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.

Führen Sie hybride Workloads mit eingebetteten Simulatoren aus PennyLane

Schauen wir uns an, wie Sie eingebettete Simulatoren von PennyLane Amazon Braket Hybrid Jobs aus verwenden können, um Hybrid-Workloads auszuführen. Der GPU-basierte eingebettete Simulator von Pennylane verwendet die Nvidia CuQuantum-Bibliotheklightning.gpu, um Schaltungssimulationen zu beschleunigen. Der eingebettete GPU-Simulator ist in allen Braket-Jobcontainern vorkonfiguriert, die Benutzer sofort verwenden können. Auf dieser Seite zeigen wir Ihnen, wie Sie lightning.gpu damit Ihre Hybrid-Workloads beschleunigen können.

lightning.gpuFür QAOA-Workloads verwenden

Sehen Sie sich die Beispiele des Quantum Approximate Optimization Algorithm (QAOA) aus diesem Notizbuch an. Um einen eingebetteten Simulator auszuwählen, geben Sie als device Argument eine Zeichenfolge der folgenden Form an:. "local:<provider>/<simulator_name>" Sie würden beispielsweise "local:pennylane/lightning.gpu" für festlegenlightning.gpu. Die Gerätezeichenfolge, die Sie dem Hybrid-Job beim Start geben, wird als Umgebungsvariable an den Job übergeben"AMZN_BRAKET_DEVICE_ARN".

device_string = os.environ["AMZN_BRAKET_DEVICE_ARN"]
prefix, device_name = device_string.split("/")
device = qml.device(simulator_name, wires=n_wires)

Vergleichen Sie auf dieser Seite die beiden eingebetteten PennyLane Zustandsvektorsimulatoren lightning.qubit (der CPU-basiert) und lightning.gpu (der GPU-basiert ist). Stellen Sie den Simulatoren benutzerdefinierte Gate-Zerlegungen zur Verfügung, um verschiedene Gradienten zu berechnen.

Jetzt sind Sie bereit, das Skript zum Starten des Hybrid-Jobs vorzubereiten. Führen Sie den QAOA-Algorithmus mit zwei Instanztypen aus: ml.m5.2xlarge und. ml.g4dn.xlarge Der ml.m5.2xlarge Instanztyp ist vergleichbar mit einem Standard-Entwickler-Laptop. Dabei ml.g4dn.xlarge handelt es sich um eine beschleunigte Recheninstanz mit einer einzelnen NVIDIA T4-GPU mit 16 GB Arbeitsspeicher.

Um die GPU auszuführen, müssen wir zunächst ein kompatibles Image und die richtige Instanz angeben (die standardmäßig eine ml.m5.2xlarge Instanz ist).

from braket.aws import AwsSession
from braket.jobs.image_uris import Framework, retrieve_image

image_uri = retrieve_image(Framework.PL_PYTORCH, AwsSession().region)
instance_config = InstanceConfig(instanceType="ml.g4dn.xlarge")

Diese müssen wir dann zusammen mit den aktualisierten Geräteparametern sowohl in den System- als auch in den Hybrid-Job-Argumenten in den Hybrid-Job-Decorator eingeben.

@hybrid_job(
        device="local:pennylane/lightning.gpu",
        input_data=input_file_path,
        image_uri=image_uri,
        instance_config=instance_config)
def run_qaoa_hybrid_job_gpu(p=1, steps=10):
    params = np.random.rand(2, p)

    braket_task_tracker = Tracker()

    graph = nx.read_adjlist(input_file_path, nodetype=int)
    wires = list(graph.nodes)
    cost_h, _mixer_h = qaoa.maxcut(graph)

    device_string = os.environ["AMZN_BRAKET_DEVICE_ARN"]
    prefix, device_name = device_string.split("/")
    dev= qml.device(simulator_name, wires=len(wires))
    ...

Die durchschnittliche Iterationszeit für die m5.2xlarge Instanz beträgt etwa 73 Sekunden, während sie für die ml.g4dn.xlarge Instanz etwa 0,6 Sekunden beträgt. Für diesen 21-Qubit-Workflow bietet uns die GPU-Instanz eine 100-fache Beschleunigung. Wenn Sie sich die Preisseite für Amazon Braket Hybrid Jobs ansehen, können Sie sehen, dass die Kosten pro Minute für eine m5.2xlarge Instance 0,00768 USD betragen, während sie für die ml.g4dn.xlarge Instance 0,01227 USD betragen. In diesem Fall ist die Ausführung auf der GPU-Instanz schneller und günstiger.

Maschinelles Quantenlernen und Datenparallelität

