Run in the Cloud#

The Quantuloop Quantum Simulator Suite for HPC provides several benefits for accelerating Ket applications on the cloud, including:

Faster simulation: The suite uses GPU acceleration to provide faster and more efficient simulation of quantum algorithms. This can significantly reduce the simulation time compared to using CPU-only simulation.
Easy deployment: The suite is available on the AWS Marketplace, making it easy to deploy and manage on your cloud infrastructure. Simply click on the product page to get started.
Cost-effective: The Cloud GPU-based simulation is cost-effective for quantum algorithm development as you can use the simulator only when you need it, without the need to purchase and maintain dedicated hardware.
Scalable: The Quantuloop Quantum Simulator Suite for HPC is designed to be scalable and can be used on multi-GPU systems, allowing you to scale up your simulation needs as your quantum algorithm grows in complexity.
Accessible: With the suite available on AWS, it is accessible from anywhere, allowing users to collaborate and share quantum simulations easily.

AWS Marketplace: Quantuloop Quantum Simulator Suite for HPC

How it works#

Quantuloop Quantum Simulator Suite for HPC on AWS

Experience the power of private quantum simulation by deploying your own Quantum Simulator Server on AWS with Quantuloop. Enjoy the flexibility and control of having your own dedicated quantum simulator, fully customizable to your needs.

How to deploy#

Deploying the Quantuloop Quantum Simulator Suite for HPC is easy with the container product available on the AWS Marketplace. Simply deploy it in an Amazon ECS cluster with Amazon EC2 GPU-based container instances.

Once you’ve subscribed to the product, you can quickly set up your simulation server using the CloudFormation templates provided by Quantuloop. These templates streamline the configuration and launch process, allowing you to get up and running with just a few clicks. Follow the steps below to get started.

Choose an EC2 GPU-based instance#

With the CloudFormation templates provided by Quantuloop, you have the flexibility to choose the instance type that best suits your needs. Available options include:

EC2 GPU-based instances#
Instance	GPUs	GPU Memory	Price	vCPU
`g4dn.xlarge`	NVIDIA T4	16 GB	G4 prices	4
`g5.xlarge`	NVIDIA A10G	24 GB	G5 prices	4
`p3.2xlarge`\(^*\)	NVIDIA V100	16 GB	P3 prices	8
`p3.8xlarge`	4x NVIDIA V100	64 GB	P3 prices	32
`p3.16xlarge`	8x NVIDIA V100	128 GB	P3 prices	64
`p3dn.24xlarge`	8x NVIDIA V100	256 GB	P3 prices	96
`p4d.24xlarge`	8x NVIDIA A100	320 GB	P4 prices	96
`p4de.24xlarge`	8x NVIDIA A100	640 GB	P4 prices	96

\(^*\) Recommended instance.

Verify your vCPU quota on AWS#

AWS provides vCPU limits to control the allocation of resources to instances, and it is recommended to verify your current resource allocation using the vCPU limits calculator before deploying the Quantuloop Quantum Simulator Suite for HPC. This calculator helps you understand the number of vCPUs that you can use per instance type and the total number of vCPUs you can use across all instance types.

If you find that your current resource allocation is insufficient for deploying the simulator suite, you can request an on-demand limit increase using the calculator. Keep in mind that new AWS accounts may have their limit increase requests denied automatically. If this happens, you can contact the AWS Support Center to reopen the case and have the issue resolved.

Requesting a public certificate for secure connection (optional)#

To ensure a secure connection for the Quantuloop Quantum Simulator Suite for HPC deployed on AWS, it is recommended to enable HTTPS by obtaining an Amazon ACM (AWS Certificate Manager) certificate. While it is possible to skip this step and use HTTP, it is highly recommended to use HTTPS for the following benefits:

Security: HTTPS provides encryption of the data transmitted between the client and server, ensuring that sensitive information is kept private.
Authenticity: HTTPS provides authentication of the website, verifying that the website is genuine and not a fake or fraudulent website.

To obtain an Amazon ACM certificate and enable HTTPS, a domain name is required. The process for requesting a public certificate can be found in the AWS documentation at https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html.

Generate an SSH RSA key pair for authentication#

To ensure the security of your simulation server, it’s important to provide an RSA public key at the launch configuration stage. When accessing the server, the quantum execution client will sign requests with your RSA private key, which helps prevent unauthorized access.

To generate a new SSH RSA key pair, we recommend using OpenSSH. If you’re on Windows, you’ll need to follow some additional steps to install it. On Linux and macOS, OpenSSH is likely already installed.

We strongly recommend generating a new SSH RSA key pair for your quantum simulation server, and sharing the private key only with your team. Keep in mind that anyone with access to the private key will be able to send quantum executions to the simulator server. You can use the following command to generate a new SSH RSA key pair:

