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.
# Exemples de tâches quantiques sur Amazon Braket
Cette section décrit les étapes de l'exécution d'un exemple de tâche quantique, de la sélection de l'appareil à l'affichage du résultat. Comme bonne pratique pour Amazon Braket, nous vous recommandons de commencer par exécuter le circuit sur un simulateur, tel que. SV1
**Topics**
+ [Spécifiez l'appareil](#braket-example-specify-device)
+ [Soumettre un exemple de tâche quantique](#braket-submit-example-task)
+ [Soumettre une tâche paramétrée](#braket-submit-parametrized-task)
+ [Spécifiez shots](#braket-shots)
+ [Sondage pour les résultats](#braket-polling-results)
+ [Voir les exemples de résultats](#braket-example-results)
## Spécifiez l'appareil
Tout d'abord, sélectionnez et spécifiez l'appareil pour votre tâche quantique. Cet exemple montre comment choisir le simulateur,SV1.
```
from braket.aws import AwsDevice
# Choose the on-demand simulator to run the circuit
device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
```
Vous pouvez consulter certaines des propriétés de cet appareil comme suit :
```
print(device.name)
for iter in device.properties.action['braket.ir.jaqcd.program']:
print(iter)
```
```
SV1
('version', ['1.0', '1.1'])
('actionType', 'braket.ir.jaqcd.program')
('supportedOperations', ['ccnot', 'cnot', 'cphaseshift', 'cphaseshift00', 'cphaseshift01', 'cphaseshift10', 'cswap', 'cy', 'cz', 'ecr', 'h', 'i', 'iswap', 'pswap', 'phaseshift', 'rx', 'ry', 'rz', 's', 'si', 'swap', 't', 'ti', 'unitary', 'v', 'vi', 'x', 'xx', 'xy', 'y', 'yy', 'z', 'zz'])
('supportedResultTypes', [ResultType(name='Sample', observables=['x', 'y', 'z', 'h', 'i', 'hermitian'], minShots=1, maxShots=100000), ResultType(name='Expectation', observables=['x', 'y', 'z', 'h', 'i', 'hermitian'], minShots=0, maxShots=100000), ResultType(name='Variance', observables=['x', 'y', 'z', 'h', 'i', 'hermitian'], minShots=0, maxShots=100000), ResultType(name='Probability', observables=None, minShots=1, maxShots=100000), ResultType(name='Amplitude', observables=None, minShots=0, maxShots=0)])
('disabledQubitRewiringSupported', None)
```
## Soumettre un exemple de tâche quantique
Soumettez un exemple de tâche quantique à exécuter sur le simulateur à la demande.
```
from braket.circuits import Circuit, Observable
# Create a circuit with a result type
circ = Circuit().rx(0, 1).ry(1, 0.2).cnot(0, 2).variance(observable=Observable.Z(), target=0)
# Add another result type
circ.probability(target=[0, 2])
# Set up S3 bucket (where results are stored)
my_bucket = "amazon-braket-s3-demo-bucket" # The name of the bucket
my_prefix = "your-folder-name" # The name of the folder in the bucket
s3_location = (my_bucket, my_prefix)
# Submit the quantum task to run
my_task = device.run(circ, s3_location, shots=1000, poll_timeout_seconds=100, poll_interval_seconds=10)
# The positional argument for the S3 bucket is optional if you want to specify a bucket other than the default
# Get results of the quantum task
result = my_task.result()
```
La `device.run()` commande crée une tâche quantique via l'`CreateQuantumTask`API. Après une courte période d'initialisation, la tâche quantique est mise en file d'attente jusqu'à ce qu'il soit possible d'exécuter la tâche quantique sur un appareil. Dans ce cas, l'appareil estSV1. Une fois que l'appareil a terminé le calcul, Amazon Braket écrit les résultats sur l'emplacement Amazon S3 spécifié lors de l'appel. L'argument positionnel `s3_location` est obligatoire pour tous les appareils à l'exception du simulateur local.
**Note**
La taille de l'action de tâche quantique Braket est limitée à 5 Mo.
## Soumettre une tâche paramétrée
Amazon Braket propose des simulateurs locaux et à la demande et prend QPUs également en charge la spécification de valeurs de paramètres libres lors de la soumission des tâches. Vous pouvez le faire en utilisant l'`inputs`argument to`device.run()`, comme indiqué dans l'exemple suivant. `inputs`Il doit s'agir d'un dictionnaire de paires chaîne-flottante, où les clés sont les noms des paramètres.
La compilation paramétrique peut améliorer les performances d'exécution de circuits paramétriques sur certains circuits. QPUs Lorsque vous soumettez un circuit paramétrique en tant que tâche quantique à un QPU compatible, Braket compilera le circuit une fois et mettra le résultat en cache. Aucune recompilation n'est nécessaire pour les mises à jour ultérieures des paramètres du même circuit, ce qui se traduit par des temps d'exécution plus rapides pour les tâches utilisant le même circuit. Braket utilise automatiquement les données d'étalonnage mises à jour fournies par le fournisseur du matériel lors de la compilation de votre circuit afin de garantir des résultats de la plus haute qualité.
**Note**
La compilation paramétrique est prise en charge sur tous les modèles supraconducteurs basés sur des portes, QPUs à l'Rigetti Computingexception des programmes de niveau d'impulsion.
```
from braket.circuits import Circuit, FreeParameter, Observable
# Create the free parameters
alpha = FreeParameter('alpha')
beta = FreeParameter('beta')
# Create a circuit with a result type
circ = Circuit().rx(0, alpha).ry(1, alpha).cnot(0, 2).xx(0, 2, beta)
circ.variance(observable=Observable.Z(), target=0)
# Add another result type
circ.probability(target=[0, 2])
# Submit the quantum task to run
my_task = device.run(circ, inputs={'alpha': 0.1, 'beta': 0.2}, shots=100)
```
## Spécifiez shots
L'shotsargument fait référence au nombre de mesures souhaitéesshots. Les simulateurs tels que celui-ci SV1 prennent en charge deux modes de simulation.
+ Pour shots = 0, le simulateur effectue une simulation exacte, renvoyant les valeurs vraies pour tous les types de résultats. (Non disponible surTN1.)
+ Pour les valeurs non nulles deshots, le simulateur prélève des échantillons à partir de la distribution de sortie pour émuler le shot bruit réel. QPUs Les appareils QPU autorisent uniquement shots > 0.
Pour plus d'informations sur le nombre maximum de tirs par tâche quantique, reportez-vous à [Braket Quotas](braket-quotas.md).
## Sondage pour les résultats
Lors de l'exécution`my_task.result()`, le SDK commence à rechercher un résultat avec les paramètres que vous définissez lors de la création de la tâche quantique :
+ `poll_timeout_seconds`est le nombre de secondes nécessaires pour interroger la tâche quantique avant son expiration lors de l'exécution de la tâche quantique sur le simulateur à la demande et/ou sur des appareils QPU. La valeur par défaut est 432 000 secondes, soit 5 jours.
+ **Remarque :** pour les appareils QPU tels que Rigetti etIonQ, nous vous recommandons d'attendre quelques jours. Si le délai d'attente de votre sondage est trop court, les résultats risquent de ne pas être renvoyés dans le délai imparti. Par exemple, lorsqu'un QPU n'est pas disponible, une erreur de temporisation locale est renvoyée.
+ `poll_interval_seconds`est la fréquence à laquelle la tâche quantique est interrogée. Il indique à quelle fréquence vous appelez le Braket API pour obtenir le statut lorsque la tâche quantique est exécutée sur le simulateur à la demande et sur les appareils QPU. La valeur par défaut est de 1 seconde.
Cette exécution asynchrone facilite l'interaction avec les périphériques QPU qui ne sont pas toujours disponibles. Par exemple, un appareil peut être indisponible pendant une période de maintenance normale.
Le résultat renvoyé contient une série de métadonnées associées à la tâche quantique. Vous pouvez vérifier le résultat de la mesure à l'aide des commandes suivantes :
```
print('Measurement results:\n', result.measurements)
print('Counts for collapsed states:\n', result.measurement_counts)
print('Probabilities for collapsed states:\n', result.measurement_probabilities)
```
```
Measurement results:
[[1 0 1]
[0 0 0]
[0 0 0]
...
[0 0 0]
[0 0 0]
[1 0 1]]
Counts for collapsed states:
Counter({'000': 766, '101': 220, '010': 11, '111': 3})
Probabilities for collapsed states:
{'101': 0.22, '000': 0.766, '010': 0.011, '111': 0.003}
```
## Voir les exemples de résultats
Comme vous avez également spécifié le`ResultType`, vous pouvez consulter les résultats renvoyés. Les types de résultats apparaissent dans l'ordre dans lequel ils ont été ajoutés au circuit.
```
print('Result types include:\n', result.result_types)
print('Variance=', result.values[0])
print('Probability=', result.values[1])
# Plot the result and do some analysis
import matplotlib.pyplot as plt
plt.bar(result.measurement_counts.keys(), result.measurement_counts.values())
plt.xlabel('bitstrings')
plt.ylabel('counts')
```
```
Result types include:
[ResultTypeValue(type=Variance(observable=['z'], targets=[0], type=), value=0.693084), ResultTypeValue(type=Probability(targets=[0, 2], type=), value=array([0.777, 0. , 0. , 0.223]))]
Variance= 0.693084
Probability= [0.777 0. 0. 0.223]
Text(0, 0.5, 'counts')
```
