# RADIO

[RADIO](https://huggingface.co/papers/2312.06709) (Reduce All Domains Into One) é uma família de modelos de visão fundacionais da NVIDIA, treinada por destilação multi-mentor (por exemplo, CLIP, DINOv2, SAM) em um único backbone ViT. Ela produz tanto um embedding de `summary` no nível da imagem quanto `features` espaciais densas, e suporta resoluções de entrada variáveis por meio de um gerador de patches Cropped Position Embedding (CPE).

O exemplo abaixo demonstra como extrair recursos de imagem com a classe [RadioModel](/docs/transformers/main/pt/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)
```

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

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `1280`) : Dimensão das representações ocultas.

num_hidden_layers (`int`, *opcional*, padrão `32`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

mlp_ratio (`float`, *opcional*, padrão 4.0) : Razão do tamanho oculto do MLP em relação a `hidden_size`.

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

layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada.

attention_probs_dropout_prob (`float`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

hidden_dropout_prob (`float`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.

drop_path_rate (`float`, *opcional*, padrão `0.0`) : Taxa de drop path para a fusão de patches.

use_swiglu_ffn (`bool`, *opcional*, padrão `False`) : Se deve usar uma rede feed-forward SwiGLU nas camadas do codificador em vez do MLP padrão.

qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values.

layerscale_value (`float`, *opcional*, padrão 1.0) : Valor inicial para os parâmetros de LayerScale. O C-RADIO não possui LayerScale; o padrão de `1.0` torna o LayerScale (herdado) uma operação de identidade.

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

patch_size (`int`, *opcional*, padrão `16`) : O tamanho (resolução) de cada patch.

image_size (`int`, *opcional*, padrão `224`) : O tamanho (resolução) de cada imagem.

max_img_size (`int`, *opcional*, padrão 2048) : Tamanho máximo de imagem suportado (em pixels) usado para dimensionar a tabela de incorporação de posição do gerador de patches CPE.

num_cls_tokens (`int`, *opcional*, padrão 3) : Número de tokens de classe (resumo) aprendidos adicionados à sequência de patches.

num_registers (`int`, *opcional*, padrão 7) : Número de tokens de registro aprendidos adicionados à sequência de patches.

video_temporal_patch_size (`int`, *opcional*) : Número de frames empilhados temporalmente por patch. Quando definido, o gerador de patches também constrói um `video_patch_projection` para patches de vídeo empacotados temporalmente; `None` desativa o caminho de vídeo.

patch_dim (`int`, *opcional*) : Tamanho achatado de um patch de imagem. Derivado de `num_channels` e `patch_size`.

video_patch_dim (`int`, *opcional*) : Tamanho achatado de um patch de vídeo empacotado temporalmente. Derivado de `video_temporal_patch_size` e `patch_dim`; `None` para checkpoints apenas de imagem.

summary_idxs (`list[int]`, *opcional*, padrão `[0, 1]`) : Índices dos tokens de classe a serem reunidos e achatados no embedding de saída `summary`.

norm_mean (`tuple[float, float, float]`, *opcional*, padrão `OPENAI_CLIP_MEAN`) : Média por canal usada pelo condicionador de entrada para normalizar os valores de pixels.

norm_std (`tuple[float, float, float]`, *opcional*, padrão `OPENAI_CLIP_STD`) : Desvio padrão por canal usado pelo condicionador de entrada para normalizar os valores de pixels.

initializer_range (`float`, *opcional*, padrão `0.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 RadioModel. Ela é usada para instanciar um modelo Radio 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 [nvidia/C-RADIOv4-H](https://huggingface.co/nvidia/C-RADIOv4-H)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## RadioModel[[transformers.RadioModel]]

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

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

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

**Parâmetros:**

config ([RadioConfig](/docs/transformers/main/pt/model_doc/radio#transformers.RadioConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

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

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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.RadioModel.forward]]

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

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

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` ou `(total_patches, num_channels * patch_size**2)`) : Imagens de um único tamanho ou, com `image_grid_hw`, os patches achatados de imagens de tamanhos diferentes concatenados. Cada patch é organizado com prioridade para o canal, ou seja, `(num_channels, patch_size, patch_size)`.

image_grid_hw (`torch.LongTensor` de shape `(num_images, 2)`, *opcional*) : Grade de patches `(height, width)` de cada imagem nos `pixel_values` empacotados.

**Retorna:** `RadioModelOutput` ou `tuple(torch.Tensor)`

Um `RadioModelOutput` 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 ([RadioConfig](/docs/transformers/main/pt/model_doc/radio#transformers.RadioConfig)) e das entradas.

O método forward da [RadioModel](/docs/transformers/main/pt/model_doc/radio#transformers.RadioModel) 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.

- **resumo** (`torch.Tensor` de forma `(batch_size, num_summary_idxs * hidden_size)`) -- Embedding de resumo achatado, coletado dos tokens cls selecionados por `config.summary_idxs`.
- **features** (`torch.Tensor` de forma `(batch_size, num_patches, hidden_size)`) -- Recursos de patches espaciais densos. Para entradas empacotadas (`image_grid_hw` fornecido), os recursos de patches de todas as imagens concatenados, de forma `(total_patches, hidden_size)`.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência completa de tokens (tokens de prefixo + patches) da camada final do codificador. Para entradas empacotadas, as sequências de todas as imagens concatenadas, de forma `(total_sequence_length, hidden_size)`.
- **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) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.