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 hybride Workloads auszuführen. Der GPU-based eingebettete Simulator von Pennylane verwendet die Nvidia lightning.gpu CuQuantum-Bibliothek, um Schaltungssimulationen zu beschleunigen. Der eingebettete GPU-Simulator ist in allen Braket-Jobcontainern vorkonfiguriert, sodass Benutzer sie sofort verwenden können. Auf dieser Seite zeigen wir Ihnen, wie Sie Ihre lightning.gpu Hybrid-Workloads beschleunigen können.

Verwenden von lightning.gpu für QAOA-Workloads

Sehen Sie sich die Beispiele für den Quantum Approximate Optimization Algorithm (QAOA) aus diesem Notizbuch an. https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/hybrid_jobs/2_Using_PennyLane_with_Braket_Hybrid_Jobs Um einen eingebetteten Simulator auszuwählen, geben Sie als device Argument eine Zeichenfolge der Form an:. "local:<provider>/<simulator_name>" Zum Beispiel würden Sie "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 (welcher ist CPU-based) und lightning.gpu (welcher ist GPU-based). Versehen Sie die Simulatoren mit benutzerdefinierten Gate-Zerlegungen, um verschiedene Gradienten zu berechnen.

Jetzt sind Sie bereit, das hybride Jobstartskript 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. Das ml.g4dn.xlarge ist eine beschleunigte Recheninstanz, die über eine einzelne NVIDIA T4-GPU mit 16 GB Speicher verfügt.

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 Instance 0,01227 USD betragen. ml.g4dn.xlarge In diesem Fall ist die Ausführung auf der GPU-Instance schneller und billiger.

Maschinelles Quantenlernen und Datenparallelität

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

Da der Verlust eines Datenpunkts nicht von anderen Datenpunkten abhängt, können die Verluste parallel ausgewertet werden! Verluste und Gradienten, die verschiedenen Datenpunkten zugeordnet sind, können gleichzeitig ausgewertet werden. Dies wird als Datenparallelität bezeichnet. Mit SageMaker der Bibliothek für verteilte parallele Daten 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, bei dem der https://archive.ics.uci.edu/dataset/151/connectionist+bench+sonar+mines+vs+rocks Sonar-Datensatz aus dem bekannten UCI-Repository als Beispiel für die binäre Klassifizierung verwendet wird. 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 Felsen beschriftet. Unser QML-Modell besteht aus einer Eingabeschicht, einem Quantenschaltkreis als versteckte Schicht und einer Ausgangsschicht. Die Eingabe- und Ausgabeschichten sind klassische neuronale Netze, in PyTorch denen implementiert ist. Der Quantenschaltkreis wird mithilfe PennyLane des Moduls qml.qnn in die PyTorch neuronalen Netze integriert. Weitere Informationen zur Arbeitslast finden Sie in unseren Beispiel-Notizbüchern. Wie im QAOA-Beispiel oben können Sie die Leistung der GPU nutzen, indem Sie eingebettete GPU-based Simulatoren wie PennyLane diese verwenden, um die Leistung gegenüber eingebetteten Simulatoren lightning.gpu zu verbessern. CPU-based

Um einen Hybrid-Job zu erstellen, können Sie das Algorithmus-Skript, das Gerät AwsQuantumJob.create und andere Konfigurationen mithilfe der 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 nutzen, müssen Sie einige Codezeilen im Algorithmusskript für die SageMaker verteilte Bibliothek ändern, um das Training korrekt zu parallelisieren. Zuerst importieren Sie das smdistributed Paket, das die meiste Arbeit für die Verteilung Ihrer Workloads auf mehrere GPUs und mehrere Instanzen übernimmt. 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 für das Training (world_size) ist, rank sowie das Ende local_rank eines GPU-Kerns. rankist der absolute Index einer GPU für alle Instanzen, während local_rank es sich um den Index einer GPU innerhalb einer Instanz handelt. Wenn es beispielsweise vier Instanzen gibt, denen jeweils acht GPUs für das Training zugewiesen sind, rank reichen die Werte von 0 bis 31 und die local_rank Bereiche von 0 bis 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 eine DistributedSampler entsprechend dem world_size und rank und übergeben sie dann an den Datenlader. Dieser Sampler verhindert, dass GPUs auf denselben Teil eines Datensatzes zugreifen.

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 verteilte parallele Datenbibliothek. Sie konfigurieren den Instanztyp über das InstanceConfig Argument in Hybrid Jobs. Damit die SageMaker Distributed Data Parallel Library weiß, dass die Datenparallelität aktiviert ist, müssen Sie zwei zusätzliche Hyperparameter hinzufügen: "sagemaker_distributed_dataparallel_enabled" Einstellung "true" und "sagemaker_instance_type" Einstellung des verwendeten Instanztyps. Diese beiden Hyperparameter werden vom 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 hybriden Joberstellung 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.

Nachdem die Instanz und die Datenparallelität konfiguriert sind, können Sie jetzt Ihren Hybrid-Job einreichen. In einer Instanz befinden sich 4 GPUs. ml.g4dn.12xlarge Wenn Sie festlegeninstanceCount=1, wird die Arbeitslast auf die 8 GPUs in der Instanz verteilt. Wenn Sie instanceCount mehr als eine festlegen, wird die Arbeitslast auf die in allen Instanzen verfügbaren GPUs 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 fakturierbare Zeit das Vierfache der Laufzeit pro Instance, da Ihre Workloads auf 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 Verwendung kann die Verwendung mehrerer Instanzen zu einer Reduzierung des Zeit- und Kostenaufwands um ein Vielfaches führen. Weitere Informationen finden Sie im Beispiel-Notizbuch.