> 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-models-generation-vllm-vllm-worker/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.models.generation.vllm.vllm\_worker

## Module Contents

### Classes

| Name                                                                                        | Description |
| ------------------------------------------------------------------------------------------- | ----------- |
| [`BaseVllmGenerationWorker`](#nemorlmodelsgenerationvllmvllmworkerbasevllmgenerationworker) | Aucun       |
| [`VllmGenerationWorker`](#nemorlmodelsgenerationvllmvllmworkervllmgenerationworker)         | Aucun       |

### API

```python
class nemo_rl.models.generation.vllm.vllm_worker.BaseVllmGenerationWorker(config: nemo_rl.models.generation.vllm.config.VllmConfig, bundle_indices: typing.Optional[list[int]] = None, fraction_of_gpus: float = 1.0, seed: typing.Optional[int] = None)
```

```python
__repr__() -> str
```

Personnalise le préfixe de l'acteur dans les journaux de Ray.

Cela facilite l'identification du worker qui produit des messages de journal spécifiques.

```python
configure_worker(
    num_gpus: int | float,
    bundle_indices: typing.Optional[tuple[int, list[int]]] = None
) -> tuple[dict[str, typing.Any], dict[str, str], dict[str, typing.Any]]
```

Fournit la configuration complète du worker pour le parallélisme tensoriel et par pipeline de vLLM.

Cette méthode configure le worker en fonction de son rôle dans le parallélisme tensoriel et par pipeline,
qui est déterminé directement à partir du paramètre bundle\_indices.

Args:
num\_gpus : Allocation GPU originale pour ce worker basée sur le groupe de placement
bundle\_indices : Tuple de (node\_idx, local\_bundle\_indices) pour le parallélisme (le cas échéant)

Returns:
tuple avec la configuration complète du worker :

* 'resources' : Allocation de ressources (par exemple, num\_gpus)
* 'env\_vars' : Variables d'environnement pour ce worker
* 'init\_kwargs' : Paramètres à passer à **init** du worker

```python
llm()
```

```python
is_alive()
```

Vérifier si le worker est actif.

```python
_merge_stop_strings(batch_stop_strings)
```

```python
_build_sampling_params(
    *,
    greedy: bool,
    stop_strings,
    max_new_tokens: typing.Optional[int] = None
)
```

```python
start_gpu_profiling() -> None
```

Démarrer le profilage GPU.

```python
stop_gpu_profiling() -> None
```

Arrêter le profilage GPU.

```python
class nemo_rl.models.generation.vllm.vllm_worker.VllmGenerationWorker(config: nemo_rl.models.generation.vllm.config.VllmConfig, bundle_indices: typing.Optional[list[int]] = None, fraction_of_gpus: float = 1.0, seed: typing.Optional[int] = None)
```

**Bases** : `nemo_rl.models.generation.vllm.vllm_worker.BaseVllmGenerationWorker`

```python
_create_engine(llm_kwargs: dict[str, typing.Any]) -> None
```

```python
post_init()
```

```python
init_collective(
    rank_prefix: int,
    ip: str,
    port: int,
    world_size: int
) -> None
```

```python
generate(
    data: nemo_rl.distributed.batched_data_dict.BatchedDataDict[nemo_rl.models.generation.interfaces.GenerationDatumSpec],
    greedy: bool = False
) -> nemo_rl.distributed.batched_data_dict.BatchedDataDict[nemo_rl.models.generation.interfaces.GenerationOutputSpec]
```

Générer un lot de données à l'aide de la génération vLLM.

Args:
data: BatchedDataDict contenant les tenseurs input\_ids et input\_lengths
greedy: Indique s'il faut utiliser le décodage gourmand au lieu de l'échantillonnage

Returns:
BatchedDataDict conforme à GenerationOutputSpec :

* output\_ids : ID de tokens d'entrée + générés avec un remplissage approprié
* logprobs : Logarithmes des probabilités des tokens
* generation\_lengths : Longueurs de chaque réponse
* unpadded\_sequence\_lengths : Longueurs de chaque séquence d'entrée + générée

```python
generate_text(
    data: nemo_rl.distributed.batched_data_dict.BatchedDataDict[nemo_rl.models.generation.interfaces.GenerationDatumSpec],
    greedy: bool = False
) -> nemo_rl.distributed.batched_data_dict.BatchedDataDict[nemo_rl.models.generation.interfaces.GenerationOutputSpec]
```

Générer des réponses textuelles à l'aide de la génération vLLM.

Args:
data: BatchedDataDict contenant des invites avec des chaînes de texte
greedy: Indique s'il faut utiliser le décodage gourmand au lieu de l'échantillonnage

Returns:
BatchedDataDict contenant :

* texts : Liste de réponses textuelles générées