ssh-keygen -t rsa -f quantum_simulator_key

When you run the ssh-keygen command, it will generate two files in the current directory: the private key quantum_simulator_key and the public key quantum_simulator_key.pub. The private key file contains sensitive information and should be kept secret. If you choose to encrypt the private key with a password, you will need to provide the password whenever you use the key in your quantum application.

Create the CloudFormation stack#

To deploy the Quantum Simulator Suite on AWS, follow these steps:

Go to the product page at https://aws.amazon.com/marketplace/pp/prodview-obpwf766uzz6g and click “Continue to Subscribe”. Review the terms and conditions, then click “Continue to Configuration”.
Choose “ECS Cluster with NVIDIA GPU” as the fulfillment option, select the desired software version, and click “Continue to Launch”.
Download the appropriate CloudFormation template depending on whether you have a public certificate or not. If you have a public certificate, download the “Custom domain with a secure connection” template. Otherwise, download the “Application Load Balancer domain” template.
Open the AWS CloudFormation console at https://console.aws.amazon.com/cloudformation and click “Create Stack”. Upload the downloaded template file, fill in the parameters (remember to use your OpenSSH RSA public key, which should be “quantum_simulator_key.pub”), then click “Next”.
On the “Configure stack options” page, click “Next”.
Check the box in the “Capabilities” section, then click “Submit”.
Wait for up to 10 minutes for the stack to complete. Once it’s done, go to the “Output” tab on the stack page to get further instructions.
You should see a link to the Application Load Balancer domain (e.g., https://example-1234567890.xx-xxx-x.elb.amazonaws.com). Accessing the link should take you to a page similar to this example.

Remember that creating an AWS account, setting up the necessary resources, and properly configuring the Quantum Simulator Suite for HPC using the CloudFormation templates are all critical steps in ensuring that your quantum simulation server is up and running smoothly. By following these steps, you’ll be able to deploy the Quantum Simulator Suite on AWS with ease, allowing you to perform complex simulations quickly and efficiently.

Enable Amazon Braket (optional)#

The provided CloudFormation template includes all the necessary permissions to access the Amazon Braket service through the quantum simulator suite available on AWS Marketplace. However, there are additional steps required to enable Amazon Braket on your AWS account. To enable Amazon Braket on your AWS account, follow these steps using your AWS root account credentials:

Login to your AWS account as the root user.
Visit https://console.aws.amazon.com/braket.
Select your preferred region from the available options.
Go to the Permissions and settings section.
In the General tab, enable third-party devices to allow integration with external quantum devices.
In the Execution roles tab, create a service-linked role for Braket.

By completing these steps with your AWS root account, Amazon Braket will be enabled for your AWS account. Please note that region restrictions may apply. If you encounter any “access denied” errors, please contact AWS support and request to allowlist your account for the regions us-east-1, us-west-1, and eu-west-2 to ensure proper access to Amazon Braket services.

Ket configuration#

Tip

Ket Quantum Programming is a cutting-edge open-source platform that facilitates seamless interaction between classical and quantum data at the programming level, simplifying classical-quantum development. With Ket, you can take advantage of the latest advancements in quantum computing to develop efficient and powerful applications. To learn more about the capabilities and features of Ket, visit https://quantumket.org.

After deploying your Quantum Simulator Server on AWS, you can configure your Ket application to access it. To get started, install the Quantuloop Quantum Simulator AWS Client using the appropriate command for your operating system:

Linux and macOS

python3 -m pip install quantuloop-aws-client

Windows

py -3 -m pip install quantuloop-aws-client

The configuration options for your Ket application vary depending on the deployment template you have chosen. To proceed with the configuration, please choose the relevant tab:

For the Custom domain with a secure connection template,

select Access with a valid certificate.
For the Application Load Balancer domain template,

select Access with the Application Load Balancer domain.

Access with a valid certificate

To access the quantum simulator server with a valid SSL certificate, add a CNAME record in the DNS of your domain registration provider. You can access the simulators using the Application Load Balancer domain for a quicker but less secure setup.

Setup server

Import the client and set the server using the quantuloop_aws_client.setup_server() function:

import quantuloop_aws_client as ql

# Set the URL, private key, and passphrase to connect to your quantum simulator server on AWS.
server = ql.setup_server(
    url='https://example.com',
    private_key="~/.ssh/id_rsa", # Specify the path to your private key file.
                                 # This key should match the public key provided in the CloudFormation template.
    passphrase=b'password',      # set passphrase=True to prompt the user for the password.
)

Access with the Application Load Balancer domain

Setup server

Import the client and set the server using the :func:quantuloop_aws_client.setup_server() function:

import quantuloop_aws_client as ql

# Set the URL, private key, and passphrase to connect to your quantum simulator server on AWS.
server = ql.setup_server(
    url='http://example-1234567890.xx-xxx-x.elb.amazonaws.com',
    private_key="~/.ssh/id_rsa", # Specify the path to your private key file.
                                 # This key should match the public key provided in the CloudFormation template.
    passphrase=b'password',      # set passphrase=True to prompt the user for the password.
)

Setup simulator

To select the simulator, floating-point precision, and number of GPUs used, use the quantuloop_aws_client.make_configuration() function:

import ket
remote_process = ket.Process(server(
    num_qubits=num_qubits,
    # Set the simulator to be used for the computation.
    # Options are "quantuloop::sparse" and "quantuloop::dense".
    simulator="quantuloop::dense"

    # Set the floating-point precision used for the computation.
    # Options are 1 for single precision, or 2 for double precision.
    precision=1,

    # Set the number of GPUs to be used for the computation.
    # Set to 0 to use all available GPUs.
    gpu_count=4,
))

Example#

Example of Grover’s algorithm running locally using KBW Dense and on your simulation server using Quantuloop Dense. To increase the number of qubits, modify the variable n.

from math import pi, sqrt
from time import perf_counter
import quantuloop_aws_client as ql
import ket

server = ql.setup_server(
    url="https://example.com",
    private_key="~/.ssh/id_rsa",
    passphrase=True,
)


def grover(process: ket.Process, size: int, w: int = 3):
    q = ket.H(process.alloc(size))
    for _ in range(int(pi / 4 * sqrt(2**size))):
        ket.lib.phase_oracle(w, q)
        with ket.around(ket.H, q):
            ket.lib.phase_oracle(0, q)
    assert ket.measure(q).get() == w


if __name__ == "__main__":
    num_qubits = 16

    print("Local execution (KBW Dense CPU)")
    begin = perf_counter()

    local_process = ket.Process(num_qubits=num_qubits, simulator="dense")
    grover(local_process, num_qubits)

    end = perf_counter()
    print(f"Local execution time {end - begin}s")

    print("Remote Execution (Quantuloop Dense GPU)")
    begin = perf_counter()

    remote_process = ket.Process(server(num_qubits=num_qubits, simulator="quantuloop::dense"))
    grover(remote_process, num_qubits)

    end = perf_counter()
    print(f"Local execution time {end - begin}s")

Privacy#

Quantuloop does not perform telemetry on your quantum execution or send any information to third parties. Data processed by your Quantuloop Quantum Simulator Suite for HPC instance on AWS is restricted to you and your AWS account.

Using HTTPS is highly recommended to improve the security of your quantum simulation server. Follow this step during deployment to enable a secure connection.

To comply with restrictions on sensitive data that cannot leave your on-premises network, we recommend deploying Quantuloop Quantum Simulation Suite for HPC on-premises with Amazon ECS Anywhere. With this method, all data is processed locally, but an AWS connection is still required to validate your subscription. If connecting to AWS is not an option, contact Quantuloop to acquire a Quantuloop Access Token to run offline.

The simulator server deployed in the AWS cloud or on-premises with Amazon ECS Anywhere is stateless and does not store quantum data. Therefore, one with the OpenSSH RSA private key cannot collect information about the quantum run they have not activated. Your quantum data remains private and secure.

When utilizing Amazon Braket simulators (and QPUs), it is important to note that the quantum execution process will be managed by AWS, and as such, your data will be subject to the Amazon Braket privacy policy. This policy may involve the transmission of data to third-party entities. It is recommended to review the Amazon Braket privacy policy to understand how your data is handled and ensure compliance with your privacy requirements.

Billing#

The Quantuloop Quantum Simulator Suite for HPC is a paid container product available on the AWS Marketplace. Once you subscribe to the product, you will be charged an hourly rate based on the number of containers running, and not based on the instance type and region you choose for deployment. You can check the current pricing for the product on the AWS Marketplace product page.

AWS charges you for the usage of the underlying infrastructure that hosts the Quantuloop Quantum Simulator Suite for HPC. This includes charges for compute resources and data transfer. You can monitor your usage and costs using the AWS Cost Explorer, and you can set up billing alerts to notify you when your costs exceed a certain threshold.

AWS bills you on a monthly basis for your usage of the infrastructure, and you can pay your bill using a credit card, bank account, or through other payment methods available in your country.

It’s important to note that AWS bills you separately for the usage of the infrastructure and the cost of the product subscription. You only get charged when you deploy the product and not when you subscribe. The subscription cost for the Quantuloop Quantum Simulator Suite for HPC is charged hourly based on the number of containers running, and the usage of the infrastructure is billed separately based on the resources you consume.

To stop future charges, you can terminate the CloudFormation stack from the AWS Management Console. When you delete the stack, all resources associated with the stack are deleted, and you will no longer be billed for them. You should also make sure to terminate any running instances or containers associated with the product to avoid additional charges. Overall, the billing process for the Quantuloop Quantum Simulator Suite for HPC on AWS is straightforward, and you can easily monitor and manage your costs using the tools provided by AWS.

Please note that using the simulators (and QPUs) with names starting with “arn:aws:braket” provided by Amazon Braket may incur additional charges. For detailed pricing information, please refer to the Amazon Braket pricing page at https://aws.amazon.com/braket/pricing. It is important to review the pricing details to understand the potential costs associated with utilizing these services.

Technical support#

If you require technical support for the Quantuloop Quantum Simulator Suite for HPC, you can reach out to the product’s support team by email at support@quantuloop.com. This is the recommended way to get in touch with the support team for any technical issues you may encounter while using the product.

When contacting support, be sure to provide as much detail as possible about the issue you are experiencing, including any error messages or logs that may be helpful in diagnosing the problem. The support team will work with you to troubleshoot the issue and provide a resolution as quickly as possible.

It’s important to note that the support team may take some time to respond to your inquiry depending on the volume of support requests they receive. However, they will make every effort to respond to your inquiry in a timely manner and provide the assistance you need to get the most out of the product.

FAQ#

Frequently asked questions about the Quantuloop Quantum Simulator Suite for HPC.

What is the Quantuloop Quantum Simulator Suite for HPC?

The Quantuloop Quantum Simulator Suite for HPC is a software product that provides three high-performance quantum computer simulators for the quantum programming language Ket. It allows you to simulate quantum algorithms on your local machine or on AWS, accelerating the execution of quantum applications.
How does the product work?

The product works by providing a set of quantum computer simulators that can be used to simulate quantum algorithms written in the Ket language. You can configure the product to send the quantum execution to AWS, while keeping the classical code and data locally.
How is the product priced?

The product is priced hourly with the addiction of the underlying AWS infrastructure cost based on the instance type and the region you choose for deployment. You can check the current pricing for the product on the AWS Marketplace product page.
Is the product secure?

Yes, the product is designed to keep your quantum experiments secure by sending quantum data only to your AWS account. Quantuloop Quantum Simulator Suite for HPC performs no telemetry and does not send any information to third parties.
What is Quantuloop Sparse?

Quantuloop Sparse is a simulator included in the product that features a unique algorithm that enables simulating 100+ qubits depending on the algorithm. You can select Quantuloop Sparse with one line of code and evaluate if it suits your quantum application.
How can I get technical support for the product?

For technical support, please email support@quantuloop.com.
How can I monitor my usage and costs of the product?

You can monitor your usage and costs of the product using the AWS Cost Explorer, and you can set up billing alerts to notify you when your costs exceed a certain threshold.
What is the minimum AWS configuration required to use Quantuloop Quantum Simulator Suite for HPC?

The minimum requirement is an AWS account and an EC2 instance with a GPU. You can choose the instance type and region that best suits your needs.
Can I use my own quantum programming language with the Quantuloop Quantum Simulator Suite for HPC?

Currently, the product only supports the quantum programming language Ket. However, we are constantly evaluating new languages and expanding the product capabilities.
Can I use my existing AWS account to deploy the simulator?

Yes, you can use your existing AWS account to deploy the Quantuloop Quantum Simulator Suite for HPC. Simply subscribe to the product on the AWS Marketplace and configure it to run on your AWS account.
Can I cancel my subscription at any time?

Yes, you can cancel your subscription to the Quantuloop Quantum Simulator Suite for HPC at any time. Simply go to the AWS Marketplace subscription page and click on the “Cancel Subscription” button.
Can I deploy the simulator in any AWS region?

Yes, you can deploy the Quantuloop Quantum Simulator Suite for HPC in any AWS region that supports the required instance types. You can select the region during the deployment process on the AWS Marketplace.
Can I use my own quantum programs with the Quantuloop Quantum Simulator Suite for HPC?

Yes, you can use your own quantum programs written in the Ket quantum programming language with the simulators. The simulators support all Ket operations, including unitary gates, measurements, and control flow.
What is the difference between Quantuloop Dense and Quantuloop Sparse?

Quantuloop Dense is a simulator designed for simulating small to medium-sized quantum circuits with a around 30. Quantuloop Sparse is designed for simulating large quantum circuits with a sparse structure, such as those encountered in error correction algorithms. Depending on the algorithm being simulated, Quantuloop Sparse can simulate up to 100+ qubits.
What is the minimum instance size required to run the Quantuloop Quantum Simulator Suite for HPC?

The minimum instance size required is g4dn.xlarge.
Can I use the Quantuloop Quantum Simulator Suite for HPC for commercial purposes?

Yes, the product is available for commercial use on the AWS Marketplace.
Can I access the source code for the quantum simulators?

No, the source code for the simulators is not available for access or modification.