View a markdown version of this page

Verwendung CUDA-Q mit Amazon Braket - Amazon Braket
CUDA-Q in NBIsCUDA-Q in hybriden Berufen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Verwendung CUDA-Q mit Amazon Braket

NVIDIA's CUDA-Qist eine Softwarebibliothek für die Programmierung hybrider Quantenalgorithmen, die CPUs, GPUs und Quantenprozessoren (QPUs) kombinieren. Es bietet ein einheitliches Programmiermodell, das es Entwicklern ermöglicht, sowohl klassische als auch Quantenbefehle in einem einzigen Programm auszudrücken und so Arbeitsabläufe zu rationalisieren. CUDA-Qbeschleunigt die Simulation und Laufzeit von Quantenprogrammen mit seinen integrierten CPU- und GPU-Simulatoren. CUDA-Qist mit nativen Braket Notebook Instances (NBIs) und Amazon Braket Hybrid Jobs verfügbar.

CUDA-Q in NBIs

CUDA-Qist standardmäßig in der Braket NBI-Umgebung installiert. Sie können ein CUDA-Q Beispiel-Notizbuch öffnen, indem Sie auf die Jupyter-Launcher-Seite gehen und die Kachel und Braket auswählen. CUDA-Q Dadurch wird das Beispiel-Notizbuch 0_Getting_started_with_CUDA-Q.ipynb im Hauptfenster geöffnet. Weitere CUDA-Q Beispiele finden Sie im linken Bereich des nvidia_cuda_q/ Verzeichnisses.

Sie können auch die Version von CUDA-Q oder eines anderen Drittanbieterpakets überprüfen, das in Ihrem NBI installiert ist. Sie können beispielsweise den folgenden Befehl in einer Notebook-Codezelle ausführenCUDA-Q, um die Versionen der Qiskit- und Braket-Pakete zu überprüfen PennyLane, die in der Umgebung installiert sind.

%pip freeze | grep -i -e cudaq -e qiskit -e pennylane -e braket

CUDA-Q in hybriden Berufen

Die Verwendung CUDA-Q auf Amazon Braket Hybrid Jobs bietet eine flexible On-Demand-Computerumgebung. Recheninstanzen werden nur für die Dauer Ihrer Arbeitslast ausgeführt. So wird sichergestellt, dass Sie nur für das bezahlen, was Sie tatsächlich nutzen. Amazon Braket Hybrid Jobs bietet auch ein skalierbares Erlebnis. Benutzer können mit kleineren Instances für das Prototyping und Testen beginnen und dann auf größere Instances hochskalieren, die größere Arbeitslasten für vollständige Experimente bewältigen können.

Amazon Braket Hybrid Jobs unterstützt GPUs, die für die Maximierung des Potenzials unerlässlich sind. CUDA-Q GPUs beschleunigen die Simulationen von Quantenprogrammen im Vergleich zu CPU-based Simulatoren erheblich, insbesondere wenn mit Schaltungen mit hoher Qubit-Anzahl gearbeitet wird. Bei Verwendung CUDA-Q auf Amazon Braket Hybrid Jobs wird die Parallelisierung zum Kinderspiel. Hybrid Jobs vereinfacht die Verteilung von Schaltkreisabtastungen und beobachtbaren Auswertungen auf mehrere Rechenknoten. Diese nahtlose Parallelisierung der CUDA-Q Workloads ermöglicht es den Benutzern, sich mehr auf die Entwicklung ihrer Workloads zu konzentrieren, anstatt die Infrastruktur für groß angelegte Experimente einzurichten.

Sehen Sie sich zunächst das CUDA-Q Starterbeispiel auf dem Amazon Braket-Beispiel-Github an, um einen von Braket bereitgestellten CUDA-Q hybriden Jobcontainer zu verwenden.

Der folgende Codeausschnitt ist ein hello-world Beispiel für die Ausführung eines CUDA-Q Programms mit Amazon Braket Hybrid Jobs.

image_uri = retrieve_image(Framework.CUDAQ, AwsSession().region)

@hybrid_job(device='local:nvidia/qpp-cpu', image_uri=image_uri)
def hello_quantum():
    import cudaq

    # define the backend
    device=get_job_device_arn()
    cudaq.set_target(device.split('/')[-1])

    # define the Bell circuit
    kernel = cudaq.make_kernel()
    qubits = kernel.qalloc(2)
    kernel.h(qubits[0])
    kernel.cx(qubits[0], qubits[1])

    # sample the Bell circuit
    result = cudaq.sample(kernel, shots_count=1000)
    measurement_probabilities = dict(result.items())
    
    return measurement_probabilities

