Traitement par lots de tâches quantiques

Le traitement par lots de tâches quantiques est disponible sur tous les appareils Amazon Braket, à l'exception du simulateur local. Le traitement par lots est particulièrement utile pour les tâches quantiques que vous exécutez sur les simulateurs à la demande (TN1 or SV1) car ils peuvent traiter plusieurs tâches quantiques en parallèle. Pour vous aider à configurer diverses tâches quantiques, Amazon Braket propose des exemples de carnets de notes.

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 circuits de ces tâches quantiques sont indépendants les uns des autres, il est conseillé d'utiliser le traitement par lots. De cette façon, vous n'avez pas à attendre qu'une tâche quantique soit terminée avant qu'une autre ne commence.

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

circuits = [bell for _ in range(5)]
batch = device.run_batch(circuits, s3_folder, shots=100)
print(batch.results()[0].measurement_counts)  # The result of the first quantum task in the batch

Pour plus d'informations, consultez les exemples Amazon Braket GitHub ou le traitement par lots de tâches Quantum, qui contiennent des informations plus spécifiques sur le traitement par lots.

À 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 :

• Par défaut, le traitement par lots de tâches quantiques recommence à tout moment ou échoue 3 fois aux tâches quantiques.

• Un lot de tâches quantiques de longue durée, telles que 34 qubits for SV1, peut entraîner des coûts importants. Assurez-vous de bien vérifier les valeurs run_batch d'assignation avant de commencer un lot de tâches quantiques. Nous ne recommandons pas d'utiliser TN1 avec run_batch.

• TN1 peut entraîner des coûts en cas d'échec des tâches de la phase de répétition (voir la TN1 description pour plus d'informations). Les nouvelles tentatives automatiques peuvent augmenter le coût. Nous vous recommandons donc de définir le nombre de « max_retries » sur 0 lors du traitement par lots lors de l'utilisation TN1 (voir Quantum Task Batching, ligne 186).

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.

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

# 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)