Choisir un profil de calcul

Les workflows gérés s'exécutent sur des profils de calcul. Un profil de calcul est une combinaison fixe de vCPU, de mémoire et de GPU, semblable aux ressources que tu demandes à un ordonnanceur HPC. Lorsque tu téléverses un workflow, tu associes ses tailles, telles que S et M, à des profils, et chaque exécution choisit l'une de ces tailles. Le job s'exécute ensuite sur son propre nœud avec ce profil, et le conserve jusqu'à la fin du job.

Profil	vCPU	Mémoire (Go)	GPU
8x32	8	32	Aucun
16x128	16	128	Aucun
48x768	48	768	Aucun
128x1500	128	1500	Aucun
24x120x1l40s	24	120	1 L40S
20x320x2a100	20	320	2 A100
80x1200x8a100	80	1200	8 A100
160x1792x8h100	160	1792	8 H100

Un ID de profil a la forme {cpu}x{memory}, avec la mémoire en Go, ou {cpu}x{memory}x{count}{gpu} pour un profil avec GPU. Par exemple, 24x120x1l40s a 24 vCPU, 120 Go de mémoire et un GPU NVIDIA L40S.

Vérifier les profils disponibles

Pour voir quels profils sont disponibles, appelle compute_profiles() :

run_workflow_remotely.ipynb

from qiskit_ibm_catalog import ManagedWorkflowClient

client = ManagedWorkflowClient()
print(client.compute_profiles())

8x32            (8 vCPU / 32 GB)
16x128          (16 vCPU / 128 GB)
48x768          (48 vCPU / 768 GB)
128x1500        (128 vCPU / 1500 GB)
24x120x1l40s    (24 vCPU / 120 GB / 1l40s)
20x320x2a100    (20 vCPU / 320 GB / 2a100)
80x1200x8a100   (80 vCPU / 1200 GB / 8a100)
160x1792x8h100  (160 vCPU / 1792 GB / 8h100)

Rechercher un profil par ses ressources

Au lieu de saisir un ID de profil, tu peux décrire les ressources dont ton workflow a besoin avec compute_profile(), et utiliser le résultat comme valeur dans sizes_map. Passe cpu et memory en Go, et passe gpu pour un profil GPU :

run_workflow_remotely.ipynb

profile = client.compute_profile(cpu=24, memory=120, gpu="1l40s")
print(profile)  # 24x120x1l40s

sizes_map = {"S": "8x32", "L": profile}

Un sizes_map accepte des ID de profil et les profils que compute_profile() renvoie, et tu peux mélanger les deux dans un même mapping. Pour vérifier un ID de profil avant le téléversement, passe-le à compute_profile(), par exemple client.compute_profile("16x128"). Si aucun profil ne correspond, l'erreur liste les profils disponibles.

compute_profiles() renvoie une liste, tu peux donc aussi la filtrer toi-même. Par exemple, le code suivant trouve les profils GPU :

run_workflow_remotely.ipynb

gpu_profiles = [p for p in client.compute_profiles() if p.gpu]

Définir un profil de calcul par défaut pour ton workflow

La plupart des workflows commencent avec une seule taille. Associe-la à un profil avec sizes_map, et définis-la par défaut avec default_size, lorsque tu téléverses le workflow :

run_workflow_remotely.ipynb

from qiskit_ibm_catalog import ManagedWorkflow, ManagedWorkflowClient

client = ManagedWorkflowClient()

my_workflow = client.upload(
    ManagedWorkflow(
        title="my-workflow",
        entrypoint="my_workflow.py",
        working_dir="./source_files/",
        sizes_map={"M": "16x128"},
        default_size="M",
    )
)

Chaque exécution du workflow utilise ce profil, tu n'as donc pas besoin de passer de taille lorsque tu l'exécutes :

run_workflow_remotely.ipynb

job = my_workflow.run(circuits=circuits)  # Runs on 16x128

Bonne pratique : adapte les tailles à la taille des problèmes

Un workflow résout des problèmes spécifiques, et il peut nécessiter différents profils de calcul à mesure que les problèmes gagnent en échelle et en complexité. Avec un sizes_map pour chaque workflow, tu peux faire ce qui suit :

• Donner aux grands problèmes assez de ressources de calcul pour aller jusqu'au bout de l'exécution.

• Éviter que les petits problèmes n'utilisent un nœud plus grand que nécessaire.

