> 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-math-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.math\_environment

## Contenu du Module

### Classes

| Nom                                                                                                            | Description                                                                                                                                                                                                                                                                                                                                                                                               |
| -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`MathEnvConfig`](#nemorlenvironmentsmathenvironmentmathenvconfig)                                             | 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 si : d = \{} for k, v in iterable: d\[k] = v dict(\*\*kwargs) -> nouveau dictionnaire initialisé avec les paires nom=valeur dans la liste d'arguments de mot-clé.  Par exemple :  dict(one=1, two=2) |
| [`HFVerifyWorker`](#nemorlenvironmentsmathenvironmenthfverifyworker)                                           | Aucun                                                                                                                                                                                                                                                                                                                                                                                                     |
| [`MultilingualMultichoiceVerifyWorker`](#nemorlenvironmentsmathenvironmentmultilingualmultichoiceverifyworker) | Aucun                                                                                                                                                                                                                                                                                                                                                                                                     |
| [`EnglishMultichoiceVerifyWorker`](#nemorlenvironmentsmathenvironmentenglishmultichoiceverifyworker)           | Aucun                                                                                                                                                                                                                                                                                                                                                                                                     |
| [`MathEnvironmentMetadata`](#nemorlenvironmentsmathenvironmentmathenvironmentmetadata)                         | 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 si : d = \{} for k, v in iterable: d\[k] = v dict(\*\*kwargs) -> nouveau dictionnaire initialisé avec les paires nom=valeur dans la liste d'arguments de mot-clé.  Par exemple :  dict(one=1, two=2) |
| [`MathEnvironment`](#nemorlenvironmentsmathenvironmentmathenvironment)                                         | Classe d'aide qui fournit un moyen standard de créer un ABC par héritage.                                                                                                                                                                                                                                                                                                                                 |

### Fonctions

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

### API

```python
class nemo_rl.environments.math_environment.MathEnvConfig
```

**Bases**: `typing.TypedDict`

```python
num_workers: int
```

**Valeur**: `None`

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

**Valeur**: `None`

```python
verifier_type: typing.Optional[str]
```

**Valeur**: `None`

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

```python
class nemo_rl.environments.math_environment.HFVerifyWorker
```

```python
verify(
    pred_responses: list[str],
    ground_truths: list[str],
    return_extracted_answer: bool = False
) -> typing.Union[list[float], tuple[list[float], list[str | None]]]
```

Vérifier l'exactitude 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 :
Union\[list\[float], tuple\[list\[float], list\[str | None]]].
Si return\_extracted\_answer est False, renvoie uniquement les scores.
Si return\_extracted\_answer est True, renvoie (scores, extracted\_answers).

```python
class nemo_rl.environments.math_environment.MultilingualMultichoiceVerifyWorker
```

```python
verify(
    pred_responses: list[str],
    ground_truths: list[str],
    return_extracted_answer: bool = False
) -> typing.Union[list[float], tuple[list[float], list[str | None]]]
```

Vérifier l'exactitude 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 :
Union\[list\[float], tuple\[list\[float], list\[str | None]]].
Si return\_extracted\_answer est False, renvoie uniquement les scores.
Si return\_extracted\_answer est True, renvoie (scores, extracted\_answers).

```python
class nemo_rl.environments.math_environment.EnglishMultichoiceVerifyWorker
```

```python
verify(
    pred_responses: list[str],
    ground_truths: list[str],
    return_extracted_answer: bool = False
) -> typing.Union[list[float], tuple[list[float], list[str | None]]]
```

Vérifier l'exactitude 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 :
Union\[list\[float], tuple\[list\[float], list\[str | None]]].
Si return\_extracted\_answer est False, renvoie uniquement les scores.
Si return\_extracted\_answer est True, renvoie (scores, extracted\_answers).

```python
class nemo_rl.environments.math_environment.MathEnvironmentMetadata
```

**Bases**: `typing.TypedDict`

```python
ground_truth: str
```

**Valeur**: `None`

```python
extracted_answer: str | None
```

**Valeur**: `None`

```python
class nemo_rl.environments.math_environment.MathEnvironment(cfg: nemo_rl.environments.math_environment.MathEnvConfig)
```

**Bases**: `nemo_rl.environments.interfaces.EnvironmentInterface[nemo_rl.environments.math_environment.MathEnvironmentMetadata]`

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

```python
step(
    message_log_batch: list[nemo_rl.data.interfaces.LLMMessageLogType],
    metadata: list[nemo_rl.environments.math_environment.MathEnvironmentMetadata],
    return_extracted_answer: bool = False
) -> nemo_rl.environments.interfaces.EnvironmentReturn[nemo_rl.environments.math_environment.MathEnvironmentMetadata]
```

Exécute une étape dans l'environnement mathématique.

Args :
message\_log : list\[list\[dict\[str, str]]]. Un lot de journaux de messages de type API OpenAI représentant des interactions avec le LLM.
metadata : list\[MathEnvironmentMetadata]. Le classificateur utilisera la clé 'ground\_truth' pour évaluer la précision. La réponse extraite sera stockée pour calculer cons\@k.

Returns :
EnvironmentReturn : Un tuple contenant :

* list\[dict\[str, str]] : Lot d'observations/réponses
* list\[dict] : Métadonnées mises à jour
* list\[str] : Prochaines chaînes d'arrêt pour le prochain tour
* Tensor : Tenseur de récompenses
* Tensor : Tenseur de drapeaux 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 de cet environnement à partir d'un lot global de rollout.

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