Hugging Face's logo

Transformers documentation

RADIO

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2026-06-30.

FlashAttention SDPA

RADIO

RADIO (Reduce All Domains Into One) est une famille de modèles de vision de base développée par NVIDIA, entraînée par distillation multi-enseignant (par exemple CLIP, DINOv2, SAM) vers un unique backbone ViT. Il génère à la fois un embedding summary au niveau de l'image et des features spatiales denses, et prend en charge des résolutions d'entrée variables grâce à un générateur de patches Cropped Position Embedding (CPE).

L’exemple ci-dessous montre comment extraire des caractéristiques d’image avec la classe RadioModel.

RadioModel
import requests
import torch
from PIL import Image

from transformers import CLIPImageProcessor, RadioModel


hf_repo = "nvidia/C-RADIOv4-H"

device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"

model = RadioModel.from_pretrained(hf_repo)
model.eval().to(device)

image_processor = CLIPImageProcessor(
    size={"height": 224, "width": 224}, do_resize=True, do_center_crop=False, do_normalize=False
)

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
pixel_values = pixel_values.to(device)

with torch.no_grad():
    outputs = model(pixel_values)

summary = outputs.summary    # (1, 2560) image-level embedding
features = outputs.features   # (1, 196, 1280) dense spatial features

RadioConfig

classe transformers.RadioConfig

< >

( 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 = Nonehidden_size: int = 1280num_hidden_layers: int = 32num_attention_heads: int = 16mlp_ratio: float = 4.0hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06attention_probs_dropout_prob: float = 0.0hidden_dropout_prob: float = 0.0drop_path_rate: float = 0.0use_swiglu_ffn: bool = Falseqkv_bias: bool = Truelayerscale_value: float = 1.0num_channels: int = 3patch_size: int = 16image_size: int = 224max_img_size: int = 2048num_cls_tokens: int = 3num_registers: int = 7video_temporal_patch_size: int | None = Nonepatch_dim: int | None = Nonevideo_patch_dim: int | None = Nonesummary_idxs: list[int] | None = Nonenorm_mean: list[float] | tuple[float, float, float] = (0.48145466, 0.4578275, 0.40821073)norm_std: list[float] | tuple[float, float, float] = (0.26862954, 0.26130258, 0.27577711)initializer_range: float = 0.02 )

Paramètres

  • hidden_size (int, facultatif, par défaut 1280) — Dimension des représentations cachées.
  • num_hidden_layers (int, facultatif, par défaut 32) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • mlp_ratio (float, facultatif, valeur par défaut 4.0) — Ratio de la taille cachée du MLP par rapport à hidden_size.
  • hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de couche.
  • attention_probs_dropout_prob (float, facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • hidden_dropout_prob (float, facultatif, valeur par défaut 0.0) — La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l’encodeur et du pooler.
  • drop_path_rate (float, facultatif, valeur par défaut 0.0) — Taux de drop path pour la fusion des patches.
  • use_swiglu_ffn (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser un réseau feed-forward SwiGLU dans les couches encodeur plutôt que le MLP standard.
  • qkv_bias (bool, facultatif, par défaut True) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs.
  • layerscale_value (float, facultatif, valeur par défaut 1.0) — Valeur initiale des paramètres LayerScale. C-RADIO n'utilise pas de LayerScale ; la valeur par défaut de 1.0 rend le LayerScale (hérité) une opération identité.
  • num_channels (int, facultatif, par défaut 3) — Le nombre de canaux d'entrée.
  • patch_size (int, facultatif, par défaut 16) — La taille (résolution) de chaque patch.
  • image_size (int, facultatif, par défaut 224) — La taille (résolution) de chaque image.
  • max_img_size (int, facultatif, valeur par défaut : 2048) — Taille maximale d'image prise en charge (en pixels) utilisée pour dimensionner le tableau d'incorporation de position du générateur de patch CPE.
  • num_cls_tokens (int, facultatif, valeur par défaut : 3) — Nombre de jetons de classe (résumé) appris préfixés à la séquence de patches.
  • num_registers (int, facultatif, valeur par défaut : 7) — Nombre de jetons de registre appris préfixés à la séquence de patches.
  • video_temporal_patch_size (int, facultatif) — Nombre d’images empilées dans le temps par patch. Lorsqu’il est défini, le générateur de patches crée également un video_patch_projection pour les patches vidéo empilés dans le temps ; None désactive le chemin vidéo.
  • patch_dim (int, facultatif) — Taille aplatie d'un patch d'image. Déduite de num_channels et patch_size.
  • video_patch_dim (int, facultatif) — Taille aplatie d'un patch vidéo temporellement groupé. Déduite de video_temporal_patch_size et de patch_dim ; None pour les points de contrôle dédiés aux images.
  • summary_idxs (list[int], facultatif, par défaut [0, 1]) — Indices des jetons de classe à collecter et aplatir dans l’embedding de sortie summary.
  • norm_mean (tuple[float, float, float], facultatif, par défaut OPENAI_CLIP_MEAN) — Moyenne par canal utilisée par le conditionneur d'entrée pour normaliser les valeurs de pixels.
  • norm_std (tuple[float, float, float], facultatif, valeur par défaut OPENAI_CLIP_STD) — Écart-type par canal utilisé par le conditionneur d'entrée pour normaliser les valeurs de pixels.
  • initializer_range (float, facultatif, par défaut 0.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 RadioModel. Elle est utilisée pour instancier un modèle Radio en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de nvidia/C-RADIOv4-H

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.

RadioModel

classe transformers.RadioModel

< >

( config: RadioConfig )

Paramètres

  • config (RadioConfig) — 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.

Le modèle Radio brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

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

< >

( pixel_values: Tensorimage_grid_hw: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → RadioModelOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, height, width) ou (total_patches, num_channels * patch_size**2)) — Images de taille unique, ou, avec image_grid_hw, les patches aplatis d’images de tailles différentes concaténés. Chaque patch est organisé par canal, c’est-à-dire (num_channels, patch_size, patch_size).
  • image_grid_hw (torch.LongTensor de forme (num_images, 2), facultatif) — Grille de patches (height, width) de chaque image dans pixel_values empilés.

Retourne

RadioModelOutput ou tuple(torch.Tensor)

Un RadioModelOutput 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 (RadioConfig) et des entrées.

La méthode forward de RadioModel 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 Module plutô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.

  • résumé (torch.Tensor de forme (batch_size, num_summary_idxs * hidden_size)) — Embedding de résumé aplati, collecté à partir des jetons cls sélectionnés par config.summary_idxs.

  • features (torch.Tensor de forme (batch_size, num_patches, hidden_size)) — Caractéristiques spatiales denses des patches. Pour les entrées empilées (image_grid_hw fourni), les caractéristiques des patches de toutes les images concaténées, de forme (total_patches, hidden_size).

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence complète de jetons (jetons de préfixe + patches) de la couche d'encodeur finale. Pour les entrées empilées, les séquences de toutes les images concaténées, de forme (total_sequence_length, hidden_size).

  • hidden_states (tuple[torch.Tensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple[torch.Tensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    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.

Update on GitHub

←Pyramid Vision Transformer v2 (PVTv2) RegNet→