# RADIO

[RADIO](https://huggingface.co/papers/2312.06709) (Reduce All Domains Into One) es una familia de modelos de visión de base de NVIDIA entrenados mediante destilación multi-mentor (p. ej. CLIP, DINOv2, SAM) en un único backbone ViT. Genera tanto un embedding de `summary` a nivel de imagen como `features` espaciales densas, y admite resoluciones de entrada variables a través de un generador de parches de Cropped Position Embedding (CPE).

El siguiente ejemplo demuestra cómo extraer características de imagen con la clase [RadioModel](/docs/transformers/v5.23.0/es/model_doc/radio#transformers.RadioModel).

```python
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[[transformers.RadioConfig]]

#### transformers.RadioConfig[[transformers.RadioConfig]]

```python
transformers.RadioConfig(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, hidden_size: int = 1280, num_hidden_layers: int = 32, num_attention_heads: int = 16, mlp_ratio: float = 4.0, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, attention_probs_dropout_prob: float = 0.0, hidden_dropout_prob: float = 0.0, drop_path_rate: float = 0.0, use_swiglu_ffn: bool = False, qkv_bias: bool = True, layerscale_value: float = 1.0, num_channels: int = 3, patch_size: int = 16, image_size: int = 224, max_img_size: int = 2048, num_cls_tokens: int = 3, num_registers: int = 7, video_temporal_patch_size: int | None = None, patch_dim: int | None = None, video_patch_dim: int | None = None, summary_idxs: list[int] | None = None, norm_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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/radio/configuration_radio.py#L28)

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado `1280`) : Dimensión de las representaciones ocultas.

num_hidden_layers (`int`, *opcional*, valor predeterminado `32`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `16`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

mlp_ratio (`float`, *opcional*, valor predeterminado 4.0) : Proporción del tamaño oculto del MLP en relación con `hidden_size`.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas.

attention_probs_dropout_prob (`float`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

hidden_dropout_prob (`float`, *opcional*, valor predeterminado `0.0`) : La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings, el codificador y el pooler.

drop_path_rate (`float`, *opcional*, valor predeterminado `0.0`) : Tasa de drop path para la fusión de parches.

use_swiglu_ffn (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe utilizar una red feed-forward SwiGLU en las capas del codificador en lugar del MLP estándar.

qkv_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir un sesgo a las consultas, claves y valores.

layerscale_value (`float`, *opcional*, valor predeterminado 1.0) : Valor inicial para los parámetros de LayerScale. C-RADIO no tiene LayerScale; el valor predeterminado de `1.0` convierte la LayerScale (heredada) en una operación de identidad.

num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada.

patch_size (`int`, *opcional*, valor predeterminado `16`) : El tamaño (resolución) de cada parche.

image_size (`int`, *opcional*, valor predeterminado `224`) : El tamaño (resolución) de cada imagen.

max_img_size (`int`, *opcional*, valor predeterminado 2048) : Tamaño máximo de imagen admitido (en píxeles) utilizado para dimensionar la tabla de incrustaciones de posición del generador de parches CPE.

num_cls_tokens (`int`, *opcional*, valor predeterminado 3) : Número de tokens de clase (resumen) aprendidos que se añaden al inicio de la secuencia de parches.

num_registers (`int`, *opcional*, valor predeterminado 7) : Número de tokens de registro aprendidos que se añaden al inicio de la secuencia de parches.

video_temporal_patch_size (`int`, *opcional*) : Número de fotogramas apilados temporalmente por parche. Cuando se establece, el generador de parches también crea un `video_patch_projection` para parches de video empaquetados temporalmente; `None` deshabilita la ruta de video.

patch_dim (`int`, *opcional*) : Tamaño aplanado de un parche de imagen. Derivado de `num_channels` y `patch_size`.

video_patch_dim (`int`, *opcional*) : Tamaño aplanado de un parche de video empaquetado temporalmente. Derivado de `video_temporal_patch_size` y `patch_dim`; `None` para puntos de control solo de imagen.

summary_idxs (`list[int]`, *opcional*, valor predeterminado `[0, 1]`) : Índices de los tokens de clase que se recopilarán y aplanarán en la incrustación de salida `summary`.

norm_mean (`tuple[float, float, float]`, *opcional*, valor predeterminado `OPENAI_CLIP_MEAN`) : Media por canal utilizada por el acondicionador de entrada para normalizar los valores de píxeles.

norm_std (`tuple[float, float, float]`, *opcional*, valor predeterminado `OPENAI_CLIP_STD`) : Desviación estándar por canal que utiliza el acondicionador de entrada para normalizar los valores de píxeles.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

Esta es la clase de configuración para almacenar la configuración de un RadioModel. Se utiliza para instanciar un modelo Radio según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [nvidia/C-RADIOv4-H](https://huggingface.co/nvidia/C-RADIOv4-H)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## RadioModel[[transformers.RadioModel]]

#### transformers.RadioModel[[transformers.RadioModel]]

```python
transformers.RadioModel(config: RadioConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/radio/modeling_radio.py#L434)

**Parámetros:**

config ([RadioConfig](/docs/transformers/v5.23.0/es/model_doc/radio#transformers.RadioConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Radio básico que genera estados ocultos sin ninguna cabeza específica en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.RadioModel.forward]]

```python
forward(pixel_values: Tensor, image_grid_hw: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/radio/modeling_radio.py#L454)

**Parámetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` o `(total_patches, num_channels * patch_size**2)`) : Imágenes de un mismo tamaño o, con `image_grid_hw`, los parches aplanados de imágenes de diferentes tamaños concatenados. Cada parche se organiza con el canal como dimensión principal, es decir, `(num_channels, patch_size, patch_size)`.

image_grid_hw (`torch.LongTensor` de forma `(num_images, 2)`, *opcional*) : Cuadrícula de parches `(height, width)` de cada imagen en `pixel_values` empaquetados.

**Devuelve:** `RadioModelOutput` o `tuple(torch.Tensor)`

Un `RadioModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([RadioConfig](/docs/transformers/v5.23.0/es/model_doc/radio#transformers.RadioConfig)) y las entradas.

El método forward de [RadioModel](/docs/transformers/v5.23.0/es/model_doc/radio#transformers.RadioModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **resumen** (`torch.Tensor` de forma `(batch_size, num_summary_idxs * hidden_size)`) -- Embedding de resumen aplanado, recopilado de los tokens cls seleccionados por `config.summary_idxs`.
- **características** (`torch.Tensor` de forma `(batch_size, num_patches, hidden_size)`) -- Características espaciales densas de parches. Para entradas empaquetadas (se proporciona `image_grid_hw`), las características de parches de todas las imágenes concatenadas, de forma `(total_patches, hidden_size)`.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia completa de tokens (tokens de prefijo + parches) de la capa final del codificador. Para entradas empaquetadas, las secuencias de todas las imágenes concatenadas, de forma `(total_sequence_length, hidden_size)`.
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

