Amazon Braket est un service AWS entièrement géré qui aide les chercheurs, scientifiques et développeurs à débuter avec l’informatique quantique. L’informatique quantique Mon infobulle a le potentiel de résoudre certains problèmes de calcul hors de portée des ordinateurs classiques, car elle exploite les lois de la mécanique quantique pour traiter l’information de façon inédite.
| Imports | from braket.circuits import Circuit, Gate, Instructionfrom braket.circuits.observables import X |
| Créer un circuit | circuit = Circuit() |
| Ajouter des portes | circuit.x(0).rx(1, 1.23).cnot(0, 1) |
| Lister les portes disponibles | [attr for attr in dir(Gate) if attr[0].isupper()] |
| Appliquer une matrice unitaire | circuit.unitary([0], matrix) |
| Obtenir l’unitaire du circuit | circuit.to_unitary() |
| Ajouter un type de résultat | circuit.probability(0)circuit.expectation(0.5 * X() @ X(), target=[0, 1]) |
| Types de résultats disponibles | adjoint_gradient, amplitude, density_matrix, expectation, probability, sample, state_vector, variance |
| Ajouter une boîte verbatim | circuit.add_verbatim_box(circuit2) |
| Modificateurs de portes | circuit.x(0, control=[1, 2], control_state=[0, 1], power=-0.5) |
| Dessiner un circuit | print(circuit) |
| Importer depuis OpenQASM3 | Circuit.from_ir(source=qasm_str) |
| Exporter vers OpenQASM3 | Circuit.to_ir("OPENQASM") |
| Créer une instruction | inst = Instruction(Gate.CPhaseShift(1.23), target=[0, 1]) |
| Ajouter une instruction | circuit.add(inst) |
| Imports | from braket.circuits import FreeParameter |
| Créer un paramètre libre | alpha = FreeParameter("alpha") |
| Utiliser un paramètre libre | circuit.rx(0, alpha) |
| Algèbre de paramètres libres | beta = 2 * alpha + 1 |
| Lier une valeur | circuit.make_bound_circuit({"alpha": 0.1}) |
| Lister les paramètres libres non liés | circuit.parameters |
| Compilation en ligne | device.run(circuit, inputs={"alpha": 0.1}) |
| Imports | from braket.aws import AwsSession, AwsQuantumTask |
| Créer une tâche quantique en exécutant un circuit | task = device.run(circuit) |
| Désactiver le recâblage des qubits | device.run(circuit, disable_qubit_rewiring=True) |
| Instancier une AwsSession | session = AwsSession(...) |
| Recréer une tâche quantique | task = AwsQuantumTask(arn[, aws_session]) |
| Position dans la file | task.queue_position() |
| Imports | from braket.program_sets import ProgramSet, CircuitBindingfrom braket.circuits.observables import X, Z |
| Regrouper plusieurs circuits dans une tâche | program_set = ProgramSet([circuit1, circuit2], shots_per_executable=100) |
| Balayer un circuit sur des jeux de paramètres | binding = CircuitBinding(circuit, input_sets=[{"theta": 0.1}, {"theta": 0.2}]) |
| Balayer sur un hamiltonien (observables) | binding = CircuitBinding(circuit, {"theta": [0.1, 0.2]}, 2.1 * X(0) @ Z(1) - 4.5 * Z(0) @ Z(1)) |
| Construire un ensemble de programmes à partir de liaisons | program_set = ProgramSet(binding) |
| Associer circuits et entrées/observables | ProgramSet.zip([circuit1, circuit2], observables=[X(0), Z(0)]) |
| Produit cartésien circuits × observables | ProgramSet.product([circuit1], [X(0), Z(0)]) |
| Nombre total d’exécutables | program_set.total_executables |
| Exécuter un ensemble de programmes | task = device.run(program_set, shots=1000) |
| Espérance du i-ème exécutable | task.result().expectation(0) |
| Récupérer les résultats | result = task.result() |
| Obtenir le décompte des mesures | result.measurement_counts |
| Obtenir les qubits mesurés | result.measured_qubits |
| Obtenir le circuit compilé | result.get_compiled_circuit() |
| Imports | from braket.aws import AwsDevicefrom braket.devices import Devices |
| Instancier un dispositif | AwsDevice("<deviceARN>") |
| Alias de dispositif (au lieu de l’ARN) | Devices.Rigetti.Cepheus1108Q |
| Profondeur de la file | device.queue_depth() |
| Implémentation des portes en impulsions | device.gate_calibrations |
| Imports | from braket.aws import AwsDevice, DirectReservation |
| Réserver via un gestionnaire de contexte | with DirectReservation(device, reservation_arn="<arn>"): task = device.run(circuit, shots=100) |
| Démarrer / arrêter une réservation explicitement | res = DirectReservation(device, reservation_arn="<arn>")res.start()res.stop() |
| Appliquer à une seule tâche quantique | device.run(circuit, shots=100, reservation_arn="<arn>") |
| Appliquer à une tâche hybride | @hybrid_job(device=Devices.IQM.Garnet, reservation_arn="<arn>") |
| Graphe de connectivité | device.properties.paradigm.connectivity |
| Dictionnaire des fidélités | device.properties.provider.specs |
| Jeu de portes natives | device.properties.paradigm.nativeGateSet |
| Coût et disponibilité | device.properties.service |
| Propriétés d’impulsion | device.properties.pulse |
| Propriétés des actions | action_properties = device.properties.action['braket.ir.openqasm.program'] |
| Portes prises en charge | action_properties.supportedOperations |
| Imports | import mathfrom braket.circuits import Circuitfrom braket.experimental_capabilities import EnableExperimentalCapability |
| Activer les fonctionnalités expérimentales | with EnableExperimentalCapability(): circuit = Circuit() |
| Mesure en cours de circuit vers un registre de rétroaction (IQM) | circuit.measure_ff(0, feedback_key=0) |
| Porte PRx contrôlée classiquement, conditionnée par une clé de rétroaction (IQM) | circuit.cc_prx(1, math.pi / 2, math.pi / 4, feedback_key=0) |
| Disponible sur | dispositifs IQM (p. ex. Devices.IQM.Garnet) |
| Imports | from braket.tracking import Tracker |
| Démarrer le suivi des coûts | tracker=Tracker().start() |
| Afficher les coûts | tracker.qpu_tasks_cost()tracker.simulator_tasks_cost() |
| Résumé des coûts | tracker.quantum_tasks_statistics() |
| Imports | from braket.aws import AwsQuantumJobfrom braket.devices import Devicesfrom braket.jobs import hybrid_job, save_job_resultfrom braket.jobs.metrics import log_metric |
| Créer une tâche à partir d’un script | job = AwsQuantumJob.create(Devices.Amazon.SV1, source_module="algorithm_script.py", entry_point="algorithm_script:start_here", wait_until_complete=True) |
| Décorer un point d’entrée | @hybrid_job(device=Devices.Amazon.SV1)def my_job(): return save_job_result({"theta": 0.5}) |
| Lancer la tâche (la crée) | job = my_job() |
| Exécuter localement sans créer de tâche AWS | @hybrid_job(device=None, local=True) |
| Ajouter des dépendances Python | @hybrid_job(device=Devices.Amazon.SV1, dependencies="requirements.txt") |
| Inclure des modules sources supplémentaires | @hybrid_job(device=Devices.Amazon.SV1, include_modules=["my_module"]) |
| Passer des données d’entrée | @hybrid_job(device=Devices.Amazon.SV1, input_data="s3://my-bucket/input") |
| Utiliser une réservation | @hybrid_job(device=Devices.IQM.Garnet, reservation_arn="<arn>") |
| Enregistrer des métriques dans la tâche | log_metric(metric_name="loss", value=0.123, iteration_number=0) |
| Récupérer le résultat | job.result() |
| Position dans la file | job.queue_position() |
| Imports | from braket.devices import LocalSimulator |
| Instancier le simulateur local | local_sim = LocalSimulator() |
| Imports | from braket.aws import AwsDevicefrom braket.devices import Devices, LocalSimulatorfrom braket.emulation import Emulatorfrom braket.emulation.local_emulator import LocalEmulator |
| Obtenir un émulateur pour un QPU | emulator = AwsDevice(Devices.IQM.Garnet).emulator |
| Valider un circuit selon les contraintes du dispositif | emulator.validate(circuit) |
| Compiler un circuit vers les portes natives et la connectivité du dispositif | compiled = emulator.transform(circuit) |
| Exécuter sur le backend émulé (applique le bruit du dispositif) | result = emulator.run(circuit, shots=100).result() |
| Inspecter le modèle de bruit du dispositif | emulator.noise_model |
| Construire un émulateur personnalisé | emulator = Emulator(backend=LocalSimulator("braket_dm")) |
| Émulateur à partir d’un JSON de propriétés de dispositif | emulator = LocalEmulator.from_json(properties_json) |
| Imports | from braket.circuits import Noise, Gate |
| Bruit dépolarisant | circuit.depolarizing(0, 0.1) |
| Appliquer un opérateur de Kraus | circuit.kraus([0,2], [E0, E1]) |
| Canal d’amortissement de phase | noise = Noise.PhaseDamping(0.1) |
| Appliquer un canal de bruit | circuit.apply_gate_noise(noise, Gate.X) |
| Imports | from braket.pulse import PulseSequence, Framefrom braket.pulse.waveforms import * |
| Créer une nouvelle séquence d’impulsions | pulse_sequence = PulseSequence() |
| Ports prédéfinis | device.ports |
| Frames prédéfinis | device.frames |
| Créer un frame | Frame(port, frequency[, phase]) |
| Formes d’onde prédéfinies | ConstantWaveform(length, iq)GaussianWaveform(length, width, amplitude, zero_at_edges)DragGaussianWaveform(length, width, amplitude, beta, zero_at_edges) |
| Jouer une forme d’onde | pulse_sequence.play(frame, waveform) |
| Ajouter un délai | pulse_sequence.delay(frame, delay) |
| Définir la fréquence | pulse_sequence.set_frequency(frame, frequency) |
| Décaler la fréquence | pulse_sequence.shift_frequency(frame, detuning) |
| Définir la phase | pulse_sequence.set_phase(frame, phase) |
| Décaler la phase | pulse_sequence.shift_phase(frame, phi) |
| Obtenir la série temporelle | pulse_sequence.to_time_traces() |
| Imports | from braket.ahs import AtomArrangement, DrivingField, AnalogHamiltonianSimulation |
| Arrangement d’atomes | register = AtomArrangement() |
| Ajouter un atome par coordonnées (en mètres) | register.add((5.7e-6, 5.7e-6)) |
| Obtenir les coordonnées | register.coordinate_list(axis) |
| Créer un champ d’excitation | DrivingField(amplitude, phase, detuning) |
| Créer un programme AHS | ahs_program = AnalogHamiltonianSimulation(register, drive) |
| Exécuter un programme AHS | device.run(ahs_program) |
| Débiaisage | device.run(circuit, shots=2500, device_parameters={"errorMitigation": Debias()}) |
| Affinage (si le débiaisage est utilisé) | result.additional_metadata.ionqMetadata.sharpenedProbabilities |
La console est une interface web où vous trouvez des informations à jour sur le service Braket et les dispositifs disponibles.
| Onglet Dispositifs | Résumé du dispositif Connectivité |
| Notebook | Jupyter hub |
| Braket Direct | Réservation de dispositif Heures de permanence |
| Annuler une tâche hybride Braket | CancelJob |
| Annuler la tâche spécifiée | CancelQuantumTask |
| Créer une tâche hybride Braket | CreateJob |
| Créer une tâche quantique | CreateQuantumTask |
| Lister les dispositifs disponibles dans Braket | GetDevice |
| Récupérer la tâche hybride Braket spécifiée | GetJob |
| Récupérer la tâche quantique spécifiée | GetQuantumTask |
| Afficher les étiquettes associées à cette ressource | ListTagsForResource |
| Rechercher des dispositifs selon des filtres | SearchDevices |
| Rechercher des tâches hybrides Braket selon des filtres | SearchJobs |
| Rechercher des tâches quantiques selon des filtres | SearchQuantumTasks |
| Ajouter une étiquette à la ressource spécifiée | TagResource |
| Retirer des étiquettes d’une ressource | UntagResource |
| Imports | from qiskit_braket_provider import AWSBraketProvider |
| Instancier un fournisseur | provider = AWSBraketProvider() |
| Instancier un backend | provider.get_backend(name) |