Merge branch 'main' of github.com:SURFQuantum/qc-quantum-linear-systems

Author: dmark04

.github/workflows/publish_pypi.yml

@@ -0,0 +1,15 @@
+name: Python package
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  workflow_dispatch:
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build and publish to pypi
+        uses: JRubics/poetry-publish@v1.17
+        with:
+          pypi_token: ${{ secrets.PYPI_API_TOKEN }}

CHANGELOG.md

@@ -0,0 +1,6 @@
+CHANGELOG
+=========
+
+2023-11-28 (0.1.0)
+---
+* initial release

README.md

@@ -1,3 +1,6 @@
+[![PyPI Version](https://img.shields.io/pypi/v/quantum-linear-systems.svg)](https://pypi.org/project/quantum-linear-systems)
+![Python Version](https://img.shields.io/badge/Python-3.9%20%E2%86%92%203.12-blue)
+![CI/CD](https://github.com/SURFQuantum/qc-quantum-linear-systems/actions/workflows/actions.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/SURFQuantum/qc-quantum-linear-systems/badge.svg?branch=main)](https://coveralls.io/github/SURFQuantum/qc-quantum-linear-systems?branch=main)
 
 # quantum-linear-systems

pyproject.toml

@@ -3,8 +3,20 @@ name = "quantum-linear-systems"
 version = "0.1.0"
 description = "Quantum algorithms to solve linear systems of equations."
 authors = ["dmark04 <dmark04@web.de>"]
-license = "Apache 2.0"
+license = "Apache-2.0"
 readme = "README.md"
+keywords = ["science", "quantum"]
+repository = "https://github.com/SURFQuantum/qc-quantum-linear-systems"
+classifiers=[
+        "Development Status :: 4 - Beta",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+        "Topic :: Scientific/Engineering",
+    ]
+include = ["CHANGELOG.md"]
 
 [tool.poetry.dependencies]
 python = ">=3.9, <3.12" # >=3.9 because of amazon-braket, <3.12 because of classiq

quantum_linear_systems/execution/aws_execution.py

@@ -7,20 +7,18 @@
 from typing import Tuple
 
 import boto3
-from braket.aws import AwsSession
+from braket.aws import AwsQuantumJob
 from braket.devices import Devices
 from braket.jobs import OutputDataConfig
 from braket.jobs.hybrid_job import hybrid_job
 from braket.tracking import Tracker
 from qiskit import QuantumCircuit
 from qiskit.primitives import BackendEstimator
-from qiskit.providers import JobStatus
 from qiskit.providers import ProviderV1
 from qiskit.result import Result
 from qiskit.visualization import plot_histogram
 from qiskit_braket_provider import AWSBraketProvider
 from qiskit_braket_provider import BraketLocalBackend
-from qiskit_braket_provider.providers.braket_job import AmazonBraketTask
 
 from quantum_linear_systems.implementations.vqls_qiskit_implementation import (
     solve_vqls_qiskit,
@@ -43,43 +41,66 @@ def run_real_device_aws(
     """Run circuit on real AWS BraKet device."""
     provider: ProviderV1 = AWSBraketProvider()
     # select device by name
+    device = None
     if device_name == "ionq":
-        backend = provider.get_backend("IonQ Device")
+        device = "arn:aws:braket:::device/qpu/ionq/ionQdevice"
     elif device_name == "rigetti":
-        backend = provider.get_backend("Aspen-M-1")
+        device = "arn:aws:braket:::device/qpu/rigetti/Aspen-M-1"
     elif device_name == "oqc":
-        backend = provider.get_backend("Lucy")
-    else:
-        return ValueError(f"{device_name} not in the list of known device names.")
+        device = "arn:aws:braket:::device/qpu/oqc/Lucy"
 
-    task = backend.run(circuit, shots=shots)
+    if device is None:
+        raise ValueError(f"{device_name} not in the list of known device ARNs.")
 
-    retrieved_job: AmazonBraketTask = backend.retrieve_job(job_id=task.job_id())
+    backend = provider.get_backend(device)
+    aws_quantum_job = backend.run(circuit, shots=shots)
 
-    check_task_status(braket_task=retrieved_job)
-    result = retrieved_job.result()
-    plot_histogram(result.get_counts())
+    check_job_status(aws_quantum_job=aws_quantum_job)
+    job_result = aws_quantum_job.result()
+    plot_histogram(job_result.get_counts())
 
 
-def check_task_status(
-    braket_task: AmazonBraketTask, seconds_interval: int = 10
+def check_job_status(
+    aws_quantum_job: AwsQuantumJob, seconds_interval: int = 10
 ) -> None:
-    """Check task status every `second_interval` seconds until the quantum task is
-    done."""
+    """Check job status every `seconds_interval` seconds until the quantum job is done
+    or failed."""
     while True:
-        status = braket_task.status()
+        state = aws_quantum_job.state()
         current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        if status == JobStatus.DONE:
-            print(f"{current_time} - Your quantum task {braket_task.task_id} is done!")
-            break  # Exit the loop if the job is done
+
+        if state == "COMPLETED":
+            print(
+                f"{current_time} - Your quantum job {aws_quantum_job.arn} has completed successfully."
+            )
+            # Retrieve and print job result
+            result = aws_quantum_job.result()
+            print("Job result:", result)
+            # Print measurement probabilities if available
+            if "measurementProbabilities" in result:
+                print("Measurement Probabilities:", result["measurementProbabilities"])
+            break
+        elif state == "FAILED":
+            print(f"{current_time} - Your quantum job {aws_quantum_job.arn} failed.")
+            # Retrieve and print job metadata for debugging
+            metadata = aws_quantum_job.metadata()
+            print("Job failed with metadata:", metadata)
+            # Display logs for debugging
+            try:
+                aws_quantum_job.logs(wait=False)
+            except Exception as e:
+                print("An error occurred while retrieving logs:", e)
+            break
         else:
             print(
-                f"{current_time} - Current status of your quantum task {braket_task.task_id} is: {status}"
+                f"{current_time} - Current status of your quantum job {aws_quantum_job.arn} is: {state}"
             )
-            if status == JobStatus.QUEUED:
-                print(
-                    f"{current_time} - Your position in the queue is {braket_task.queue_position()}"
-                )
+            if state == "QUEUED":
+                queue_info = aws_quantum_job.queue_position()
+                if queue_info and queue_info.queue_position:
+                    print(
+                        f"{current_time} - Your position in the queue is {queue_info.queue_position}"
+                    )
             time.sleep(seconds_interval)
 
 
@@ -132,16 +153,13 @@ def aws_s3_folder(folder_name: str) -> Tuple[str, str]:
     )
 
     # Define the role ARN for executing the hybrid job (replace with your actual role ARN)
-    # role_arn = "arn:aws:iam::815925483357:role/surf-administrator"
-    os.environ[
-        "BRAKET_JOBS_ROLE_ARN"
-    ] = "arn:aws:iam::815925483357:role/src-workspace-AmazonBraketJobsExecutionRole"
-    aws_session = AwsSession()
-    print("Default role", aws_session.get_default_jobs_role())
+    surf_role_arn = (
+        "arn:aws:iam::815925483357:role/src-workspace-AmazonBraketJobsExecutionRole"
+    )
 
     @hybrid_job(
         device=device_arn,
-        # role_arn=role_arn,
+        role_arn=surf_role_arn,
         output_data_config=output_data_config,
         dependencies="aws_requirements.txt",
         local=args.local,
@@ -176,17 +194,17 @@ def execute_hybrid_job() -> None:
 
     with Tracker() as tracker:
         # submit the job
-        job = execute_hybrid_job()
+        job: AwsQuantumJob = execute_hybrid_job()
 
-        check_task_status(braket_task=job, seconds_interval=10)
+        check_job_status(aws_quantum_job=job, seconds_interval=10)
 
         # Check the final status
-        print(f"Job {job.id} finished with status {job.state()}.")
+        print(f"Job {job.arn} finished with status {job.state()}.")
 
         # Retrieve results if job is completed
         if job.state() == "COMPLETED":
             result = job.result()
             print("Job result:", result)
-        # display the results
-        print(job.result().measurement_counts)
+            # display the results
+            print(result.measurement_counts)
     print(tracker.simulator_tasks_cost())