Das obige Beispiel simuliert eine Bell-Schaltung auf einem CPU-Simulator. Dieses Beispiel läuft lokal auf Ihrem Laptop oder Braket Jupyter-Notebook. Aufgrund der local=True Einstellung wird bei der Ausführung dieses Skripts ein Container in Ihrer lokalen Umgebung gestartet, um das CUDA-Q Programm zum Testen und Debuggen auszuführen. Nachdem Sie mit dem Testen fertig sind, können Sie das local=True Flag entfernen und Ihren Job AWS weiterführen. Weitere Informationen finden Sie unter Arbeiten mit Amazon Braket Hybrid Jobs.

Wenn Ihre Workloads eine hohe Qubit-Anzahl, eine große Anzahl von Schaltungen oder eine große Anzahl von Iterationen aufweisen, können Sie leistungsstärkere CPU-Rechenressourcen verwenden, indem Sie die Einstellung angeben. instance_config Der folgende Codeausschnitt zeigt, wie Sie die Einstellung im Decorator konfigurieren. instance_config hybrid_job Weitere Informationen zu den unterstützten Instance-Typen finden Sie unter Konfigurieren Sie Ihre Hybrid-Job-Instance. Eine Liste der Instance-Typen finden Sie unter Amazon EC2-Instance-Typen.

@hybrid_job(
    device="local:nvidia/qpp-cpu",
    image_uri=image_uri,
    instance_config=InstanceConfig(instanceType="ml.c5.2xlarge"),
)
def my_job_script():
    ...

Für anspruchsvollere Workloads können Sie Ihre Workloads auf einem CUDA-Q GPU-Simulator ausführen. Verwenden Sie den Backend-Namen, um einen GPU-Simulator zu aktivieren. nvidia Das nvidia Backend arbeitet als CUDA-Q GPU-Simulator. Wählen Sie als Nächstes einen Amazon EC2-Instance-Typ aus, der eine NVIDIA GPU unterstützt. Der folgende Codeausschnitt zeigt den Decorator. GPU-configured hybrid_job

@hybrid_job(
    device="local:nvidia/nvidia",
    image_uri=image_uri,
    instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"),
)
def my_job_script():
    ...

Amazon Braket Hybrid Jobs und NBIs unterstützen parallele GPU-Simulationen mit. CUDA-Q Sie können die Auswertung mehrerer Observables oder mehrerer Schaltungen parallelisieren, um die Leistung Ihrer Arbeitslast zu steigern. Um mehrere Observablen zu parallelisieren, nehmen Sie die folgenden Änderungen an Ihrem Algorithmus-Skript vor.

Stellen Sie die mgpu Option des Backends ein. nvidia Dies ist erforderlich, um die Observablen zu parallelisieren. Die Parallelisierung verwendet MPI für die Kommunikation zwischen GPUs, daher muss MPI vor der Ausführung initialisiert und danach abgeschlossen werden.

Geben Sie als Nächstes den Ausführungsmodus durch Einstellung an. execution=cudaq.parallel.mpi Der folgende Codeausschnitt zeigt diese Änderungen.

cudaq.set_target("nvidia", option="mqpu")
cudaq.mpi.initialize()
result = cudaq.observe(
    kernel, hamiltonian, shots_count=n_shots, execution=cudaq.parallel.mpi
)
cudaq.mpi.finalize()

Geben Sie im hybrid_job Decorator einen Instanztyp an, der mehrere GPUs hostet, wie im folgenden Codeausschnitt gezeigt.

@hybrid_job(
    device="local:nvidia/nvidia-mqpu",
    instance_config=InstanceConfig(instanceType="ml.g4dn.12xlarge", instanceCount=1),
    image_uri=image_uri,
)
def parallel_observables_gpu_job(sagemaker_mpi_enabled=True):
    ...

Das Notizbuch für parallele Simulationen im Amazon Braket-Beispiel-Github bietet umfassende Beispiele, die demonstrieren, wie Quantenprogrammsimulationen auf GPU-Backends ausgeführt und parallele Simulationen von Observablen und Schaltungsstapeln durchgeführt werden.

Führen Sie Ihre Workloads auf Quantencomputern aus

Nach Abschluss der Simulatortests können Sie zur Ausführung von Experimenten auf QPUs übergehen. Schalten Sie das Ziel einfach auf eine Amazon Braket-QPU um, z. B. die IQMIonQ, oder -Geräte. Rigetti Der folgende Codeausschnitt veranschaulicht, wie das Ziel auf das Gerät festgelegt wird. IQM Garnet Eine Liste der verfügbaren QPUs finden Sie in der Amazon Braket-Konsole. 

device_arn = "arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet"
cudaq.set_target("braket", machine=device_arn)

Weitere Informationen zu Hybrid-Jobs finden Sie im Entwicklerhandbuch unter Working with Amazon Braket Hybrid Jobs. Weitere Informationen über CUDA-Q finden Sie in der NVIDIA CUDA-QDokumentation.