Strangeworks-Braket
The strangeworks-braket
package provides a similar experience to Amazon Braket.
Installationā
To get started, make sure you have Python 3.9 or above (installation) and are familiar with setting up and using virtual environments.
pip install strangeworks-braket
Usageā
Here's a simple example of creating a Bell state with Amazon Braket.
Before running:
- Set up your environment and install
strangeworks-braket
- In the portal, Activate Amazon Braket to create a Resource
- Replace
your-api-key
with your key from the Portal homepage - Run the script!
import strangeworks
from braket.circuits import Circuit
from strangeworks_braket import StrangeworksDevice
# get your API key from the Strangeworks Portal
strangeworks.authenticate(
api_key="your-api-key",
)
# Optional: If you have multiple instances (resources) of a product,
# you can set the resource to use here.
# strangeworks.set_resource_for_product('your-resource-slug', 'amazon-braket')
# Optional: You can list the Braket devices available on
# the Strangeworks Platform
devices = StrangeworksDevice.get_devices()
print("Available devices:")
for device in devices:
print(f" - {device.name} ({device.arn})")
# create a simple quantum circuit
bell_state = Circuit().h(0).cnot(0, 1)
# Choose a device (an AWS-hosted simulator in this case)
tn1 = StrangeworksDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
# Execute the circuit
print("\nš¤ Executing Circuit...\n")
task = tn1.run(bell_state, 1000)
# At this point, the job is running on the Strangeworks Platform.
# You can check the status of the job in the Portal, even if
# stop this script.
print(f"ā³ Job {task.id} submitted!\n")
# Lots of good info in here
result = task.result()
# View the counts (also visible in the Portal in a chart š)
print(f"š š Counts: {result.measurement_counts}\n")
š„³ Success! You may view your job in the portal.
š Something went wrong? Find us in Slack!
Quera-Aquilaā
Here's a simple example of creating a analogue Hamiltonian simulation to run on Aquila with Amazon Braket.
Before running:
- Set up your environment and install
strangeworks-braket
- In the portal, Activate Amazon Braket to create a Resource
- Replace
your-api-key
with your key from the Portal homepage - Run the script!
import strangeworks
from strangeworks_braket import StrangeworksDevice
from braket.timings.time_series import TimeSeries
from braket.ahs.driving_field import DrivingField
import numpy as np
from Example.utils.ahs_utils import rabi_pulse, constant_time_series
from braket.ahs.atom_arrangement import AtomArrangement
from braket.ahs.hamiltonian import Hamiltonian
from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation
# get your API key from the Strangeworks Portal
strangeworks.authenticate(
api_key="your-api-key",
)
# Optional: If you have multiple instances (resources) of a product,
# you can set the resource to use here.
# strangeworks.set_resource_for_product('your-resource-slug', 'amazon-braket')
# Initialize Device
device = StrangeworksDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")
# Create Driving Parameters
rydberg = device.properties.paradigm.rydberg
omega_const = 1.5e7 # rad / s
rabi_pulse_area = np.pi/np.sqrt(3) # rad
omega_slew_rate_max = float(rydberg.rydbergGlobal.rabiFrequencySlewRateMax) # rad/s^2
time_points, amplitude_values = rabi_pulse(rabi_pulse_area, omega_const, 0.99 * omega_slew_rate_max)
amplitude = TimeSeries()
for t, v in zip(time_points, amplitude_values):
amplitude.put(t, v)
detuning = constant_time_series(amplitude, 0.0)
phase = constant_time_series(amplitude, 0.0)
drive = DrivingField(
amplitude=amplitude,
detuning=detuning,
phase=phase
)
# Create Register
separation = 5e-6
block_separation = 15e-6
k_max = 5
m_max = 5
register = AtomArrangement()
for k in range(k_max):
for m in range(m_max):
register.add((block_separation*m, block_separation*k + separation/np.sqrt(3)))
register.add((block_separation*m-separation/2, block_separation*k - separation/(2*np.sqrt(3))))
register.add((block_separation*m+separation/2, block_separation*k - separation/(2*np.sqrt(3))))
# Combine to create Analogue Hamiltonian
ahs_program = AnalogHamiltonianSimulation(
register=register,
hamiltonian=drive
)
discrete_program = ahs_program.discretize(device)
# Execute the circuit
print("\nš¤ Executing Circuit...\n")
n_shots = 100
task = device.run(discrete_program, n_shots)
# At this point, the job is running on the Strangeworks Platform.
# You can check the status of the job in the Portal, even if
# stop this script.
print(f"ā³ Job {task.id} submitted!\n")
# Lots of good info in here
result = task.result()
š„³ Success! You may view your job in the portal.
š Something went wrong? Find us in Slack!
Xanadu-Borealisā
Here's a simple example of creating a photonic based quantum computation to run on Borealis with Amazon Braket.
Before running:
- Set up your environment and install
strangeworks-braket
- In the portal, Activate Amazon Braket to create a Resource
- Replace
your-api-key
with your key from the Portal homepage - Run the script!
import strangeworks
from strangeworks_braket import StrangeworksDevice
from strawberryfields.tdm import borealis_gbs, get_mode_indices
from strawberryfields.ops import Sgate, Rgate, BSgate, MeasureFock
import strawberryfields as sf
import numpy as np
# get your API key from the Strangeworks Portal
strangeworks.authenticate(
api_key="your-api-key",
)
# Optional: If you have multiple instances (resources) of a product,
# you can set the resource to use here.
# strangeworks.set_resource_for_product('your-resource-slug', 'amazon-braket')
# Initialize Device
device = StrangeworksDevice("arn:aws:braket:us-east-1::device/qpu/xanadu/Borealis")
# Create Photonic Circuit
gate_args_list = borealis_gbs(device, modes=216, squeezing="high")
delays = [1, 6, 36]
n, N = get_mode_indices(delays)
prog = sf.TDMProgram(N)
with prog.context(*gate_args_list) as (p, q):
Sgate(p[0]) | q[n[0]]
for i in range(len(delays)):
Rgate(p[2 * i + 1]) | q[n[i]]
BSgate(p[2 * i + 2], np.pi / 2) | (q[n[i + 1]], q[n[i]])
MeasureFock() | q[0]
# Execute the circuit
print("\nš¤ Executing Circuit...\n")
shots = 1000
results = device.run(prog, shots=shots, crop=True)
# At this point, the job is running on the Strangeworks Platform.
# You can check the status of the job in the Portal, even if
# stop this script.
print(f"ā³ Job {task.id} submitted!\n")
# Lots of good info in here
result = task.result()
š„³ Success! You may view your job in the portal.
š Something went wrong? Find us in Slack!
Hybrid Jobsā
Here's a simple example of custom submiting user defined scripts to devices on Amazon Braket. For more details and trouble shooting, see https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs.html
Before running:
- Set up your environment and install
strangeworks-braket
- In the portal, Activate Amazon Braket to create a Resource
- Replace
your-api-key
with your key from the Portal homepage - Run the script!
import strangeworks
from strangeworks_braket import StrangeworksDevice
# get your API key from the Strangeworks Portal
strangeworks.authenticate(
api_key="your-api-key",
)
# Optional: If you have multiple instances (resources) of a product,
# you can set the resource to use here.
# strangeworks.set_resource_for_product('your-resource-slug', 'amazon-braket')
# Initialize Device
# Try on simulator
device = StrangeworksDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
# Path to user defined file
filepath = ""
# Inputs for user defined file
hyperparameters = {"shots": 100, "num_iter": 5, "nqubits": 2}
# Submit job
sw_job = device.run_hybrid(filepath, hyperparameters)
# At this point, the job is running on the Strangeworks Platform.
# You can check the status of the job in the Portal, even if
# stop this script.
print(f"ā³ Job {task.id} submitted!\n")
# Lots of good info in here
result = task.result()
An example script is shown below which will run a simple bell state circuit a number of times given by the input parameter num_iter
.
The form of the script has to follow a number of guidelines:
- The script must contain a function called main that takes no inputs,
def main()
. The inputs will be read in by theload_hyperparameters()
, see example below. This will be the entry point for the aws job. - The script must contain only one function called main
- The braket tracker must be imported,
from braket.tracking import Tracker
- The braket tracker must be started on the line right after
def main():
or immediately following any comments afterdef main():
- The braket save job result function must be imported
from braket.jobs import save_job_result
- The results of the tracker must saved using the
save_job_result
function from braket by including"task summary": t.quantum_tasks_statistics(),
in the output dictionary. - Nothing can follow
save_job_result
in the functionmain()
import json
import os
from braket.aws import AwsDevice
from braket.circuits import Circuit
from braket.jobs import save_job_result
from braket.tracking import Tracker
def main():
"""
Example Hybrid Job File
"""
t = Tracker().start()
device_arn = os.environ["AMZN_BRAKET_DEVICE_ARN"]
# Initialise device
device = AwsDevice(device_arn)
print(f"Using device {device}")
hyperparams = load_hyperparameters()
print("Hyperparameters are:", hyperparams)
shots = int(hyperparams.get("shots"))
num_iter = int(hyperparams.get("num_iter"))
counts = []
bell = Circuit().h(0).cnot(0, 1)
for count in range(num_iter):
task = device.run(bell, shots=shots)
print(task.result().measurement_counts)
counts.append(task.result().measurement_counts)
# return results as strings
save_job_result(
{
"counts": json.dumps(counts),
"task summary": t.quantum_tasks_statistics(),
"estimated cost": t.qpu_tasks_cost() + t.simulator_tasks_cost()
}
)
def load_hyperparameters():
"""Load the Hybrid Job hyperparameters"""
hp_file = os.environ["AMZN_BRAKET_HP_FILE"]
with open(hp_file) as f:
hyperparams = json.load(f)
return hyperparams
š„³ Success! You may view your job in the portal.
š Something went wrong? Find us in Slack!