> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://fr.nvidia-localization.ferndocs.com/fr/nemo/rl/latest/nemo-rl-data-multimodal-utils/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://fr.nvidia-localization.ferndocs.com/_mcp/server.

# nemo\_rl.data.multimodal\_utils

## Contenu du Module

### Classes

| Nom                                                      | Description                                                                                                 |
| -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| [`PackedTensor`](#nemorldatamultimodalutilspackedtensor) | Enveloppe autour d'une liste de tensors torch et d'une dimension le long de laquelle assembler les tensors. |

### Fonctions

| Nom                                                                                              | Description                                                                                    |
| ------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------- |
| [`get_multimodal_keys_from_processor`](#nemorldatamultimodalutilsgetmultimodalkeysfromprocessor) | Obtenir les clés des données multimodales pouvant être utilisées comme entrées du modèle.      |
| [`get_dim_to_pack_along`](#nemorldatamultimodalutilsgetdimtopackalong)                           | Considérations spéciales pour l'assemblage de certaines clés à partir de certains processeurs. |

### API

```python
class nemo_rl.data.multimodal_utils.PackedTensor(tensors: typing.Union[torch.Tensor, list[torch.Tensor]], dim_to_pack: int)
```

Enveloppe autour d'une liste de tensors torch et d'une dimension le long de laquelle assembler les tensors.

Cette classe est utilisée pour envelopper une liste de tensors avec un paramètre `dim_to_pack`.
Elle peut être utilisée pour des données qui peuvent être assemblées le long de différentes dimensions (comme des données multimodales).

`dim_to_pack` est utilisé pour spécifier la dimension le long de laquelle assembler les tensors.

La liste des tensors peut être renvoyée comme un seul tensor assemblé en appelant `as_tensor` qui concatènera les tensors le long de la dimension `dim_to_pack`.

```python
as_tensor(device: typing.Optional[torch.device] = None) -> torch.Tensor
```

```python
__len__() -> int
```

```python
to(device: str | torch.device) -> nemo_rl.data.multimodal_utils.PackedTensor
```

```python
slice(indices: typing.Union[list[int], torch.Tensor]) -> nemo_rl.data.multimodal_utils.PackedTensor
```

```python
concat(from_packed_tensors: list[nemo_rl.data.multimodal_utils.PackedTensor]) -> nemo_rl.data.multimodal_utils.PackedTensor
```

Concatène une liste d'objets PackedTensor en un seul PackedTensor.

Les tensors sous-jacents des PackedTensors sont combinés dans une seule liste de tensors et utilisés pour créer un nouveau PackedTensor.

Chaque batch doit avoir le même dim\_to\_pack.

Exemple :

```python
>>> import torch
>>> from nemo_rl.data.multimodal_utils import PackedTensor
>>> p1 = PackedTensor([torch.tensor([1, 2, 3]), torch.tensor([4, 5, 6])], dim_to_pack=0)
>>> p2 = PackedTensor([torch.tensor([7, 8, 9])], dim_to_pack=0)
>>> p3 = PackedTensor.concat([p1, p2])
>>> p3.tensors
[tensor([1, 2, 3]), tensor([4, 5, 6]), tensor([7, 8, 9])]
>>> p3.as_tensor()
tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>>
```

```python
flattened_concat(from_packed_tensors: list[nemo_rl.data.multimodal_utils.PackedTensor]) -> nemo_rl.data.multimodal_utils.PackedTensor
```

Étant donné une liste d'objets PackedTensor, aplatit chaque PackedTensor puis les concatène en un seul PackedTensor.

Chaque PackedTensor est d'abord aplati en assemblant le long de la dimension `dim_to_pack` du PackedTensor. Ensuite, les tensors aplatis résultants sont utilisés pour créer un nouveau PackedTensor.

Ceci est différent de `PackedTensor.concat` qui étend simplement la liste sous-jacente des tensors. Ceci est important car les méthodes `slice` et `__len__` opèrent sur la liste sous-jacente des tensors. Notez cependant qu'appeler `as_tensor` sur le PackedTensor résultant donnera le même tensor que `concat`.

Chaque batch doit avoir le même dim\_to\_pack.

Exemple :

```python
>>> import torch
>>> from nemo_rl.data.multimodal_utils import PackedTensor
>>> p1 = PackedTensor([torch.tensor([1, 2, 3]), torch.tensor([4, 5, 6])], dim_to_pack=0)
>>> p2 = PackedTensor([torch.tensor([7, 8, 9])], dim_to_pack=0)
>>> p3 = PackedTensor.flattened_concat([p1, p2])
>>> p3.tensors
[tensor([1, 2, 3, 4, 5, 6]), tensor([7, 8, 9])]
>>> p3.as_tensor()
tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>>
```

```python
nemo_rl.data.multimodal_utils.get_multimodal_keys_from_processor(processor) -> list[str]
```

Obtenir les clés des données multimodales pouvant être utilisées comme entrées du modèle.

Cela sera utilisé dans la fonction de traitement des données pour déterminer quelles clés utiliser comme entrées du modèle.

```python
nemo_rl.data.multimodal_utils.get_dim_to_pack_along(
    processor, key: str
) -> int
```

Considérations spéciales pour l'assemblage de certaines clés à partir de certains processeurs.

Dans la plupart des cas, les éléments assemblés sont le long de la dimension 0