> 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-environments-vlm-environment/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.environments.vlm\_environment

## Contenu du module

### Classes

| Nom                                                                                 | Description                                                                                                                                                                                                                                                                                                                                                                                                   |
| ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`VLMEnvConfig`](#nemorlenvironmentsvlmenvironmentvlmenvconfig)                     | dict() -> nouveau dictionnaire vide dict(mapping) -> nouveau dictionnaire initialisé à partir des paires (clé, valeur) d'un objet de mappage dict(iterable) -> nouveau dictionnaire initialisé comme suit : d = \{} for k, v in iterable: d\[k] = v dict(\*\*kwargs) -> nouveau dictionnaire initialisé avec les paires nom=valeur dans la liste des arguments de mot-clé.  Par exemple :  dict(one=1, two=2) |
| [`VLMVerifyWorker`](#nemorlenvironmentsvlmenvironmentvlmverifyworker)               | Aucun                                                                                                                                                                                                                                                                                                                                                                                                         |
| [`VLMEnvironmentMetadata`](#nemorlenvironmentsvlmenvironmentvlmenvironmentmetadata) | dict() -> nouveau dictionnaire vide dict(mapping) -> nouveau dictionnaire initialisé à partir des paires (clé, valeur) d'un objet de mappage dict(iterable) -> nouveau dictionnaire initialisé comme suit : d = \{} for k, v in iterable: d\[k] = v dict(\*\*kwargs) -> nouveau dictionnaire initialisé avec les paires nom=valeur dans la liste des arguments de mot-clé.  Par exemple :  dict(one=1, two=2) |
| [`VLMEnvironment`](#nemorlenvironmentsvlmenvironmentvlmenvironment)                 | Classe d'aide qui fournit un moyen standard de créer un ABC par héritage.                                                                                                                                                                                                                                                                                                                                     |

### Fonctions

| Nom                                                           | Description |
| ------------------------------------------------------------- | ----------- |
| [`_mute_output`](#nemorlenvironmentsvlmenvironmentmuteoutput) | Aucun       |

### API

```python
class nemo_rl.environments.vlm_environment.VLMEnvConfig
```

**Bases** : `typing.TypedDict`

```python
num_workers: int
```

**Valeur** : `None`

```python
stop_strings: typing.Optional[list[str]]
```

**Valeur** : `None`

```python
reward_functions: typing.List[dict[str, typing.Any]]
```

**Valeur** : `None`

```python
nemo_rl.environments.vlm_environment._mute_output()
```

```python
class nemo_rl.environments.vlm_environment.VLMVerifyWorker(cfg: nemo_rl.environments.vlm_environment.VLMEnvConfig)
```

```python
verify(
    pred_responses: list[str], ground_truths: list[str]
) -> list[float]
```

Vérifie la correction des réponses prédites par rapport à la vérité terrain.

Args :
pred\_responses : list\[str]. Les réponses prédites par le LLM.
ground\_truths : list\[str]. Les réponses de vérité terrain.

Returns :
list\[float]. Les récompenses pour chaque réponse prédite.

```python
class nemo_rl.environments.vlm_environment.VLMEnvironmentMetadata
```

**Bases** : `typing.TypedDict`

```python
ground_truth: str
```

**Valeur** : `None`

```python
class nemo_rl.environments.vlm_environment.VLMEnvironment(cfg: nemo_rl.environments.vlm_environment.VLMEnvConfig)
```

**Bases** : `nemo_rl.environments.interfaces.EnvironmentInterface`

```python
shutdown() -> None
```

```python
step(
    message_log_batch: list[list[dict[str, str]]],
    metadata: list[nemo_rl.environments.vlm_environment.VLMEnvironmentMetadata]
) -> nemo_rl.environments.interfaces.EnvironmentReturn
```

Exécute une étape dans l'environnement VLM.

Args :
message\_log : list\[list\[dict\[str, str]]]. Un lot de journaux de messages de type API OpenAI qui représentent des interactions avec le VLM.
metadata : list\[VLMEnvironmentMetadata]. L'évaluateur utilisera la clé 'ground\_truth' pour évaluer la correction.

Returns :
EnvironmentReturn : Un tuple contenant :

* list\[dict\[str, str]] : Lot d'observations/réponses
* list\[dict] : Métadonnées mises à jour
* list\[str] : Chaînes d'arrêt suivantes pour le prochain tour
* Tensor : Tenseur de récompenses
* Tensor : Indicateurs de fin

```python
global_post_process_and_metrics(batch: nemo_rl.distributed.batched_data_dict.BatchedDataDict[typing.Any]) -> tuple[nemo_rl.distributed.batched_data_dict.BatchedDataDict[typing.Any], dict[str, float | int]]
```

Calcule les métriques pour cet environnement à partir d'un lot global de déploiement.

Chaque rang exécutera cette fonction, vous pouvez donc utiliser des calculs distribués si vous le préférez pour des métriques lourdes.