Wenn es sich bei Ihrem Workload-Typ um quantenmechanisches Lernen (QML) handelt, das anhand von Datensätzen trainiert, können Sie Ihren Workload mithilfe von Datenparallelität weiter beschleunigen. In QML enthält das Modell einen oder mehrere Quantenschaltkreise. Das Modell kann auch klassische neuronale Netze enthalten oder auch nicht. Beim Training des Modells mit dem Datensatz werden die Parameter im Modell aktualisiert, um die Verlustfunktion zu minimieren. Eine Verlustfunktion wird normalerweise für einen einzelnen Datenpunkt und der Gesamtverlust für den durchschnittlichen Verlust über den gesamten Datensatz definiert. In QML werden die Verluste normalerweise seriell berechnet, bevor bei Gradientenberechnungen der Durchschnitt zum Gesamtverlust berechnet wird. Dieses Verfahren ist zeitaufwändig, insbesondere wenn es Hunderte von Datenpunkten gibt.

Da der Verlust von einem Datenpunkt nicht von anderen Datenpunkten abhängt, können die Verluste parallel ausgewertet werden! Verluste und Gradienten, die mit verschiedenen Datenpunkten verbunden sind, können gleichzeitig ausgewertet werden. Dies wird als Datenparallelität bezeichnet. Mit SageMaker der verteilten Datenparallelbibliothek erleichtert Ihnen Amazon Braket Hybrid Jobs die Nutzung von Datenparallelität, um Ihr Training zu beschleunigen.

Stellen Sie sich den folgenden QML-Workload für Datenparallelität vor, der den Sonar-Datensatz aus dem bekannten UCI-Repository als Beispiel für die binäre Klassifizierung verwendet. Der Sonar-Datensatz enthält 208 Datenpunkte mit jeweils 60 Merkmalen, die anhand von Sonarsignalen erfasst wurden, die von Materialien abprallen. Jeder Datenpunkt ist entweder mit „M“ für Minen oder mit „R“ für Gesteine gekennzeichnet. Unser QML-Modell besteht aus einer Eingangsschicht, einem Quantenschaltkreis als versteckte Schicht und einer Ausgangsschicht. Die Eingabe- und Ausgabeschichten sind klassische neuronale Netze, die in PyTorch implementiert sind. Der Quantenschaltkreis ist mithilfe PennyLane des qml.qnn-Moduls in die PyTorch neuronalen Netze integriert. Weitere Informationen zur Arbeitslast finden Sie in unseren Beispiel-Notizbüchern. Wie im obigen QAOA-Beispiel können Sie die Leistung der GPU nutzen, indem Sie eingebettete GPU-basierte Simulatoren wie PennyLane diese verwenden, um die Leistung gegenüber eingebetteten CPU-basierten Simulatoren lightning.gpu zu verbessern.

Um einen Hybrid-Job zu erstellen, können Sie das Algorithmus-Skript, das Gerät AwsQuantumJob.create und andere Konfigurationen über seine Schlüsselwortargumente aufrufen und angeben.

instance_config = InstanceConfig(instanceType='ml.g4dn.xlarge')

hyperparameters={"nwires": "10",
                 "ndata": "32",
                 ...
}

job = AwsQuantumJob.create(
    device="local:pennylane/lightning.gpu",
    source_module="qml_source",
    entry_point="qml_source.train_single",
    hyperparameters=hyperparameters,
    instance_config=instance_config,
    ...
)

Um Datenparallelität zu verwenden, müssen Sie einige Codezeilen im Algorithmus-Skript für die SageMaker verteilte Bibliothek ändern, um das Training korrekt zu parallelisieren. Zunächst importieren Sie das smdistributed Paket, das den Großteil der Arbeit für die Verteilung Ihrer Workloads auf mehrere und mehrere Instanzen übernimmt. GPUs Dieses Paket ist im Braket und in den Containern vorkonfiguriert. PyTorch TensorFlow Das dist Modul teilt unserem Algorithmus-Skript mit, wie hoch die Gesamtzahl der GPUs Trainingseinheiten (world_size) ist rank und wie hoch der Wert local_rank eines GPU-Kerns ist. rankist der absolute Index einer GPU für alle Instanzen, während local_rank es der Index einer GPU innerhalb einer Instanz ist. Wenn es beispielsweise vier Instanzen gibt, von denen jeweils acht für das Training GPUs zugewiesen sind, rank liegen die Werte zwischen 0 und 31 und die local_rank Bereiche zwischen 0 und 7.

import smdistributed.dataparallel.torch.distributed as dist

