Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Exécution de plusieurs programmes

Amazon Braket propose deux approches pour exécuter efficacement plusieurs programmes quantiques : les ensembles de programmes et le traitement par lots de tâches quantiques.

Les ensembles de programmes constituent la méthode préférée pour exécuter des charges de travail avec plusieurs programmes. Ils vous permettent de regrouper plusieurs programmes dans une seule tâche quantique Amazon Braket. Les ensembles de programmes permettent d'améliorer les performances et de réaliser des économies par rapport à la soumission individuelle de programmes, en particulier lorsque le nombre d'exécutions de programmes approche les 100.

Actuellement, IQM et les Rigetti appareils prennent en charge les ensembles de programmes. Avant de soumettre des ensembles de programmes à QPUs, il est recommandé de les tester d'abord sur le simulateur local Amazon Braket. Pour vérifier si un appareil prend en charge les ensembles de programmes, vous pouvez consulter ses propriétés à l'aide du SDK Amazon Braket ou consulter la page de l'appareil dans la console Amazon Braket.

L'exemple suivant montre comment exécuter un ensemble de programmes.

from math import pi
from braket.devices import LocalSimulator
from braket.program_sets import ProgramSet
from braket.circuits import Circuit

program_set = ProgramSet([
    Circuit().h(0).cnot(0,1),
    Circuit().rx(0, pi/4).ry(1, pi/8).cnot(1,0),
    Circuit().t(0).t(1).cz(0,1).s(0).cz(1,2).s(1).s(2),
])

device = LocalSimulator()
result = device.run(program_set, shots=300).result()
print(result[0][0].counts)  # The result of the first program in the program set

Pour en savoir plus sur les différentes manières de créer un ensemble de programmes (par exemple, créer un ensemble de programmes à partir de nombreux observables ou paramètres avec un seul programme) et de récupérer les résultats d'un ensemble de programmes, consultez la section sur les ensembles de programmes du guide du développeur Amazon Braket et le dossier des ensembles de programmes dans le référentiel Github des exemples de Braket.

Le traitement par lots de tâches quantiques est disponible sur tous les appareils Amazon Braket. Le traitement par lots est particulièrement utile pour les tâches quantiques que vous exécutez sur les simulateurs à la demande (DM1ouTN1)SV1, car ils peuvent traiter plusieurs tâches quantiques en parallèle. Le traitement par lots vous permet de lancer des tâches quantiques en parallèle. Par exemple, si vous souhaitez effectuer un calcul qui nécessite 10 tâches quantiques et que les programmes de ces tâches quantiques sont indépendants les uns des autres, il est recommandé d'utiliser le traitement par lots de tâches. Utilisez le traitement par lots de tâches quantiques lorsque vous exécutez des charges de travail avec plusieurs programmes sur un appareil qui ne prend pas en charge les ensembles de programmes.

L'exemple suivant montre comment exécuter un lot de tâches quantiques.

from braket.circuits import Circuit
from braket.devices import LocalSimulator

bell = Circuit().h(0).cnot(0, 1)
circuits = [bell for _ in range(5)]

device = LocalSimulator()
batch = device.run_batch(circuits, shots=100)
print(batch.results()[0].measurement_counts)  # The result of the first quantum task in the batch

Pour des informations plus spécifiques sur le traitement par lots, consultez les exemples d'Amazon Braket sur. GitHub

À propos de l'ensemble du programme et des coûts

Les ensembles de programmes exécutent efficacement plusieurs programmes quantiques en regroupant jusqu'à 100 programmes ou ensembles de paramètres dans une seule tâche quantique. Avec les ensembles de programmes, vous ne payez qu'un seul frais par tâche, plus les frais par plan basés sur le nombre total de prises de vue pour tous les programmes, ce qui réduit considérablement les coûts par rapport à la soumission de programmes individuels. Cette approche est particulièrement avantageuse pour les charges de travail impliquant de nombreux programmes et un faible nombre de prises par programme. Les ensembles de programmes sont actuellement pris en charge sur Rigetti les appareils IQM et sur le simulateur local Amazon Braket.

Pour plus d'informations, consultez la section Ensembles de programmes pour connaître les étapes de mise en œuvre détaillées, les meilleures pratiques et des exemples de code.

À propos du traitement par lots de tâches quantiques et des coûts

Quelques mises en garde à l'esprit concernant le traitement par lots de tâches quantiques et les coûts de facturation :

Traitement par lots de tâches quantiques et PennyLane

Tirez parti du traitement par lots lorsque vous l'utilisez PennyLane sur Amazon Braket en parallel = True définissant le moment où vous instanciez un appareil Amazon Braket, comme indiqué dans l'exemple suivant.

import pennylane as qml

# Define the number of wires (qubits) you want to use
wires = 2  # For example, using 2 qubits

# Define your S3 bucket 
my_bucket = "amazon-braket-s3-demo-bucket"
my_prefix = "pennylane-batch-output"
s3_folder = (my_bucket, my_prefix)

device = qml.device("braket.aws.qubit", 
                    device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1", 
                    wires=wires, 
                    s3_destination_folder=s3_folder, 
                    parallel=True)

Pour plus d'informations sur le traitement par lots avec PennyLane, consultez Optimisation parallélisée des circuits quantiques.

Traitement par lots de tâches et circuits paramétrés

Lorsque vous soumettez un lot de tâches quantiques contenant des circuits paramétrés, vous pouvez soit fournir un inputs dictionnaire, qui est utilisé pour toutes les tâches quantiques du lot, soit un dictionnaire list d'entrée, auquel cas le i -ème dictionnaire est associé à la i -ème tâche, comme illustré dans l'exemple suivant.

from braket.circuits import Circuit, FreeParameter, Observable
from braket.aws import AwsQuantumTaskBatch, AwsDevice

# Define your quantum device
device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")

# Create the free parameters
alpha = FreeParameter('alpha')
beta = FreeParameter('beta')

# Create two circuits
circ_a = Circuit().rx(0, alpha).ry(1, alpha).cnot(0, 2).xx(0, 2, beta)
circ_a.variance(observable=Observable.Z(), target=0)

circ_b = Circuit().rx(0, alpha).rz(1, alpha).cnot(0, 2).zz(0, 2, beta)
circ_b.expectation(observable=Observable.Z(), target=2)

# Use the same inputs for both circuits in one batch
tasks = device.run_batch([circ_a, circ_b], inputs={'alpha': 0.1, 'beta': 0.2})

# Or provide each task its own set of inputs
inputs_list = [{'alpha': 0.3, 'beta': 0.1}, {'alpha': 0.1, 'beta': 0.4}]

tasks = device.run_batch([circ_a, circ_b], inputs=inputs_list)

Vous pouvez également préparer une liste de dictionnaires d'entrée pour un seul circuit paramétrique et les soumettre sous forme de lot de tâches quantiques. Si la liste contient N dictionnaires d'entrée, le lot contient N tâches quantiques. La i -ème tâche quantique correspond au circuit exécuté avec le i -ème dictionnaire d'entrée.

from braket.circuits import Circuit, FreeParameter

# Create a parametric circuit
circ = Circuit().rx(0, FreeParameter('alpha'))

# Provide a list of inputs to execute with the circuit
inputs_list = [{'alpha': 0.1}, {'alpha': 0.2}, {'alpha': 0.3}]

tasks = device.run_batch(circ, inputs=inputs_list, shots=100)