Tu peux baser les tailles sur les facteurs qui déterminent l'utilisation de la mémoire et du CPU de ton workflow, comme la taille du sous-espace, le nombre de batches ou le nombre de qubits.

Définir les tailles

Tu peux associer jusqu'à quatre tailles, pour les problèmes petits (S), moyens (M), grands (L) et très grands (XL). Par exemple, le code suivant définit un workflow avec trois tailles :

run_workflow_remotely.ipynb

sizes_map = {"S": "8x32", "M": "16x128", "L": "128x1500"}

my_workflow = client.upload(
    ManagedWorkflow(
        title="my-workflow",
        entrypoint="my_workflow.py",
        working_dir="./source_files/",
        sizes_map=sizes_map,
        default_size="M",
    )
)

Règles de taille

Les étiquettes de taille doivent être S, M, L ou XL, un workflow peut donc définir jusqu'à quatre tailles. Un workflow géré reconnaît les étiquettes en majuscules ou en minuscules, et les stocke en majuscules. Deux tailles peuvent correspondre au même profil.

Un workflow rejette le premier téléversement dans les cas suivants :

• Une étiquette n'est pas S, M, L ou XL.

• Tu définis sizes_map sans default_size, ou default_size sans sizes_map.

• default_size n'est pas l'une des étiquettes de sizes_map.

• Une valeur de sizes_map n'est pas un profil de calcul disponible.

Modifier les tailles lors d'un nouveau téléversement

Lorsque tu téléverses de nouveau le workflow avec le même title, le workflow géré traite les tailles comme suit :

• Si tu définis sizes_map, les nouvelles tailles remplacent toutes les tailles stockées.

• Si tu omets sizes_map, le workflow conserve les tailles stockées et la valeur par défaut.

• Pour modifier uniquement la valeur par défaut, définis default_size sans sizes_map. La valeur de default_size doit être l'une des tailles stockées.

Définis default_size chaque fois que tu définis sizes_map. Un nouveau téléversement n'exige pas default_size. Si les nouvelles tailles n'incluent pas l'ancienne valeur par défaut, le workflow n'a plus de valeur par défaut, et chaque exécution sans function_size échoue.

Choisir une taille pour chaque exécution

Passe function_size à run() pour choisir l'une des tailles du workflow pour ce job. Si tu l'omets, le job utilise la taille par défaut du workflow :

run_workflow_remotely.ipynb

print(my_workflow.sizes())  # {'S': '8x32', 'M': '16x128', 'L': '128x1500'}
print(my_workflow.get_default_size())  # 'M'

job = my_workflow.run(function_size="L", circuits=circuits)  # Runs on 128x1500
job = my_workflow.run(circuits=circuits)  # Runs on the default size, M

sizes() et get_default_size() renvoient les tailles qui étaient stockées lorsque tu as chargé le workflow. Pour voir les tailles modifiées après le chargement du workflow, charge-le de nouveau.

Pour lire la taille et le profil de calcul du job, appelle get_function_size() et get_compute_profile() dans le code de ton workflow :

source_files/my_workflow.py

from qiskit_serverless import get_compute_profile, get_function_size

print(get_function_size())  # 'L'
print(get_compute_profile())  # '128x1500'

Dépanner les tailles

Problème	Cause
Le téléversement échoue avec Invalid size '...'. Valid sizes are: S, M, L, XL.	Une étiquette de sizes_map n'est pas l'une des quatre étiquettes prises en charge.
Le téléversement échoue avec Unknown compute profile '...' for size '...'.	Une valeur de sizes_map n'est pas un profil disponible. Vérifie l'ID avec compute_profiles(), ou utilise compute_profile() pour le rechercher.
compute_profile() échoue avec No compute profile matches ...	Aucun profil n'a exactement ces ressources. Pour un profil GPU, passe aussi gpu. Choisis un profil dans la liste de l'erreur.
Le téléversement échoue avec 'default_size' is required when 'sizes' is provided.	Le premier téléversement définit sizes_map sans default_size.
run() échoue avec Unknown function size '...' for this function. Available sizes: ...	Le workflow ne définit pas la taille que tu as passée à function_size.
run() échoue avec This function has no size.	Un nouveau téléversement a remplacé les tailles et supprimé la valeur par défaut. Téléverse de nouveau avec default_size, ou passe function_size.