> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-1917.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Gérer les entrées des jobs
> Gérez et configurez par programmation les entrées des jobs, comme les hyperparamètres et les configurations basées sur des fichiers, pour les jobs W&B Launch.
L'expérience centrale de Launch consiste à tester facilement différentes entrées du job, comme des hyperparamètres et des jeux de données, puis à acheminer ces jobs vers le matériel approprié. Une fois un job créé, des utilisateurs autres que l'auteur original peuvent ajuster ces entrées via l'interface graphique de W\&B ou le CLI. Pour savoir comment définir les entrées d'un job lors du lancement depuis le CLI ou l'UI, voir le guide [Mettre des jobs en file d'attente](./add-job-to-queue).
Cette section explique comment contrôler par programmation les entrées qui peuvent être modifiées pour un job.
Par défaut, les jobs W\&B capturent l'intégralité de `Run.config` comme entrées du job, mais le SDK Launch fournit une fonction pour contrôler certaines clés de la configuration du run ou pour spécifier des fichiers JSON ou YAML comme entrées.
Les fonctions du SDK Launch nécessitent `wandb-core`. Voir le fichier [`wandb-core` README](https://github.com/wandb/wandb/blob/main/core/README) pour plus d'informations.
## Reconfigurer l’objet `Run`
L’objet `Run` renvoyé par `wandb.init()` dans un job peut, par défaut, être reconfiguré. Le SDK Launch permet de personnaliser les parties de l’objet `Run.config` qui peuvent être reconfigurées au lancement du job.
```python theme={null}
import wandb
from wandb.sdk import launch
# Requis pour l'utilisation du SDK Launch.
wandb.require("core")
config = {
"trainer": {
"learning_rate": 0.01,
"batch_size": 32,
"model": "resnet",
"dataset": "cifar10",
"private": {
"key": "value",
},
},
"seed": 42,
}
with wandb.init(config=config):
launch.manage_wandb_config(
include=["trainer"],
exclude=["trainer.private"],
)
# Etc.
```
La fonction `launch.manage_wandb_config()` configure le job pour qu'il accepte des valeurs d'entrée pour l'objet `Run.config`. Les options facultatives `include` et `exclude` prennent des préfixes de chemin au sein de l'objet de configuration imbriqué. Cela peut être utile si, par exemple, un job utilise une bibliothèque dont vous ne souhaitez pas exposer les options aux utilisateurs finaux.
Si des préfixes `include` sont fournis, seuls les chemins de la configuration qui correspondent à un préfixe `include` accepteront des valeurs d'entrée. Si des préfixes `exclude` sont fournis, les chemins correspondant à la liste `exclude` seront exclus des valeurs d'entrée. Si un chemin correspond à la fois à un préfixe `include` et à un préfixe `exclude`, le préfixe `exclude` sera prioritaire.
Dans l'exemple précédent, le chemin `["trainer.private"]` exclura la clé `private` de l'objet `trainer`, et le chemin `["trainer"]` exclura toutes les clés qui ne se trouvent pas sous l'objet `trainer`.
Utilisez un `.` précédé d'un caractère d'échappement `\` pour exclure les clés dont le nom contient un `.`.
Par exemple, `r"trainer\.private"` exclut la clé `trainer.private` plutôt que la clé `private` sous l'objet `trainer`.
Notez que le préfixe `r` ci-dessus désigne une chaîne brute.
Si le code ci-dessus est empaqueté et exécuté comme un job, les types d'entrée du job seront :
```json theme={null}
{
"trainer": {
"learning_rate": "float",
"batch_size": "int",
"model": "str",
"dataset": "str"
}
}
```
Lors du lancement du job depuis le CLI ou l’interface utilisateur W\&B, l’utilisateur ne pourra modifier que les quatre paramètres `trainer`.
### Accéder aux entrées de configuration du run
Les jobs lancés avec des entrées de configuration du run peuvent accéder à leurs valeurs via `Run.config`. Le `Run` renvoyé par `wandb.init()` dans le code du job aura automatiquement les valeurs des entrées définies. Utilisez
```python theme={null}
from wandb.sdk import launch
run_config_overrides = launch.load_wandb_config()
```
pour charger les valeurs d’entrée de la configuration du run à n’importe quel endroit dans le code du job.
## Reconfigurer un fichier
Le SDK Launch permet également de gérer les valeurs d'entrée stockées dans des fichiers de configuration au sein du code du job. Il s'agit d'une pratique courante dans de nombreux cas d'usage en deep learning et avec les grands modèles de langage, comme dans cet exemple [torchtune](https://github.com/meta-pytorch/torchtune/blob/main/recipes/configs/llama3/8B_lora.yaml) ou cette [configuration Axolotl](https://github.com/OpenAccess-AI-Collective/axolotl/blob/main/examples/llama-3/qlora-fsdp-70b.yaml).
[Sweeps on Launch](/fr/platform/launch/sweeps-on-launch/) ne prend pas en charge l'utilisation d'entrées du fichier de configuration comme paramètres de balayage. Les paramètres de balayage doivent être contrôlés via l'objet `Run.config`.
La fonction `launch.manage_config_file()` peut être utilisée pour ajouter un fichier de configuration comme entrée du job Launch, ce qui vous permet de modifier les valeurs qu'il contient au moment de lancer le job.
Par défaut, aucune entrée de configuration du run n'est capturée lorsque `launch.manage_config_file()` est utilisé. L'appel à `launch.manage_wandb_config()` remplace ce comportement.
Prenez l'exemple suivant :
```python theme={null}
import yaml
import wandb
from wandb.sdk import launch
# Requis pour l'utilisation du SDK Launch.
wandb.require("core")
launch.manage_config_file("config.yaml")
with open("config.yaml", "r") as f:
config = yaml.safe_load(f)
with wandb.init(config=config):
# Etc.
pass
```
Imaginez que le code soit exécuté avec un fichier `config.yaml` situé dans le même répertoire :
```yaml theme={null}
learning_rate: 0.01
batch_size: 32
model: resnet
dataset: cifar10
```
L’appel à `launch.manage_config_file()` ajoute le fichier `config.yaml` comme entrée du job, ce qui le rend reconfigurable lors d’un lancement depuis la CLI ou l’interface utilisateur de W\&B.
Les arguments nommés `include` et `exclude` peuvent être utilisés pour filtrer les clés d’entrée acceptées du fichier de configuration, de la même manière que `launch.manage_wandb_config()`.
### Accéder aux valeurs d’entrée du fichier de configuration
Lorsque `launch.manage_config_file()` est appelé dans un run créé par Launch, `launch` met à jour le contenu du fichier de configuration avec les valeurs d’entrée. Le fichier de configuration mis à jour est disponible dans l’environnement du job.
Appelez `launch.manage_config_file()` avant de lire le fichier de configuration dans le code du job pour vous assurer que les valeurs d’entrée sont utilisées.
### Personnaliser l’interface du volet de lancement d’un job
Définir un schéma pour les entrées d’un job vous permet de créer une interface personnalisée pour lancer ce job. Pour définir le schéma d’un job, incluez-le dans l’appel à `launch.manage_wandb_config()` ou `launch.manage_config_file()`. Le schéma peut être soit un `dict` Python au format [JSON Schema](https://json-schema.org/understanding-json-schema/reference), soit une classe de modèle Pydantic.
Les schémas d’entrée du job ne sont pas utilisés pour valider les entrées. Ils servent uniquement à définir l’interface dans le volet de lancement.
L’exemple suivant montre un schéma avec les propriétés suivantes :
* `seed`, un entier
* `trainer`, un dictionnaire avec certaines clés spécifiées :
* `trainer.learning_rate`, un flottant qui doit être supérieur à zéro
* `trainer.batch_size`, un entier qui doit être égal à 16, 64 ou 256
* `trainer.dataset`, une chaîne qui doit être soit `cifar10`, soit `cifar100`
```python theme={null}
schema = {
"type": "object",
"properties": {
"seed": {
"type": "integer"
}
"trainer": {
"type": "object",
"properties": {
"learning_rate": {
"type": "number",
"description": "Learning rate of the model",
"exclusiveMinimum": 0,
},
"batch_size": {
"type": "integer",
"description": "Number of samples per batch",
"enum": [16, 64, 256]
},
"dataset": {
"type": "string",
"description": "Name of the dataset to use",
"enum": ["cifar10", "cifar100"]
}
}
}
}
}
launch.manage_wandb_config(
include=["seed", "trainer"],
exclude=["trainer.private"],
schema=schema,
)
```
De manière générale, les attributs JSON Schema suivants sont pris en charge :
| Attribut | Requis | Notes |
| ------------------ | ------ | --------------------------------------------------------------------- |
| `type` | Oui | Doit être l’un de `number`, `integer`, `string` ou `object` |
| `title` | Non | Remplace le nom d’affichage de la propriété |
| `description` | Non | Fournit le texte d’aide de la propriété |
| `enum` | Non | Crée une liste déroulante au lieu d’un champ de texte libre |
| `minimum` | Non | Autorisé uniquement si `type` vaut `number` ou `integer` |
| `maximum` | Non | Autorisé uniquement si `type` vaut `number` ou `integer` |
| `exclusiveMinimum` | Non | Autorisé uniquement si `type` vaut `number` ou `integer` |
| `exclusiveMaximum` | Non | Autorisé uniquement si `type` vaut `number` ou `integer` |
| `properties` | Non | Si `type` vaut `object`, sert à définir des configurations imbriquées |
L’exemple suivant montre un schéma avec les propriétés suivantes :
* `seed`, un entier
* `trainer`, un schéma avec certains sous-attributs spécifiés :
* `trainer.learning_rate`, un flottant qui doit être supérieur à zéro
* `trainer.batch_size`, un entier qui doit être compris entre 1 et 256, bornes incluses
* `trainer.dataset`, une chaîne qui doit être soit `cifar10`, soit `cifar100`
```python theme={null}
class DatasetEnum(str, Enum):
cifar10 = "cifar10"
cifar100 = "cifar100"
class Trainer(BaseModel):
learning_rate: float = Field(gt=0, description="Learning rate of the model")
batch_size: int = Field(ge=1, le=256, description="Number of samples per batch")
dataset: DatasetEnum = Field(title="Dataset", description="Name of the dataset to use")
class Schema(BaseModel):
seed: int
trainer: Trainer
launch.manage_wandb_config(
include=["seed", "trainer"],
exclude=["trainer.private"],
schema=Schema,
)
```
Vous pouvez également utiliser une instance de la classe :
```python theme={null}
t = Trainer(learning_rate=0.01, batch_size=32, dataset=DatasetEnum.cifar10)
s = Schema(seed=42, trainer=t)
launch.manage_wandb_config(
include=["seed", "trainer"],
exclude=["trainer.private"],
input_schema=s,
)
```
L’ajout d’un schéma d’entrée du job crée un formulaire structuré dans le volet de lancement, ce qui facilite le lancement du job.