dp_info = {
    "world_size": dist.get_world_size(),
    "rank": dist.get_rank(),
    "local_rank": dist.get_local_rank(),
}
batch_size //= dp_info["world_size"] // 8
batch_size = max(batch_size, 1)

Als Nächstes definieren Sie a DistributedSampler entsprechend dem world_size und rank und übergeben es dann an den Datenlader. Dieser Sampler vermeidet den GPUs Zugriff auf dasselbe Segment eines Datensatzes.

train_sampler = torch.utils.data.distributed.DistributedSampler(
    train_dataset,
    num_replicas=dp_info["world_size"],
    rank=dp_info["rank"]
)
train_loader = torch.utils.data.DataLoader(
    train_dataset,
    batch_size=batch_size,
    shuffle=False,
    num_workers=0,
    pin_memory=True,
    sampler=train_sampler,
)

Als Nächstes verwenden Sie die DistributedDataParallel Klasse, um Datenparallelität zu aktivieren.

from smdistributed.dataparallel.torch.parallel.distributed import DistributedDataParallel as DDP

model = DressedQNN(qc_dev).to(device)
model = DDP(model)
torch.cuda.set_device(dp_info["local_rank"])
model.cuda(dp_info["local_rank"])

Die oben genannten Änderungen sind erforderlich, um Datenparallelität zu verwenden. In QML möchten Sie häufig Ergebnisse speichern und den Trainingsfortschritt ausdrucken. Wenn jede GPU den Befehl zum Speichern und Drucken ausführt, wird das Protokoll mit den wiederholten Informationen überflutet und die Ergebnisse überschreiben sich gegenseitig. Um dies zu vermeiden, können Sie nur von der GPU aus speichern und drucken, die 0 hatrank.

if dp_info["rank"]==0:
    print('elapsed time: ', elapsed)
    torch.save(model.state_dict(), f"{output_dir}/test_local.pt")
    save_job_result({"last loss": loss_before})

Amazon Braket Hybrid Jobs unterstützt ml.g4dn.12xlarge Instance-Typen für die SageMaker Distributed Data Parallel Library. Sie konfigurieren den Instance-Typ über das InstanceConfig Argument in Hybrid Jobs. Damit die SageMaker Distributed Data Parallel Library weiß, dass Datenparallelität aktiviert ist, müssen Sie zwei zusätzliche Hyperparameter hinzufügen: "sagemaker_distributed_dataparallel_enabled" Einstellung auf "true" und "sagemaker_instance_type" Einstellung auf den Instanztyp, den Sie verwenden. Diese beiden Hyperparameter werden pro Paket verwendet. smdistributed Ihr Algorithmus-Skript muss sie nicht explizit verwenden. Im Amazon Braket SDK bietet es ein praktisches Schlüsselwortargumentdistribution. distribution="data_parallel"Bei der Erstellung hybrider Jobs fügt das Amazon Braket SDK die beiden Hyperparameter automatisch für Sie ein. Wenn Sie die Amazon Braket-API verwenden, müssen Sie diese beiden Hyperparameter einbeziehen.

Wenn die Instanz und die Datenparallelität konfiguriert sind, können Sie jetzt Ihren Hybrid-Job einreichen. Es gibt 4 GPUs in einer ml.g4dn.12xlarge Instanz. Wenn Sie diese Einstellung instanceCount=1 vornehmen, wird die Arbeitslast auf die 8 Instanzen GPUs in der Instanz verteilt. Wenn Sie instanceCount mehr als eine festlegen, wird die Arbeitslast auf alle GPUs verfügbaren Instanzen verteilt. Wenn Sie mehrere Instanzen verwenden, fällt für jede Instanz eine Gebühr an, die davon abhängt, wie lange Sie sie verwenden. Wenn Sie beispielsweise vier Instances verwenden, beträgt die abrechnungsfähige Zeit das Vierfache der Laufzeit pro Instance, da Ihre Workloads von vier Instances gleichzeitig ausgeführt werden.

instance_config = InstanceConfig(instanceType='ml.g4dn.12xlarge',
                                 instanceCount=1,
)

hyperparameters={"nwires": "10",
                 "ndata": "32",
                 ...,
}

job = AwsQuantumJob.create(
    device="local:pennylane/lightning.gpu",
    source_module="qml_source",
    entry_point="qml_source.train_dp",
    hyperparameters=hyperparameters,
    instance_config=instance_config,
    distribution="data_parallel",
    ...
)

Bei richtiger Anwendung kann die Verwendung mehrerer Instanzen zu einer erheblichen Zeit- und Kostenreduzierung führen. Weitere Informationen finden Sie im Beispiel-Notizbuch.