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.
# Amazon Neptune ML für Machine Learning anhand von Diagrammen
Große verbundene Datensätze enthalten häufig wertvolle Informationen, die nur schwer mit Abfragen extrahiert werden können, die allein auf menschlicher Intuition basieren. Machine-Learning (ML)-Techniken können helfen, in Diagrammen mit Milliarden von Beziehungen verborgene Korrelationen zu finden. Diese Korrelationen können nützlich sein, um Produkte zu empfehlen, die Kreditwürdigkeit vorherzusagen, Betrugsfälle zu erkennen und mehr.
Das Neptune-ML-Feature ermöglicht das Erstellen und Trainieren nützlicher Machine-Learning-Modelle anhand großer Diagramme in wenigen Stunden statt in Wochen. [Um dies zu erreichen, verwendet Neptune ML die Graph Neural Network (GNN) -Technologie, die von [Amazon SageMaker AI](https://aws.amazon.com/sagemaker/) und der [Deep Graph Library (DGL) (Open Source)](https://www.dgl.ai/) unterstützt wird.](https://github.com/dmlc/dgl/) Graph Neural Networks sind ein neues Feld in der künstlichen Intelligenz (siehe Umfassende Übersicht über Graph Neural Networks). Ein praktisches Tutorial zur Verwendung GNNs mit DGL finden Sie unter [Lernen neuronaler Graphennetzwerke mit der Deep Graph Library](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library).
**Anmerkung**
Diagrammeckpunkte werden in Neptune-ML-Modellen als „Knoten“ bezeichnet. Beispielsweise verwendet die Eckpunktklassifizierung ein Machine-Learning-Modell für die Knotenklassifizierung. Die Eckpunktregression verwendet ein Knotenregressionsmodell.
## Fähigkeiten von Neptune ML
Neptune unterstützt sowohl die transduktive Inferenz, die Vorhersagen zurückgibt, die während des Trainings anhand der Diagrammdaten vorab berechnet wurden, und die induktive Inferenz, die Datenverarbeitung und Modellauswertung in Echtzeit basierend auf aktuellen Daten ausführt und zurückgibt. Siehe [Der Unterschied zwischen induktiver und transduktiver Inferenz](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference).
Neptune ML kann Machine-Learning-Modelle zur Unterstützung von fünf verschiedenen Inferenzkategorien trainieren:
**Arten der zurzeit von Neptune ML unterstützten Inferenzaufgaben**
+ **Knotenklassifizierung** – Vorhersage des kategorischen Features einer Eckpunkteigenschaft.
Beispielsweise kann Neptune ML für den Film *Die Verurteilten* dessen `genre`-Eigenschaft als `story` vorhersagen, basierend auf einem Satz mit den Kandidaten `[story, crime, action, fantasy, drama, family, ...]`.
Es gibt zwei Arten von Aufgaben zur Knotenklassifizierung:
+ **Einzelklassenklassifizierung**: Bei dieser Art von Aufgabe besitzt jeder Knoten nur ein Ziel-Feature. Beispielsweise hat die Eigenschaft `Place_of_birth` von `Alan Turing` den Wert `UK`.
+ **Mehrklassenklassifizierung**: Bei dieser Art von Aufgabe besitzt jeder Knoten mehr als ein Ziel-Feature. Beispielsweise hat die Eigenschaft `genre` des Films *Der Pate* die Werte `crime` und `story`.
+ **Knotenregression** – Vorhersage einer numerischen Eigenschaft eines Eckpunkts.
Beispielsweise kann Neptune ML für den Film *Avengers: Endgame* vorhersagen, dass dessen Eigenschaft `popularity` den Wert `5.0` hat.
+ **Kantenklassifizierung** – Vorhersage des kategorischen Features einer Kanteneigenschaft.
Es gibt zwei Arten von Aufgaben zur Kantenklassifizierung:
+ **Einzelklassenklassifizierung**: Bei dieser Art von Aufgabe besitzt jede Kante nur ein Ziel-Feature. Eine Bewertungskante zwischen einem Benutzer und einem Film könnte beispielsweise die Eigenschaft `liked` mit dem Wert „Ja“ oder „Nein“ haben.
+ **Mehrklassenklassifizierung**: Bei dieser Art von Aufgabe besitzt jede Kante mehr als ein Ziel-Feature. Beispielsweise kann eine Bewertungskante zwischen einem Benutzer und einem Film mehrere Werte für das Eigenschafts-Tag haben, z. B. „Lustig“, „Herzerwärmend“, „Entspannend“ usw.
+ **Kantenregression** – Vorhersage einer numerischen Eigenschaft einer Kante.
Beispielsweise könnte eine Bewertungskante zwischen einem Benutzer und einem Film die numerische Eigenschaft `score` haben, für die Neptune ML einen Wert anhand eines Benutzers und eines Films vorhersagen könnte.
+ **Linkvorhersage** – Vorhersage der wahrscheinlichsten Zielknoten für einen bestimmten Quellknotens und eine bestimmte ausgehende Kante oder der wahrscheinlichsten Quellknoten für einen bestimmten Zielknoten und eine bestimmte eingehende Kante.
Beispielsweise kann Neptune ML anhand eines Arzneimittel-Erkrankung-Wissensdiagramms anhand von `Aspirin` als Quellknoten und `treats` als ausgehende Kante die relevantesten Zielknoten als `heart disease`, `fever` usw. vorhersagen.
Neptune ML kann auch anhand des Wikimedia-Wissensdiagramms mit `President-of` als Kante oder Beziehung und `United-States` als Zielknoten die relevantesten Köpfe als `George Washington`, `Abraham Lincoln`, `Franklin D. Roosevelt` usw. vorhersagen.
**Anmerkung**
Knotenklassifizierung und Kantenklassifizierung unterstützen nur Zeichenfolgenwerte. Das bedeutet, dass numerische Eigenschaftswerte wie `0` oder `1` nicht unterstützt werden, auch wenn die Zeichenfolgenäquivalente `"0"` und `"1"` unterstützt werden. Ähnlich funktionieren die booleschen Eigenschaftswerte `true` und `false` nicht, während `"true"` und `"false"` funktionieren.
Mit Neptune ML können Sie Machine-Learning-Modelle verwenden, die zu zwei allgemeinen Kategorien gehören:
**Arten von Machine-Learning-Modellen, die Neptune ML zurzeit unterstützt**
+ **Graph Neural Network (GNN) -Modelle** — Dazu gehören [Relational Graph Convolutional Networks](https://arxiv.org/abs/1703.06103) (R-). GCNs GNN-Modelle funktionieren für alle drei oben genannten Aufgabentypen.
+ **Knowledge-Graph-Embedding (KGE)-Modelle** – Dies umfasst `TransE`-, `DistMult`- und `RotatE`-Modelle. Sie funktionieren nur für Linkvorhersagen.
**Benutzerdefinierte Modelle** – Mit Neptune ML können Sie auch für alle oben genannten Aufgabentypen eine eigene benutzerdefinierte Modellimplementierung bereitstellen. Sie können Ihre Python-basierte benutzerdefinierte Modellimplementierung mit dem [Neptune-ML-Toolkit](https://github.com/awslabs/neptuneml-toolkit) entwickeln und testen, bevor Sie die Neptune-ML-Trainings-API mit Ihrem Modell verwenden. Einzelheiten dazu, wie Sie Ihre Implementierung strukturieren und organisieren können, damit sie mit der Neptune-ML-Trainingsinfrastruktur kompatibel ist, finden Sie unter [Benutzerdefinierte Modelle in Neptune ML](machine-learning-custom-models.md).
# Einrichten von Neptune ML
Der einfachste Weg, mit Neptune ML zu beginnen, ist [die Verwendung der CloudFormation Schnellstart-Vorlage](machine-learning-quick-start.md). Diese Vorlage installiert alle erforderlichen Komponenten, einschließlich eines neuen Neptune-DB-Clusters, aller erforderlichen IAM-Rollen und eines neuen Neptune-Graph-Notebooks, um die Arbeit mit Neptune ML zu vereinfachen.
Sie können Neptune ML auch manuell installieren, wie in [Neptune ML einrichten, ohne die Schnellstartvorlage zu verwenden CloudFormation](machine-learning-manual-setup.md) beschrieben.
# Verwenden der Neptune AWS CloudFormation ML-Vorlage für einen schnellen Einstieg in einem neuen DB-Cluster
Der einfachste Weg, mit Neptune ML zu beginnen, ist die Verwendung der CloudFormation Schnellstart-Vorlage. Diese Vorlage installiert alle erforderlichen Komponenten, einschließlich eines neuen Neptune-DB-Clusters, aller erforderlichen IAM-Rollen und eines neuen Neptune-Graph-Notebooks, um die Arbeit mit Neptune ML zu vereinfachen.
**So erstellen Sie den Schnellstart-Stack für Neptune ML**
1. Um den CloudFormation Stack auf der CloudFormation Konsole zu starten, wählen Sie eine der Schaltflächen **Stack starten** in der folgenden Tabelle:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/machine-learning-quick-start.html)
1. Wählen Sie auf der Seite **Vorlage auswählen** die Option **Weiter** aus.
1. Wählen Sie auf der Seite **Specify Details (Details angeben)** die Option **Next (Weiter)** aus.
1. Wählen Sie auf der Seite **Optionen** **Weiter** aus.
1. Auf der Seite **Überprüfen** gibt es zwei Kontrollkästchen, die Sie aktivieren müssen:
+ Die erste bestätigt, dass AWS CloudFormation möglicherweise IAM-Ressourcen mit benutzerdefinierten Namen erstellt werden.
+ Die zweite räumt ein, dass AWS CloudFormation möglicherweise die `CAPABILITY_AUTO_EXPAND` Fähigkeit für den neuen Stack erforderlich ist. `CAPABILITY_AUTO_EXPAND`erlaubt ausdrücklich CloudFormation , Makros bei der Erstellung des Stacks automatisch und ohne vorherige Überprüfung zu erweitern.
Kunden erstellen häufig einen Änderungssatz aus einer verarbeiteten Vorlage, sodass die von Makros vorgenommenen Änderungen überprüft werden können, bevor der Stack tatsächlich erstellt wird. Weitere Informationen finden Sie in der CloudFormation [CreateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html)-API.
Wählen Sie die Option **Erstellen** aus.
Mit der Schnellstartvorlage wird Folgendes erstellt und eingerichtet:
+ Ein Neptune-DB-Cluster
+ Die erforderlichen IAM-Rollen (Diese werden auch angefügt.)
+ Die erforderliche EC2 Amazon-Sicherheitsgruppe.
+ Die erforderlichen SageMaker KI-VPC-Endpunkte.
+ Eine DB-Cluster-Parametergruppe für Neptune ML
+ Die erforderlichen Parameter in dieser Parametergruppe
+ Ein SageMaker KI-Notizbuch mit vorausgefüllten Notizbuchbeispielen für Neptune ML. Beachten Sie, dass nicht alle Instance-Größen in jeder Region verfügbar sind. Sie müssen also sicherstellen, dass die ausgewählte Notebook-Instance-Größe von Ihrer Region unterstützt wird.
+ Der Service Neptune-Export
Wenn der Schnellstart-Stack fertig ist, rufen Sie das SageMaker KI-Notebook auf, das mit der Vorlage erstellt wurde, und schauen Sie sich die vorausgefüllten Beispiele an. Sie helfen Ihnen dabei, Beispiel-Datensätze herunterzuladen, die Sie zum Experimentieren mit Neptune-ML-Funktionen verwenden können.
Außerdem können Sie damit viel Zeit sparen, wenn Sie Neptune ML verwenden. Sehen Sie sich zum Beispiel die Zeilen-Magic [%neptune\$1ml](notebooks-magics.md#notebooks-line-magics-neptune_ml) und die Zellen-Magic [%%neptune\$1ml](notebooks-magics.md#notebooks-cell-magics-neptune_ml) an, die diese Notebooks unterstützen.
Sie können auch den folgenden AWS CLI Befehl verwenden, um die Schnellstart-Vorlage auszuführen: CloudFormation
```
aws cloudformation create-stack \
--stack-name neptune-ml-fullstack-$(date '+%Y-%m-%d-%H-%M') \
--template-url https://aws-neptune-customer-samples.s3.amazonaws.com/v2/cloudformation-templates/neptune-ml-nested-stack.json \
--parameters ParameterKey=EnableIAMAuthOnExportAPI,ParameterValue=(true if you have IAM auth enabled, or false otherwise) \
ParameterKey=Env,ParameterValue=test$(date '+%H%M')\
--capabilities CAPABILITY_IAM \
--region (the AWS region, like us-east-1) \
--disable-rollback \
--profile (optionally, a named CLI profile of yours)
```
# Neptune ML einrichten, ohne die Schnellstartvorlage zu verwenden CloudFormation
Dieses Handbuch enthält step-by-step Anweisungen zur Einrichtung von Amazon Neptune ML ohne Verwendung der AWS CloudFormation Schnellstartvorlage. Es wird davon ausgegangen, dass Sie bereits über einen funktionierenden Neptune-DB-Cluster verfügen, und behandelt die notwendige Einrichtung, einschließlich der Installation des Neptune-Export-Dienstes, der Erstellung benutzerdefinierter IAM-Rollen und der Konfiguration Ihres DB-Clusters zur Aktivierung von Neptune ML. In der Anleitung wird auch erklärt, wie Sie zwei SageMaker KI-Endpunkte in Ihrer Neptune-VPC erstellen, um der Neptune-Engine Zugriff auf das erforderliche KI-Management zu gewähren. SageMaker APIs Wenn Sie diese Anweisungen befolgen, können Sie Neptune ML auf Ihrer vorhandenen Neptune-Infrastruktur einrichten, ohne sich auf die Vorlage verlassen zu müssen. CloudFormation
## Beginnen mit einem funktionierenden Neptune-DB-Cluster
Wenn Sie die CloudFormation Schnellstartvorlage nicht für die Einrichtung von Neptune ML verwenden, benötigen Sie einen vorhandenen Neptune-DB-Cluster, mit dem Sie arbeiten können. Sie können entweder einen bereits vorhandenen Neptune-DB-Cluster verwenden, einen Neptune-DB-Cluster, den Sie bereits verwenden, klonen oder einen neuen Neptune-DB-Cluste erstellen (siehe [Neptun-Cluster erstellen](get-started-create-cluster.md)).
## Installieren des Service Neptune-Export
Installieren Sie den Service Neptune-Export gemäß den Anweisungen unter [Verwenden des Neptune-Export-Services zum Exportieren von Neptune-Daten](export-service.md), falls Sie dies noch nicht getan haben.
Fügen Sie der Sicherheitsgruppe `NeptuneExportSecurityGroup`, die bei der Installation erstellt wird, eine Regel für eingehenden Datenverkehr mit den folgenden Einstellungen hinzu:
+ *Typ:* `Custom TCP`
+ *Protocol (Protokoll)*: `TCP`
+ *Port-Bereich*: `80 - 443`
+ *Quelle*: *(Neptune DB cluster security group ID)*
## Erstellen Sie eine benutzerdefinierte S3-IAM-Rolle NeptuneLoadFrom
Erstellen Sie die benutzerdefinierte IAM-Rolle`NeptuneLoadFromS3` gemäß dem Anweisungen unter [Erstellen einer IAM-Rolle für den Zugriff auf Amazon S3](bulk-load-tutorial-IAM-CreateRole.md), falls Sie dies noch nicht getan haben.
## Erstellen Sie eine benutzerdefinierte Rolle NeptuneSageMaker IAMRole
Verwenden Sie die [IAM-Konsole](https://console.aws.amazon.com/iam/), um eine benutzerdefinierte `NeptuneSageMakerIAMRole` mit der folgenden Richtlinie zu erstellen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ec2:CreateNetworkInterface",
"ec2:CreateNetworkInterfacePermission",
"ec2:CreateVpcEndpoint",
"ec2:DeleteNetworkInterface",
"ec2:DeleteNetworkInterfacePermission",
"ec2:DescribeDhcpOptions",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeRouteTables",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcs"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"ecr:GetAuthorizationToken",
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::*:role/*"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"sagemaker.amazonaws.com"
]
}
},
"Effect": "Allow"
},
{
"Action": [
"kms:CreateGrant",
"kms:Decrypt",
"kms:GenerateDataKey*"
],
"Resource": "arn:aws:kms:*:*:key/*",
"Effect": "Allow"
},
{
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams",
"logs:GetLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/sagemaker/*"
],
"Effect": "Allow"
},
{
"Action": [
"sagemaker:AddTags",
"sagemaker:CreateEndpoint",
"sagemaker:CreateEndpointConfig",
"sagemaker:CreateHyperParameterTuningJob",
"sagemaker:CreateModel",
"sagemaker:CreateProcessingJob",
"sagemaker:CreateTrainingJob",
"sagemaker:CreateTransformJob",
"sagemaker:DeleteEndpoint",
"sagemaker:DeleteEndpointConfig",
"sagemaker:DeleteModel",
"sagemaker:DescribeEndpoint",
"sagemaker:DescribeEndpointConfig",
"sagemaker:DescribeHyperParameterTuningJob",
"sagemaker:DescribeModel",
"sagemaker:DescribeProcessingJob",
"sagemaker:DescribeTrainingJob",
"sagemaker:DescribeTransformJob",
"sagemaker:InvokeEndpoint",
"sagemaker:ListTags",
"sagemaker:ListTrainingJobsForHyperParameterTuningJob",
"sagemaker:StopHyperParameterTuningJob",
"sagemaker:StopProcessingJob",
"sagemaker:StopTrainingJob",
"sagemaker:StopTransformJob",
"sagemaker:UpdateEndpoint",
"sagemaker:UpdateEndpointWeightsAndCapacities"
],
"Resource": [
"arn:aws:sagemaker:*:*:*"
],
"Effect": "Allow"
},
{
"Action": [
"sagemaker:ListEndpointConfigs",
"sagemaker:ListEndpoints",
"sagemaker:ListHyperParameterTuningJobs",
"sagemaker:ListModels",
"sagemaker:ListProcessingJobs",
"sagemaker:ListTrainingJobs",
"sagemaker:ListTransformJobs"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject",
"s3:AbortMultipartUpload",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::*"
],
"Effect": "Allow"
}
]
}
```
------
Bearbeiten Sie während der Erstellung dieser Rolle die Vertrauensstellung, sodass sie wie folgt aussieht:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"ec2.amazonaws.com",
"rds.amazonaws.com",
"sagemaker.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Kopieren Sie abschließend den ARN, der dieser neuen Rolle `NeptuneSageMakerIAMRole` zugewiesen ist.
**Wichtig**
Stellen Sie sicher, dass die Amazon-S3-Berechtigungen in `NeptuneSageMakerIAMRole` mit den oben aufgeführten übereinstimmen.
Der universelle ARN `arn:aws:s3:::*` wird in der obigen Richtlinie für die Amazon-S3-Ressource verwendet. Wenn der universelle ARN aus irgendeinem Grund nicht verwendet werden kann, müssen `arn:aws:s3:::graphlytics*` und der ARN für jede andere Amazon-S3-Kundenressource, die von NeptuneML-Befehlen verwendet wird, dem Ressourcenbereich hinzugefügt werden.
## Konfigurieren Ihres DB-Clusters zur Aktivierung von Neptune ML
**So richten Sie Ihren DB-Cluster für Neptune ML ein**
1. Navigieren Sie in der [Neptune-Konsole](https://console.aws.amazon.com/neptune) zu **Parametergruppen** und dann zu der DB-Cluster-Parametergruppe, die dem DB-Cluster zugeordnet ist, den Sie verwenden werden. Setzen Sie den Parameter `neptune_ml_iam_role` auf den ARN, der der gerade erstellten Rolle zugewiesen ist.
1. Navigieren Sie zu Datenbanken und wählen Sie dann den DB-Cluster aus, den Sie für Neptune ML verwenden werden. Wählen Sie **Aktionen** und dann **IAM-Rollen verwalten** aus.
1. Wählen Sie auf der Seite **IAM-Rollen verwalten** die Option **Rolle hinzufügen** aus und fügen Sie `NeptuneSageMakerIAMRole` hinzu. Fügen Sie dann die Rolle `NeptuneLoadFromS3` hinzu.
1. Starten Sie die Writer-Instance Ihres DB-Clusters neu.
## Erstellen Sie zwei SageMaker KI-Endpunkte in Ihrer Neptune VPC
Um der Neptune-Engine Zugriff auf das erforderliche SageMaker KI-Management zu gewähren APIs, müssen Sie schließlich zwei SageMaker KI-Endpunkte in Ihrer Neptune-VPC erstellen, wie unter erklärt. [Erstellen Sie zwei Endpunkte für SageMaker KI in Ihrer Neptune VPC](machine-learning-cluster-setup.md#machine-learning-sm-endpoints)
# Manuelles Konfigurieren eines Neptune-Notebooks für Neptune ML
Neptune SageMaker AI-Notebooks sind mit einer Vielzahl von Musternotizbüchern für Neptune ML vorinstalliert. [Sie können eine Vorschau dieser Beispiele im Open-Source-Graph-Notebook-Repository anzeigen. GitHub ](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning)
Sie können eins der vorhandenen Neptune-Notebooks verwenden oder, wenn Sie möchten, ein eigenes erstellen, indem Sie die Anweisungen unter [Verwenden der Neptune-Workbench zum Hosten von Neptune-Notebooks](graph-notebooks.md#graph-notebooks-workbench) befolgen.
Sie können auch ein standardmäßiges Neptune-Notebook zum Verwenden mit Neptune ML konfigurieren, indem Sie die folgenden Schritte ausführen:
**Ändern eines Notebooks für Neptune ML**
1. Öffnen Sie die Amazon SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im Navigationsbereich auf der linken Seite **Notebook** und dann **Notebook-Instances** aus. Suchen Sie den Namen des Neptune-Notebooks, das Sie für Neptune ML verwenden möchten, und wählen Sie es aus, um die zugehörige Detailseite aufzurufen.
1. Wenn die Notebook-Instance ausgeführt wird, klicken Sie oben rechts auf der Notebook-Detailseite auf die Schaltfläche **Stopp**.
1. Wählen Sie in den **Notebook-Instance-Einstellungen** unter **Lebenszykluskonfiguration** den Link aus, um die Seite zum Lebenszyklus des Notebooks zu öffnen.
1. Wählen Sie oben rechts **Bearbeiten** und dann **Weiter** aus.
1. Ändern Sie auf der Registerkarte **Notebook starten** das Skript, um zusätzliche Exportbefehle aufzunehmen und die Felder für Ihre IAM-Rolle in Neptune ML und den Export-Service-URI auszufüllen – je nach Ihrer Shell in etwa wie folgt:
```
echo "export NEPTUNE_ML_ROLE_ARN=(your Neptune ML IAM role ARN)" >> ~/.bashrc
echo "export NEPTUNE_EXPORT_API_URI=(your export service URI)" >> ~/.bashrc
```
1. Wählen Sie **Aktualisieren**.
1. Kehren Sie zur Notebook-Instance-Seite zurück. Unter **Berechtigungen und Verschlüsselung** gibt es ein Feld für den **IAM-Rollen-ARN**. Wählen Sie den Link in diesem Feld aus, um zu der IAM-Rolle zu gelangen, mit der diese Notebook-Instance ausgeführt wird.
1. Erstellen Sie eine neue Inline-Richtlinie wie diese:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "arn:aws:cloudwatch:us-east-1:111122223333:*",
"Sid": "AllowPutMetrics",
"Effect": "Allow"
},
{
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:DescribeLogStreams",
"logs:PutLogEvents",
"logs:GetLogEvents"
],
"Resource": "arn:aws:logs:us-east-1:111122223333:*",
"Sid": "AllowCreateLogs",
"Effect": "Allow"
},
{
"Action": [
"s3:Put*",
"s3:Get*",
"s3:List*"
],
"Resource": "arn:aws:s3:::*",
"Sid": "AllowS3Actions",
"Effect": "Allow"
},
{
"Action": "execute-api:Invoke",
"Resource": "arn:aws:execute-api:us-east-1:111122223333:*/*",
"Sid": "AllowExecute",
"Effect": "Allow"
},
{
"Action": [
"sagemaker:CreateModel",
"sagemaker:CreateEndpointConfig",
"sagemaker:CreateEndpoint",
"sagemaker:DescribeModel",
"sagemaker:DescribeEndpointConfig",
"sagemaker:DescribeEndpoint",
"sagemaker:DeleteModel",
"sagemaker:DeleteEndpointConfig",
"sagemaker:DeleteEndpoint"
],
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:*/*",
"Sid": "AllowApiActions",
"Effect": "Allow"
},
{
"Action": [
"iam:PassRole"
],
"Resource": "arn:aws:iam::111122223333:role/role-name",
"Sid": "AllowPassRole",
"Effect": "Allow"
}
]
}
```
------
1. Speichern Sie diese neue Richtlinie und fügen Sie sie an die IAM-Rolle aus Schritt 8 an.
1. Wählen Sie oben rechts auf der Detailseite der SageMaker KI-Notebook-Instance **Start** aus, um die Notebook-Instance zu starten.
# Verwenden von AWS CLI , um Neptune ML auf einem DB-Cluster einzurichten
Neben der CloudFormation Schnellstart-Vorlage und dem AWS-Managementkonsole können Sie Neptune ML auch mit dem einrichten. AWS CLI
## Erstellen einer DB-Cluster-Parametergruppe für den neuen Neptune-ML-Cluster
Die folgenden AWS CLI Befehle erstellen eine neue DB-Cluster-Parametergruppe und richten sie so ein, dass sie mit Neptune ML funktioniert:
**So erstellen und konfigurieren Sie eine DB-Cluster-Parametergruppe für Neptune ML**
1. Erstellen Sie eine neue DB-Cluster-Parametergruppe:
```
aws neptune create-db-cluster-parameter-group \
--db-cluster-parameter-group-name (name of the new DB cluster parameter group) \
--db-parameter-group-family neptune1
--description "(description of your machine learning project)" \
--region (AWS region, such as us-east-1)
```
1. Erstellen Sie einen `neptune_ml_iam_role` DB-Cluster-Parametersatz, der auf den ARN des `SageMakerExcecutionIAMRole` gesetzt ist, damit Ihr DB-Cluster ihn beim Aufrufen von SageMaker KI zum Erstellen von Jobs und zum Abrufen von Vorhersagen aus gehosteten ML-Modellen verwenden kann:
```
aws neptune modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name (name of the new DB cluster parameter group) \
--parameters "ParameterName=neptune_ml_iam_role, \
ParameterValue=ARN of the SageMakerExcecutionIAMRole, \
Description=NeptuneMLRole, \
ApplyMethod=pending-reboot" \
--region (AWS region, such as us-east-1)
```
Wenn Sie diesen Parameter festlegen, kann Neptune auf SageMaker KI zugreifen, ohne dass Sie die Rolle bei jedem Anruf weitergeben müssen.
Informationen zum Erstellen von `SageMakerExcecutionIAMRole` finden Sie unter [Erstellen Sie eine benutzerdefinierte Rolle NeptuneSageMaker IAMRole](machine-learning-manual-setup.md#ml-manual-setup-sm-role).
1. Verwenden Sie abschließend `describe-db-cluster-parameters`, um zu überprüfen, ob alle Parameter in der neuen DB-Cluster-Parametergruppe wie gewünscht festgelegt sind:
```
aws neptune describe-db-cluster-parameters \
--db-cluster-parameter-group-name (name of the new DB cluster parameter group) \
--region (AWS region, such as us-east-1)
```
## Anfügen der neuen DB-Cluster-Parametergruppe an den DB-Cluster, der mit Neptune ML verwendet werden soll
Jetzt können Sie die neue DB-Cluster-Parametergruppe, die Sie gerade erstellt haben, mit dem folgenden Befehl an einen vorhandenen DB-Cluster anfügen:
```
aws neptune modify-db-cluster \
--db-cluster-identifier (the name of your existing DB cluster) \
--apply-immediately
--db-cluster-parameter-group-name (name of your new DB cluster parameter group) \
--region (AWS region, such as us-east-1)
```
Anschließend können Sie den DB-Cluster neu starten, damit alle Parameter wirksam werden:
```
aws neptune reboot-db-instance
--db-instance-identifier (name of the primary instance of your DB cluster) \
--profile (name of your AWS profile to use) \
--region (AWS region, such as us-east-1)
```
Wenn Sie einen neuen DB-Cluster zum Verwenden mit Neptune ML erstellen, können Sie alternativ den folgenden Befehl verwenden, um den Cluster mit der angefügten neuen Parametergruppe zu erstellen und dann eine neue primäre (Writer-)Instance zu erstellen:
```
cluster-name=(the name of the new DB cluster)
aws neptune create-db-cluster
--db-cluster-identifier ${cluster-name}
--engine graphdb \
--engine-version 1.0.4.1 \
--db-cluster-parameter-group-name (name of your new DB cluster parameter group) \
--db-subnet-group-name (name of the subnet to use) \
--region (AWS region, such as us-east-1)
aws neptune create-db-instance
--db-cluster-identifier ${cluster-name}
--db-instance-identifier ${cluster-name}-i \
--db-instance-class (the instance class to use, such as db.r5.xlarge)
--engine graphdb \
--region (AWS region, such as us-east-1)
```
## Hängen Sie das `NeptuneSageMakerIAMRole` an Ihren DB-Cluster an, damit es auf SageMaker KI- und Amazon S3 S3-Ressourcen zugreifen kann
Folgen Sie abschließend den Anweisungen unter, [Erstellen Sie eine benutzerdefinierte Rolle NeptuneSageMaker IAMRole](machine-learning-manual-setup.md#ml-manual-setup-sm-role) um eine IAM-Rolle zu erstellen, die es Ihrem DB-Cluster ermöglicht, mit SageMaker KI und Amazon S3 zu kommunizieren. Verwenden Sie dann den folgenden Befehl, um die von Ihnen erstellte Rolle `NeptuneSageMakerIAMRole` an Ihren DB-Cluster anzufügen:
```
aws neptune add-role-to-db-cluster
--db-cluster-identifier ${cluster-name}
--role-arn arn:aws:iam::(the ARN number of the role's ARN):role/NeptuneMLRole \
--region (AWS region, such as us-east-1)
```
## Erstellen Sie zwei Endpunkte für SageMaker KI in Ihrer Neptune VPC
Neptune ML benötigt zwei SageMaker KI-Endpunkte in der VPC Ihres Neptune-DB-Clusters:
+ `com.amazonaws.(AWS region, like us-east-1).sagemaker.runtime`
+ `com.amazonaws.(AWS region, like us-east-1).sagemaker.api`
Wenn Sie die CloudFormation Schnellstart-Vorlage, die diese automatisch für Sie erstellt, nicht verwendet haben, können Sie sie mit den folgenden Befehlen erstellen: AWS CLI
Mit diesem wird der Endpunkt `sagemaker.runtime` erstellt:
```
aws ec2 create-vpc-endpoint
--vpc-id (the ID of your Neptune DB cluster's VPC)
--vpc-endpoint-type Interface
--service-name com.amazonaws.(AWS region, like us-east-1).sagemaker.runtime
--subnet-ids (the subnet ID or IDs that you want to use)
--security-group-ids (the security group for the endpoint network interface, or omit to use the default)
--private-dns-enabled
```
Und mit diesem wird der Endpunkt `sagemaker.api` erstellt:
```
aws ec2 create-vpc-endpoint
--vpc-id (the ID of your Neptune DB cluster's VPC)
--vpc-endpoint-type Interface
--service-name com.amazonaws.(AWS region, like us-east-1).sagemaker.api
--subnet-ids (the subnet ID or IDs that you want to use)
--security-group-ids (the security group for the endpoint network interface, or omit to use the default)
--private-dns-enabled
```
Sie können diese Endpunkte auch mit der [VPC-Konsole](https://console.aws.amazon.com/vpc/) erstellen. Weitere Informationen finden Sie unter [Sichere Prognoseaufrufe in Amazon SageMaker mit AWS PrivateLink](https://aws.amazon.com/blogs/machine-learning/secure-prediction-calls-in-amazon-sagemaker-with-aws-privatelink/) und [Sichern aller SageMaker Amazon-API-Aufrufe mit AWS PrivateLink](https://aws.amazon.com/blogs/machine-learning/securing-all-amazon-sagemaker-api-calls-with-aws-privatelink/).
## Erstellen Sie einen SageMaker AI-Inferenz-Endpunktparameter in Ihrer DB-Cluster-Parametergruppe
Um zu vermeiden, dass Sie den SageMaker AI-Inferenzendpunkt des Modells, das Sie verwenden, bei jeder Abfrage angeben müssen, erstellen Sie einen DB-Cluster-Parameter mit dem Namen `neptune_ml_endpoint` in der DB-Cluster-Parametergruppe für Neptune ML. Legen Sie den Parameter auf die `id` des betreffenden Instance-Endpunkts fest.
Dazu können Sie den folgenden AWS CLI Befehl verwenden:
```
aws neptune modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name neptune-ml-demo \
--parameters "ParameterName=neptune_ml_endpoint, \
ParameterValue=(the name of the SageMaker AI inference endpoint you want to query), \
Description=NeptuneMLEndpoint, \
ApplyMethod=pending-reboot" \
--region (AWS region, such as us-east-1)
```
# Überblick über die Verwendung des Features Neptune ML
Die Neptune ML-Funktion in Amazon Neptune bietet einen optimierten Arbeitsablauf für die Nutzung von Modellen für maschinelles Lernen in einer Graphdatenbank. Der Prozess umfasst mehrere wichtige Schritte: das Exportieren von Daten aus Neptune in das CSV-Format, die Vorverarbeitung der Daten, um sie für das Modelltraining vorzubereiten, das maschinelle Lernmodell mit Amazon SageMaker AI zu trainieren, einen Inferenzendpunkt für Vorhersagen zu erstellen und dann das Modell direkt aus Gremlin-Abfragen abzufragen. Die Neptune Workbench bietet praktische Befehle für Linien- und Zellenmagie, mit denen Sie diese Schritte verwalten und automatisieren können. Durch die direkte Integration von Funktionen für maschinelles Lernen in die Graphdatenbank ermöglicht Neptune ML Benutzern, anhand der umfangreichen relationalen Daten, die im Neptun-Diagramm gespeichert sind, wertvolle Erkenntnisse abzuleiten und Vorhersagen zu treffen.
## Starten des Workflows für die Verwendung von Neptune ML
Die Verwendung des Features Neptune ML in Amazon Neptune umfasst in der Regel zunächst die folgenden fünf Schritte:
![\[Diagramm zum Neptune-ML-Workflow\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/neptune-ML-workflow.png)
1. **Datenexport und Konfiguration** – Beim Datenexport werden mithilfe des Service Neptune-Export oder des `neptune-export`-Befehlszeilen-Tools Daten aus Neptune im CSV-Format in Amazon Simple Storage Service (Amazon S3) exportiert. Gleichzeitig wird automatisch eine Konfigurationsdatei mit dem Namen `training-data-configuration.json` generiert, in der angegeben ist, wie die exportierten Daten in ein trainierbares Diagramm geladen werden können.
1. **Datenvorverarbeitung** – In diesem Schritt wird der exportierte Datensatz mithilfe von Standardverfahren vorverarbeitet, um ihn für das Modelltraining vorzubereiten. Für numerische Daten kann eine Merkmalsnormalisierung durchgeführt und Textmerkmale können mit `word2vec` codiert werden. Am Ende dieses Schritts wird aus dem exportierten Datensatz ein DGL-Diagramm (Deep Graph Library) generiert, das während des Modelltrainings verwendet wird.
Dieser Schritt wird mithilfe eines SageMaker KI-Verarbeitungsauftrags in Ihrem Konto implementiert, und die resultierenden Daten werden an einem von Ihnen angegebenen Amazon S3 S3-Standort gespeichert.
1. **Modelltraining** – Beim Modelltraining wird das Machine-Learning-Modell trainiert, das für Prognosen verwendet wird.
Das Modelltraining erfolgt in zwei Phasen:
+ In der ersten Phase wird mithilfe eines SageMaker KI-Verarbeitungsauftrags ein Konfigurationssatz für die Modelltrainingsstrategie generiert, der festlegt, welcher Modelltyp und welche Modell-Hyperparameterbereiche für das Modelltraining verwendet werden.
+ In der zweiten Phase werden dann mithilfe eines SageMaker KI-Modeltuning-Jobs verschiedene Hyperparameter-Konfigurationen ausprobiert und der Trainingsjob ausgewählt, der das Modell mit der besten Leistung hervorgebracht hat. Der Optimierungsauftrag führt eine vordefinierte Anzahl von Modelloptimierungsaufträgen mit den verarbeiteten Daten durch. Am Ende dieser Phase werden die trainierten Modellparameter des besten Trainingsauftrags verwendet, um Modellartefakte für Inferenzen zu generieren.
1. **Erstellen Sie einen Inferenzendpunkt in Amazon SageMaker AI** — Der Inferenzendpunkt ist eine SageMaker KI-Endpunkt-Instance, die mit den Modellartefakten gestartet wird, die durch den besten Trainingsjob erzeugt wurden. Jedes Modell ist an einen einzelnen Endpunkt gebunden. Der Endpunkt ist in der Lage, eingehende Anfragen von der Graphdatenbank anzunehmen und die Modellvorhersagen für die Eingaben in den Anfragen zurückzugeben. Nach der Erstellung des Endpunkts bleibt dieser aktiv, bis Sie ihn löschen.
1. **Abfragen des Machine-Learning-Modells mithilfe von Gremlin** – Sie können Erweiterungen der Gremlin-Abfragesprache verwenden, um Prognosen vom Inferenzendpunkt abzufragen.
**Anmerkung**
Die [Neptune-Workbench](graph-notebooks.md#graph-notebooks-workbench) enthält ein Line-Magic und ein Zell-Magic, mit denen Sie bei der Verwaltung dieser Schritte viel Zeit sparen können, nämlich:
[%neptune\$1ml](notebooks-magics.md#notebooks-line-magics-neptune_ml)
[%%neptune\$1ml](notebooks-magics.md#notebooks-cell-magics-neptune_ml)
# Erstellen von Prognosen auf der Grundlage sich entwickelnder Graphdaten
Bei einem sich ständig ändernden Graphen möchten Sie möglicherweise regelmäßig neue Stapelprognosen auf der Grundlage aktueller Daten erstellen. Das Abfragen vorab berechneter Prognosen (transduktive Inferenz) kann erheblich schneller sein als die spontane Generierung neuer Prognosen auf der Grundlage der allerneuesten Daten (induktive Inferenz). Beide Ansätze haben ihre Berechtigung, je nachdem, wie schnell sich Ihre Daten ändern und welche Leistungsanforderungen Sie haben.
## Der Unterschied zwischen induktiver und transduktiver Inferenz
Bei der Durchführung transduktiver Inferenz sucht Neptune nach Prognosen, die zum Zeitpunkt des Trainings vorberechnet wurden, und gibt sie zurück.
Bei der Durchführung induktiver Inferenz konstruiert Neptune den entsprechenden Untergraphen und ruft seine Eigenschaften ab. Das DGL-GNN-Modell wendet dann Datenverarbeitung und Modellauswertung in Echtzeit an.
Durch induktive Inferenz können daher Prognosen zu Knoten und Edges generiert werden, die zum Zeitpunkt des Trainings nicht vorhanden waren und die den aktuellen Zustand des Graphen widerspiegeln. Damit geht jedoch eine höhere Latenz einher.
Wenn Ihr Graph dynamisch ist, sollten Sie die induktive Inferenz verwenden, um sicherzugehen, dass die neuesten Daten berücksichtigt werden. Wenn Ihr Graph jedoch statisch ist, ist die transduktive Inferenz schneller und effizienter.
Die induktive Inferenz ist standardmäßig deaktiviert. Sie können sie für eine Abfrage aktivieren, indem Sie das Gremlin-Prädikat [Neptune\$1ml.inductiveInference](machine-learning-gremlin-inference-query-predicates.md#machine-learning-gremlin-inference-neptune-ml-inductiveInference) in der Abfrage wie folgt verwenden:
```
.with( "Neptune#ml.inductiveInference")
```
# Inkrementelle transduktive Workflows
Während Sie Modellartefakte einfach aktualisieren, indem Sie die Schritte eins bis drei (vom **Datenexport und der Konfiguration** bis zur **Modelltransformation**) erneut ausführen, unterstützt Neptune ML einfachere Methoden, um Ihre ML-Stapelprognosen mithilfe neuer Daten zu aktualisieren. Eine Möglichkeit besteht darin, einen [inkrementellen Modell-Workflow](#machine-learning-overview-incremental) zu verwenden, und eine andere darin, das [Modell mit einem Warmstart neu zu trainieren](#machine-learning-overview-model-retraining).
## Workflow mit inkrementellem Modell
Bei diesem Workflow aktualisieren Sie die ML-Prognosen, ohne das ML-Modell erneut zu trainieren.
**Anmerkung**
Dies ist nur möglich, wenn die Grafikdaten mit neuen Knoten und/oder Edges aktualisiert wurden. Es funktioniert derzeit nicht, wenn Knoten entfernt werden.
1. **Datenexport und Konfiguration** – Dieser Schritt ist identisch mit dem im Haupt-Workflow.
1. **Inkrementelle Datenvorverarbeitung** – Dieser Schritt ähnelt dem Schritt der Datenvorverarbeitung im Haupt-Workflow, verwendet jedoch dieselbe Verarbeitungskonfiguration wie zuvor, die einem bestimmten trainierten Modell entspricht.
1. **Modelltransformation** – Anstatt eines Modelltrainingsschritts nimmt dieser Schritt der Modelltransformation das trainierte Modell aus dem Haupt-Workflow und den Ergebnissen des Schritts der inkrementellen Datenvorverarbeitung und generiert neue Modellartefakte, die für Inferenzen verwendet werden können. Im Schritt zur Modelltransformation wird ein SageMaker KI-Verarbeitungsjob gestartet, um die Berechnung durchzuführen, die die aktualisierten Modellartefakte generiert.
1. **Amazon SageMaker AI-Inferenzendpunkt aktualisieren — Wenn Sie über einen vorhandenen Inferenzendpunkt** verfügen, aktualisiert dieser Schritt optional den Endpunkt mit den neuen Modellartefakten, die durch den Modelltransformationsschritt generiert wurden. Alternativ können Sie zudem einen neuen Inferenzendpunkt mit den neuen Modellartefakten erstellen.
## Erneutes Training des Modells mit Warmstart
Mit diesem Workflow können Sie ein neues ML-Modell für die Erstellung von Prognosen anhand der inkrementellen Grafikdaten trainieren und bereitstellen. Sie können jedoch mit einem vorhandenen Modell beginnen, das mit dem Haupt-Workflow generiert wurde:
1. **Datenexport und Konfiguration** – Dieser Schritt ist identisch mit dem im Haupt-Workflow.
1. **Inkrementelle Datenvorverarbeitung** – Dieser Schritt ist identisch mit dem beim inkrementellen Modellinferenz-Workflow. Die neuen Graphdaten sollten mit derselben Verarbeitungsmethode verarbeitet werden, die zuvor für das Modelltraining verwendet wurde.
1. **Modelltraining mit Warmstart** – Das Modelltraining ähnelt dem Training im Haupt-Workflow, Sie können jedoch die Suche nach Modell-Hyperparametern beschleunigen, indem Sie die Informationen aus der vorherigen Modelltrainingsaufgabe nutzen.
1. **Den Amazon SageMaker AI-Inferenzendpunkt aktualisieren** — Dieser Schritt ist derselbe wie beim inkrementellen Model-Inferenz-Workflow.
# Workflows für benutzerdefinierte Modelle in Neptune ML
Mit Neptune ML können Sie eigene benutzerdefinierte Modelle für alle Aufgaben implementieren, trainieren und einsetzen, die Neptune ML unterstützt. Der Workflow für die Entwicklung und Bereitstellung eines benutzerdefinierten Modells ist im Wesentlichen derselbe wie für die integrierten Modelle, mit einigen Unterschieden, wie unter [Workflow für benutzerdefinierte Modelle](machine-learning-custom-model-overview.md#machine-learning-custom-model-workflow) erläutert.
# Auswahl der Instance für die Neptune-ML-Phasen
Die verschiedenen Phasen der Neptune ML-Verarbeitung verwenden unterschiedliche SageMaker KI-Instanzen. Im Folgenden wird beschrieben, wie Sie den richtigen Instance-Typ für die einzelnen Phasen auswählen. Informationen zu SageMaker KI-Instance-Typen und Preisen finden Sie unter [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
## Auswahl einer Instance für die Datenverarbeitung
Für den SageMaker [KI-Datenverarbeitungsschritt](machine-learning-on-graphs-processing.md) ist eine [Verarbeitungsinstanz](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html) erforderlich, die über ausreichend Arbeitsspeicher und Festplattenspeicher für die Eingabe-, Zwischen- und Ausgabedaten verfügt. Die spezifische Menge an Arbeits- und Festplattenspeicher, die benötigt wird, ist von den Eigenschaften des Neptune-ML-Diagramms und dessen exportierten Features abhängig.
Standardmäßig wählt Neptune ML die kleinste `ml.r5`-Instance aus, deren Arbeitsspeicher zehnmal größer als die Größe der exportierten Diagrammdaten auf der Festplatte ist.
## Auswahl einer Instance für Modelltraining und Modelltransformation
Die Auswahl des richtigen Instance-Typs für [Modelltraining](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) oder [Modelltransformation](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-batch.html) ist vom Typ der Aufgabe, der Größe des Diagramms und den Anforderungen an die Bearbeitungszeit abhängig. GPU-Instances stellen die beste Leistung bereit. Wir empfehlen grundsätzlich serielle `p3`- und `g4dn`-Instances. Sie können auch `p2`- oder `p4d`-Instances verwenden.
Standardmäßig wählt Neptune ML die kleinste GPU-Instance aus, deren Arbeitsspeicher größer als von Modelltraining und Modelltransformation benötigt ist. Informationen zu dieser Auswahl finden Sie in der Datei `train_instance_recommendation.json` im Amazon-S3-Datenverarbeitungsausgabeort. Dies ist ein Beispiel für den Inhalt einer `train_instance_recommendation.json`-Datei:
```
{
"instance": "(the recommended instance type for model training and transform)",
"cpu_instance": "(the recommended instance type for base processing instance)",
"disk_size": "(the estimated disk space required)",
"mem_size": "(the estimated memory required)"
}
```
## Auswahl einer Instance für einen Inferenzendpunkt
Die Auswahl des richtigen Instance-Typs für einen [Inferenzendpunkt](machine-learning-on-graphs-inference-endpoint.md) ist vom Typ der Aufgabe, der Größe des Diagramms und dem Budget abhängig. Standardmäßig wählt Neptune ML die kleinste `ml.m5d`-Instance aus, deren Arbeitsspeicher größer als vom Inferenzendpunkt benötigt ist.
**Anmerkung**
Wenn mehr als 384 GB Arbeitsspeicher benötigt werden, verwendet Neptune ML eine `ml.r5d.24xlarge`-Instance.
Informationen zum von Neptune ML empfohlenen Instance-Typ finden Sie in der Datei `infer_instance_recommendation.json` am Amazon-S3-Ort, den Sie zum Modelltraining verwenden. Dies ist ein Beispiel für den Inhalt dieser Datei:
```
{
"instance" : "(the recommended instance type for an inference endpoint)",
"disk_size" : "(the estimated disk space required)",
"mem_size" : "(the estimated memory required)"
}
```
# Verwenden des Neptune-Export-Tools oder des Neptune-Export-Service zum Exportieren von Daten aus Neptune für Neptune ML
Neptune ML erfordert, dass Sie Trainingsdaten für die [Deep Graph Library (DGL)](https://www.dgl.ai/) bereitstellen, um Modelle zu erstellen und auszuwerten.
Sie können mit dem [Neptune-Export-Service](export-service.md) oder mit dem [`neptune-export`-Hilfsprogramm](export-utility.md) Daten aus Neptune exportieren. Sowohl der Service als auch das Befehlszeilentool veröffentlichen Daten zu Amazon Simple Storage Service (Amazon S3) im CSV-Format, die mit serverseitiger Amazon-S3-Verschlüsselung (`SSE-S3`) verschlüsselt sind. Siehe [Von Neptune-Export exportierte Dateien und `neptune-export`](exported-files.md).
Wenn Sie einen Export von Trainingsdaten für Neptune ML konfigurieren, erstellt und veröffentlicht der Exportauftrag eine verschlüsselte Modelltrainings-Konfigurationsdatei zusammen mit den exportierten Daten. Diese Datei hat standardmäßig den Namen `training-data-configuration.json`.
# Beispiele für die Verwendung des Neptune-Export-Service zum Exportieren von Trainingsdaten für Neptune ML
Diese Anforderung exportiert Eigenschaftsdiagramm-Trainingsdaten für eine Aufgabe zur Knotenklassifizierung:
```
curl \
(your NeptuneExportApiUri) \
-X POST \
-H 'Content-Type: application/json' \
-d '{
"command": "export-pg",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "genre",
"type": "classification"
}
]
}
}
}'
```
Diese Anforderung exportiert RDF-Trainingsdaten für eine Aufgabe zur Knotenklassifizierung:
```
curl \
(your NeptuneExportApiUri) \
-X POST \
-H 'Content-Type: application/json' \
-d '{
"command": "export-rdf",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre",
"type": "classification"
}
]
}
}
}'
```
# Felder, die beim Exportieren von Trainingsdaten im params-Objekt festgelegt werden sollen
Das `params`-Objekt in einer Exportanforderung kann verschiedene Felder enthalten, wie in der [`params`-Dokumentation](export-params-fields.md) beschrieben. Die folgenden Felder sind für den Export von Machine-Learning-Trainingsdaten am relevantesten:
****
+ **`endpoint`** – Verwenden Sie `endpoint`, um den Endpunkt einer Neptune-Instance in Ihrem DB-Cluster anzugeben, den der Exportvorgang abfragen kann, um Daten zu extrahieren.
+ **`profile`** – Das Feld `profile` im `params`-Objekt muss auf **`neptune-ml`** festgelegt sein.
Dadurch formatiert der Exportvorgang die exportierten Daten für das Neptune-ML-Modelltraining im CSV-Format für Eigenschaftsdiagrammdaten oder als N-Tripel für RDF-Daten. Außerdem wird die Datei `training-data-configuration.json` erstellt und zum selben Amazon-S3-Speicherort geschrieben wie die exportierten Trainingsdaten.
+ **`cloneCluster`** – Wenn diese Option auf `true` festgelegt ist, klont der Exportvorgang den DB-Cluster, exportiert Daten aus dem Klon und löscht den Klon, wenn der Vorgang abgeschlossen ist.
+ **`useIamAuth`** – Wenn für den DB-Cluster die [IAM-Authentifizierung](iam-auth-enable.md) aktiviert ist, müssen Sie dieses Feld auf `true` festlegen.
Der Exportvorgang bietet auch mehrere Möglichkeiten für das Filtern der exportierten Daten (siehe [diese Beispiele](export-filtering-examples.md)).
# Verwenden Sie das AdditionalParams-Objekt, um den Export von Modelltrainingsinformationen zu optimieren
Das `additionalParams`-Objekt enthält Felder, mit denen Sie Machine-Learning-Klassenbezeichnungen und -Features zu Trainingszwecken angeben und die Erstellung einer Trainingsdaten-Konfigurationsdatei steuern können.
Der Exportvorgang kann nicht automatisch ableiten, welche Knoten- und Kanteneigenschaften als Beispiele für Machine-Learning-Klassenbezeichnungen zu Trainingszwecken dienen sollen. Außerdem kann er nicht automatisch die beste Feature-Kodierung für numerische, kategorische und Texteigenschaften ableiten. Daher müssen Sie in den Feldern des `additionalParams`-Objekts Hinweise bereitstellen, um dies anzugeben oder die Standardkodierung zu überschreiben.
Für Eigenschaftsdiagrammdaten könnte die Struktur der obersten Ebene von `additionalParams` in einer Exportanforderung wie folgt aussehen:
```
{
"command": "export-pg",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [ (an array of node and edge class label targets) ],
"features": [ (an array of node feature hints) ]
}
}
}
```
Für RDF-Daten könnte die Struktur der obersten Ebene wie folgt aussehen:
```
{
"command": "export-rdf",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [ (an array of node and edge class label targets) ]
}
}
}
```
Sie können im Feld `jobs` auch mehrere Exportkonfigurationen angeben:
```
{
"command": "export-pg",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams" : {
"neptune_ml" : {
"version": "v2.0",
"jobs": [
{
"name" : "(training data configuration name)",
"targets": [ (an array of node and edge class label targets) ],
"features": [ (an array of node feature hints) ]
},
{
"name" : "(another training data configuration name)",
"targets": [ (an array of node and edge class label targets) ],
"features": [ (an array of node feature hints) ]
}
]
}
}
}
```
# Elemente der obersten Ebene im Feld neptune\$1ml in AdditionalParams
## Das Versionselement in neptune\$1ml
Gibt die Version der Trainingsdatenkonfiguration an, die generiert werden soll.
(*Optional*), *Typ*: string, *Standard*: v2.0.
Wenn Sie `version` einfügen, legen Sie dies auf `v2.0` fest.
## Das Job-Feld in neptune\$1ml
Enthält eine Reihe von Trainingsdaten-Konfigurationsobjekten, von denen jedes einen Datenverarbeitungsauftrag definiert, und enthält:
+ **`name`** – Der Name der Trainingsdatenkonfiguration, die erstellt werden soll.
Beispielsweise ergibt eine Trainingsdatenkonfiguration mit dem Namen „"job-number-1“ eine Trainingsdaten-Konfigurationsdatei mit dem Namen `job-number-1.json`.
+ **`targets`** – Ein JSON-Array mit Knoten- und Kanten-Klassenbezeichnungszielen, die die Machine-Learning-Klassenbezeichnungen für Trainingszwecke darstellen. Siehe [Das Zielfeld in einem neptune\$1ml-Objekt](machine-learning-neptune_ml-targets.md).
+ **`features`** – Ein JSON-Array mit Knoteneigenschaft-Features. Siehe [Das Feature-Feld in neptune\$1ml](machine-learning-neptune_ml-features.md).
# Das Zielfeld in einem neptune\$1ml-Objekt
Das Feld `targets` in einer Exportkonfiguration für JSON-Trainingsdaten enthält mehrere Zielobjekte, die eine Trainingsaufgabe spezifizieren, sowie die Machine-Learning-Klassenbezeichnungen zum Trainieren dieser Aufgabe. Der Inhalt der Zielobjekte ist davon abhängig, ob Sie mit Eigenschaftsdiagrammdaten oder RDF-Daten trainieren.
Für Aufgaben zur Klassifizierung und Regression von Eigenschaftsdiagramm-Knoten können die Zielobjekte im Array wie folgt aussehen:
```
{
"node": "(node property-graph label)",
"property": "(property name)",
"type" : "(used to specify classification or regression)",
"split_rate": [0.8,0.2,0.0],
"separator": ","
}
```
Für Aufgaben zur Klassifizierung, Regression oder Linkvorhersage von Eigenschaftsdiagramm-Kanten können sie wie folgt aussehen:
```
{
"edge": "(edge property-graph label)",
"property": "(property name)",
"type" : "(used to specify classification, regression or link_prediction)",
"split_rate": [0.8,0.2,0.0],
"separator": ","
}
```
Für Aufgaben zur RDF-Klassifizierung und -Regression können die Zielobjekte im Array wie folgt aussehen:
```
{
"node": "(node type of an RDF node)",
"predicate": "(predicate IRI)",
"type" : "(used to specify classification or regression)",
"split_rate": [0.8,0.2,0.0]
}
```
Für Aufgaben zur RDF-Linkvorhersage können Zielobjekte im Array wie folgt aussehen:
```
{
"subject": "(source node type of an edge)",
"predicate": "(relation type of an edge)",
"object": "(destination node type of an edge)",
"type" : "link_prediction",
"split_rate": [0.8,0.2,0.0]
}
```
Zielobjekte können die folgenden Felder enthalten:
**Contents**
+ [Felder in Eigenschaftsdiagrammzielen](#machine-learning-property-graph-neptune_ml-targets)
+ [node](#machine-learning-property-graph-neptune_ml-targets-node)
+ [edge](#machine-learning-property-graph-neptune_ml-targets-edge)
+ [property](#machine-learning-property-graph-neptune_ml-targets-property)
+ [type](#machine-learning-property-graph-neptune_ml-targets-type)
+ [split\$1rate](#machine-learning-property-graph-neptune_ml-targets-split_rate)
+ [separator](#machine-learning-property-graph-neptune_ml-targets-separator)
+ [RDF-Zielfelder](#machine-learning-RDF-neptune_ml-targets)
+ [node](#machine-learning-RDF-neptune_ml-targets-node)
+ [subject](#machine-learning-RDF-neptune_ml-targets-subject)
+ [predicate](#machine-learning-RDF-neptune_ml-targets-predicate)
+ [object](#machine-learning-RDF-neptune_ml-targets-object)
+ [type](#machine-learning-RDF-neptune_ml-targets-type)
+ [split\$1rate](#machine-learning-RDF-neptune_ml-targets-split_rate)
## Felder in einem Eigenschaftsdiagramm-Zielobjekt
### Das Knotenfeld (Vertex) in einem Zielobjekt
Die Eigenschaftsdiagramm-Bezeichnung eines Zielknotens (Eckpunkt). Ein Zielobjekt muss ein `node`-Element oder ein `edge`-Element enthalten, darf aber nicht beide Elemente enthalten.
A `node` kann einen einzelnen Wert annehmen, z. B.:
```
"node": "Movie"
```
Im Fall eines Eckpunkts mit mehreren Bezeichnungen kann er mehrere Werte annehmen, z. B.:
```
"node": ["Content", "Movie"]
```
### Das Kantenfeld in einem Eigenschaftsgraph-Zielobjekt
Gibt eine Zielkante anhand der Startknotenbezeichnung(en), der eigenen Bezeichnung und der Endknotenbezeichnung(en) an. Ein Zielobjekt muss ein `edge`-Element oder ein `node`-Element enthalten, darf aber nicht beide Elemente enthalten.
Der Wert eines `edge`-Felds ist ein JSON-Array mit drei Zeichenfolgen, die die Eigenschaftsgraphenbezeichnungen des Startknotens, die Eigenschaftsgraphenbezeichnung der Kante selbst und die Eigenschaftsgraphenbeschriftung(en) des Endknotens darstellen, z. B.:
```
"edge": ["Person_A", "knows", "Person_B"]
```
Wenn der Startknoten und der and/or Endknoten mehrere Beschriftungen hat, schließen Sie sie in ein Array ein, etwa so:
```
"edge": [ ["Admin", Person_A"], "knows", ["Admin", "Person_B"] ]
```
### Das Eigenschaftsfeld in einem Eigenschaftsgraph-Zielobjekt
Gibt eine Eigenschaft des Zieleckpunkts oder der Zielkante wie folgt an:
```
"property" : "rating"
```
Dieses Feld ist erforderlich, es sei denn, es handelt sich bei der Zielaufgabe um eine Linkvorhersage.
### Das Typfeld in einem Eigenschaftsdiagramm-Zielobjekt
Gibt den Typ der Zielaufgabe an, die für `node` oder `edge` ausgeführt werden soll, z. B.:
```
"type" : "regression"
```
Die unterstützten Aufgabentypen für Knoten sind:
+ `classification`
+ `regression`
Die unterstützten Aufgabentypen für Kanten sind:
+ `classification`
+ `regression`
+ `link_prediction`
Dies ist ein Pflichtfeld.
### Das Split\$1Rate-Feld in einem Property-Graph-Zielobjekt
(*Optional*) Eine Schätzung des Anteils der Knoten oder Kanten, die in der Trainings-, Validierungs- und Testphase jeweils verwendet werden. Diese Anteile werden durch ein JSON-Array mit drei Zahlen zwischen null und eins dargestellt, die zusammen eins ergeben:
```
"split_rate": [0.7, 0.1, 0.2]
```
Wenn Sie das optionale `split_rate` Feld nicht angeben, gilt der geschätzte Standardwert `[0.9, 0.1, 0.0]` für Klassifizierungs- und Regressionsaufgaben sowie `[0.9,0.05, 0.05]` für Aufgaben zur Linkvorhersage.
### Das Trennfeld in einem Zielobjekt mit einem Eigenschaftsdiagramm
(*Optional*) Wird zusammen mit einer Klassifizierungsaufgabe verwendet.
Das Feld `separator` gibt ein Zeichen an, das zum Aufteilen eines Zieleigenschaftswerts in mehrere kategoriale Werte verwendet wird, wenn es zum Speichern mehrerer Kategoriewerte in einer Zeichenfolge verwendet wird. Beispiel:
```
"separator": "|"
```
Das Vorhandensein des Felds `separator` weist darauf hin, dass es sich bei der Aufgabe um eine Klassifizierungsaufgabe mit mehreren Zielen handelt.
## Felder in einem RDF-Zielobjekt
### Das Knotenfeld in einem RDF-Zielobjekt
Definiert den Knotentyp der Zielknoten. Wird bei Aufgaben zur Klassifizierung oder Regression von Knoten verwendet. Der Knotentyp eines Knotens in RDF wird wie folgt definiert:
```
node_id, , node_type
```
Ein `node`-Knoten kann nur einen Wert annehmen, z. B.:
```
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie"
```
### Das Betreff-Feld in einem RDF-Zielobjekt
Bei Linkvorhersageaufgaben definiert `subject` den Quellknotentyp von Zielkanten.
```
"subject": "http://aws.amazon.com/neptune/csv2rdf/class/Director"
```
**Anmerkung**
Bei Linkvorhersageaufgaben sollte `subject` zusammen mit `predicate` und `object` verwendet werden. Wenn keiner dieser drei Werte angegeben ist, werden alle Kanten als Trainingsziel behandelt.
### Das Prädikatfeld in einem RDF-Zielobjekt
Bei Aufgaben zur Klassifizierung und Regression von Knoten definiert `predicate` die Literaldaten, die als Zielknoten-Feature eines Zielknotens verwendet werden.
```
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre"
```
**Anmerkung**
Wenn die Zielknoten nur ein Prädikat besitzen, das das Zielknoten-Feature definiert, kann das Feld `predicate` übersprungen werden.
Bei Linkvorhersageaufgaben definiert `predicate` den Beziehungstyp von Zielkanten.
```
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/direct"
```
**Anmerkung**
Bei Linkvorhersageaufgaben sollte `predicate` zusammen mit `subject` und `object` verwendet werden. Wenn keiner dieser drei Werte angegeben ist, werden alle Kanten als Trainingsziel behandelt.
### Das Objektfeld in einem RDF-Zielobjekt
Bei Linkvorhersageaufgaben definiert `object` den Zielknotentyp von Zielkanten:
```
"object": "http://aws.amazon.com/neptune/csv2rdf/class/Movie"
```
**Anmerkung**
Bei Linkvorhersageaufgaben sollte `object` zusammen mit `subject` und `predicate` verwendet werden. Wenn keiner dieser drei Werte angegeben ist, werden alle Kanten als Trainingsziel behandelt.
### Das Typfeld in einem RDF-Zielobjekt
Gibt den Typ der Zielaufgabe an, die ausgeführt werden soll, z. B.:
```
"type" : "regression"
```
Die unterstützten Aufgabentypen für RDF-Daten sind:
+ `link_prediction`
+ `classification`
+ `regression`
Dies ist ein Pflichtfeld.
### Das Feld `split_rate` in einem Eigenschaftsdiagramm-Zielobjekt
(*Optional*) Eine Schätzung des Anteils der Knoten oder Kanten, die in der Trainings-, Validierungs- und Testphase jeweils verwendet werden. Diese Anteile werden durch ein JSON-Array mit drei Zahlen zwischen null und eins dargestellt, die zusammen eins ergeben:
```
"split_rate": [0.7, 0.1, 0.2]
```
Wenn Sie keinen Wert für das optionale `split_rate`-Feld angeben, ist der geschätzte Standardwert `[0.9, 0.1, 0.0]`.
# Das Feature-Feld in neptune\$1ml
Eigenschaftswerte und RDF-Literale haben verschiedene Formate und Datentypen. Um eine gute Machine-Learning-Leistung zu erzielen, müssen diese Werte in numerische Kodierungen konvertiert werden, so genannte *features*.
Neptune ML extrahiert und kodiert Features als Teil der Schritte für Datenexport und Datenverarbeitung durch, wie in [Feature-Kodierung in Neptune ML](machine-learning-feature-encoding.md) beschrieben.
Für Eigenschaftsdiagramm-Datensätze inferiert der Exportvorgang automatisch `auto`-Features für Zeichenfolgeneigenschaften und numerische Eigenschaften, die mehrere Werte enthalten. Für numerische Eigenschaften, die Einzelwerte enthalten, werden `numerical`-Features inferiert. Für Datumseigenschaften werden `datetime`-Features inferiert.
Wenn Sie eine automatisch abgeleitete Feature-Spezifikation überschreiben oder eine numerische Bucket-, TF-IDF- oder SBERT-Spezifikation für eine Eigenschaft hinzufügen möchten FastText, können Sie die Feature-Codierung mithilfe des Features-Felds steuern.
**Anmerkung**
Sie können das Feld `features` nur verwenden, um die Feature-Spezifikationen für Eigenschaftsdiagrammdaten zu steuern, nicht für RDF-Daten.
Für Freiformtext kann Neptune ML mehrere verschiedene Modelle verwenden, um die Sequenz von Token in einem Zeichenfolgen-Eigenschaftswert in einen Realwertvektor fester Größe zu konvertieren:
+ [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features) – Verwendet [fastText](https://fasttext.cc/)-Kodierung. Dies ist die empfohlene Kodierung für Features, die eine und nur eine der fünf Sprachen verwenden, die fastText unterstützt.
+ [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-sbert-features) – Verwendet die Kodierungsmodelle [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Dies ist die empfohlene Kodierung für Text, den `text_fasttext` nicht unterstützt.
+ [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features) – Verwendet [Word2Vec](https://wikipedia.org/wiki/Word2vec)-Algorithmen (ursprünglich von [Google](https://code.google.com/archive/p/word2vec/) veröffentlicht), um Text zu kodieren. Word2Vec unterstützt nur Englisch.
+ [`text_tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features) – Verwendet den Vektorisierer [term frequency–inverse document frequency](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) für die Textkodierung. Die TF-IDF-Kodierung unterstützt statistische Features, die von den anderen Kodierungen nicht unterstützt werden.
Das Feld `features` enthält ein JSON-Array mit Knoteneigenschaft-Features. Objekte im Array können die folgenden Felder enthalten:
**Contents**
+ [node](#machine-learning-neptune_ml-features-node)
+ [edge](#machine-learning-neptune_ml-features-edge)
+ [property](#machine-learning-neptune_ml-features-property)
+ [type](#machine-learning-neptune_ml-feature-types)
+ [norm](#machine-learning-neptune_ml-features-norm)
+ [language](#machine-learning-neptune_ml-features-language)
+ [max\$1length](#machine-learning-neptune_ml-features-max_length)
+ [separator](#machine-learning-neptune_ml-features-separator)
+ [range](#machine-learning-neptune_ml-features-range)
+ [bucket\$1cnt](#machine-learning-neptune_ml-features-bucket_cnt)
+ [slide\$1window\$1size](#machine-learning-neptune_ml-features-slide_window_size)
+ [imputer](#machine-learning-neptune_ml-features-imputer)
+ [max\$1features](#machine-learning-neptune_ml-features-max_features)
+ [min\$1df](#machine-learning-neptune_ml-features-min_df)
+ [ngram\$1range](#machine-learning-neptune_ml-features-ngram_range)
+ [datetime\$1parts](#machine-learning-neptune_ml-features-datetime_parts)
## Das Knotenfeld in Features
Das Feld `node` gibt die Eigenschaftsdiagramm-Bezeichnung eines Feature-Eckpunkts an. Beispiel:
```
"node": "Person"
```
Wenn ein Eckpunkt mehrere Bezeichnungen hat, verwenden Sie ein Array, um sie aufzunehmen. Beispiel:
```
"node": ["Admin", "Person"]
```
## Das Kantenfeld in Features
Das Feld `edge` gibt den Kantentyp einer Feature-Kante an. Ein Kantentyp besteht aus einem Array, das die Eigenschaftsdiagramm-Bezeichnung(en) des Quelleckpunkts, der Kante und des Zieleckpunkts enthält. Sie müssen alle drei Werte angeben, wenn Sie ein Kanten-Feature angeben. Beispiel:
```
"edge": ["User", "reviewed", "Movie"]
```
Wenn ein Quell- oder Zieleckpunkt eines Kantentyps mehrere Bezeichnungen hat, verwenden Sie ein weiteres Array. Beispiel:
```
"edge": [["Admin", "Person"]. "edited", "Post"]
```
## Das Eigenschaftsfeld in Features
Mit dem Eigenschaftsparameter können Sie eine Eigenschaft des Eckpunkts angeben, der vom Parameter `node` identifiziert wird. Beispiel:
```
"property" : "age"
```
## Mögliche Werte des Typfeldes für Features
Der Parameter `type` gibt den Typ des Features an, das definiert wird. Beispiel:
```
"type": "bucket_numerical"
```
**Mögliche Werte des Parameters `type`**
+ **`"auto"`** – Gibt an, dass Neptune ML den Eigenschaftstyp automatisch erkennen und die korrekte Feature-Kodierung anwenden soll. Ein `auto`-Feature kann auch das optionale Feld `separator` besitzen.
Siehe [Auto-Feature-Kodierung in Neptune ML](machine-learning-feature-encoding.md#machine-learning-auto-encoding).
+ **`"category"`** – Diese Feature-Kodierung stellt einen Eigenschaftswert als eine von mehreren Kategorien dar. Mit anderen Worten, das Feature kann einen oder mehrere diskrete Werte annehmen. Ein `category`-Feature kann auch das optionale Feld `separator` besitzen.
Siehe [Kategorische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-categorical-features).
+ **`"numerical"`** – Diese Feature-Kodierung stellt numerische Eigenschaftswerte als Zahlen in einem kontinuierlichen Intervall dar, wobei „größer als“ und „kleiner als“ eine Bedeutung haben.
Ein `numerical`-Feature kann auch die optionalen Felder `norm`, `imputer` und `separator` besitzen.
Siehe [Numerische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features).
+ **`"bucket_numerical"`** – Diese Feature-Kodierung unterteilt numerische Eigenschaftswerte in eine Reihe von *Buckets* oder Kategorien.
Sie könnten beispielsweise das Alter von Personen in 4 Buckets unterteilen: Kinder (0–20), junge Erwachsene (20–40), Personen mittleren Alters (40–60) und ältere Menschen (60 und älter).
Ein `bucket_numerical` Feature erfordert ein `range` `bucket_cnt` Feld und kann optional auch ein `imputer` and/or `slide_window_size` Feld enthalten.
Siehe [Bucket-numerische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
+ **`"datetime"`** – Diese Feature-Kodierung stellt den datetime-Eigenschaftswert als Array dieser Kategorie-Features dar: Jahr, Monat, Wochentag und Stunde.
Eine oder mehrere dieser vier Kategorien können mithilfe des Parameters `datetime_parts` eliminiert werden.
Siehe [Datetime-Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-datetime-features).
+ **`"text_fasttext"`** – Diese Feature-Kodierung konvertiert Eigenschaftswerte, die aus Sätzen oder Freiformtext bestehen, mithilfe von [fastText](https://fasttext.cc/)-Modellen in numerische Vektoren. Sie unterstützt fünf Sprachen, nämlich Englisch (`en`), Chinesisch (`zh`), Hindi (`hi`), Spanisch (`es`) und Französisch (`fr`). Für Texteigenschaftswerte in einer dieser fünf Sprachen wird die Kodierung `text_fasttext` empfohlen. Sie kann jedoch nicht für Fälle verwendet werden, in denen derselbe Satz Wörter in mehr als einer Sprache enthält.
Für Sprachen, die nicht von fastText unterstützt werden, verwenden Sie die `text_sbert`-Kodierung.
Wenn es zahlreiche Eigenschaftswert-Textzeichenfolgen mit mehr als beispielsweise 120 Token gibt, verwenden Sie das Feld `max_length`, um die Anzahl der Token in jeder von `"text_fasttext"` kodierten Zeichenfolge zu begrenzen.
Siehe [*fastText*-Kodierung von Texteigenschaftswerten in Neptune ML](machine-learning-feature-encoding.md#machine-learning-fasttext-features).
+ **`"text_sbert"`** – Diese Kodierung konvertiert Texteigenschaftswerte mithilfe von [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT)-Modellen in numerische Vektoren. Neptune unterstützt zwei SBERT-Methoden: `text_sbert128` (die Standardmethode, wenn Sie nur `text_sbert` angeben) und `text_sbert512`. Der Unterschied zwischen ihnen besteht in der maximalen Anzahl von Token in einer Texteigenschaft, die kodiert wird. Die `text_sbert128`-Kodierung kodiert nur die ersten 128 Token, während `text_sbert512` bis zu 512 Token kodiert. Daher kann die Verwendung von `text_sbert512` mehr Verarbeitungszeit als `text_sbert128` in Anspruch nehmen. Beide Methoden sind langsamer als `text_fasttext`.
Die `text_sbert*`-Methoden unterstützen zahlreiche Sprachen und können einen Satz kodieren, der mehr als eine Sprache enthält.
Siehe [Sentence BERT (SBERT)-Satzkodierung von Text-Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-sbert-features).
+ **`"text_word2vec"`** – Diese Kodierung konvertiert Texteigenschaftswerte mithilfe von [Word2Vec](https://wikipedia.org/wiki/Word2vec)-Algorithmen in numerische Vektoren. Sie unterstützt nur Englisch.
Siehe [Word2Vec-Kodierung von Text-Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-word2vec-features).
+ **`"text_tfidf"`** – Bei dieser Kodierung werden Texteigenschaftswerte mithilfe des Vektorisierers [term frequency–inverse document frequency](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) in numerische Vektoren konvertiert.
Sie definieren die Parameter einer `text_tfidf`-Feature-Kodierung mithilfe der Felder `ngram_range`, `min_df` und `max_features`.
Siehe [TF-IDF-Kodierung von Text-Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
+ **`"none"`** – Die Verwendung des Typs `none` führt dazu, dass keine Feature-Kodierung erfolgt. Stattdessen werden die rohen Eigenschaftswerte geparst und gespeichert.
Verwenden Sie `none` nur, wenn Sie Ihre eigene benutzerdefinierte Feature-Kodierung als Teil eines benutzerdefinierten Modelltrainings ausführen möchten.
## Das Normfeld
Dies ist ein Pflichtfeld für numerische Features. Es gibt eine Normalisierungsmethode für numerische Werte an:
```
"norm": "min-max"
```
Die folgenden Normalisierungsmethoden werden unterstützt:
+ **"min-max"** – Normalisiert jeden Wert, indem der Mindestwert subtrahiert wird und der Wert dann durch die Differenz zwischen Maximalwert und Mindestwert dividiert wird.
+ **"standard"** – Normalisiert jeden Wert, indem er durch die Summe aller Werte dividiert wird.
+ **"none"** – Normalisiert die numerischen Werte während der Kodierung nicht.
Siehe [Numerische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features).
## Das Sprachfeld
Das Feld für die Sprache gibt die Sprache an, die in Texteigenschaftswerten verwendet wird. Die Nutzung ist von der Textkodierungsmethode abhängig:
+ Dieses Feld ist für die [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)-Kodierung erforderlich und es muss eine der folgenden Sprachen angegeben werden:
+ `en` (Englisch)
+ `zh` (Chinesisch)
+ `hi` (Hindi)
+ `es` (Spanisch)
+ `fr` (Französisch)
+ Dieses Feld wird für die [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)-Kodierung nicht verwendet, da die SBERT-Kodierung mehrsprachig ist.
+ Dieses Feld ist für die [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features)-Kodierung optional, da `text_word2vec` nur Englisch unterstützt. Wenn vorhanden, muss der Name des englischsprachigen Modells angegeben werden:
```
"language" : "en_core_web_lg"
```
+ Dieses Feld wird für die [`text_tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features)-Kodierung nicht verwendet.
## Das Feld max\$1length
Das Feld `max_length` ist optional für `text_fasttext`-Features, wo es die maximale Anzahl von Token in einem Eingabe-Text-Feature angibt, die kodiert werden. Eingabetext, der länger als `max_length` ist, wird abgeschnitten. Wenn Sie beispielsweise max\$1length auf 128 festlegen, werden alle Token in einer Textsequenz nach dem 128. Zeichen ignoriert:
```
"max_length": 128
```
## Das Trennfeld
Dieses Feld wird optional mit den Features `category`, `numerical` und `auto` verwendet. Es gibt ein Zeichen an, das für die Unterteilung eines Eigenschaftswerts in mehrere kategorische oder numerische Werte verwendet werden kann:
```
"separator": ";"
```
Verwenden Sie das Feld `separator` nur, wenn die Eigenschaft mehrere durch Trennzeichen getrennte Werte in einer einzigen Zeichenfolge speichert, z. B. `"Actor;Director"` oder `"0.1;0.2"`.
Siehe [Kategorische Features](machine-learning-feature-encoding.md#machine-learning-categorical-features), [Numerische Features](machine-learning-feature-encoding.md#machine-learning-numerical-features) und [Auto-Verschlüsselung](machine-learning-feature-encoding.md#machine-learning-auto-encoding).
## Das Bereichsfeld
Dies ist ein Pflichtfeld für `bucket_numerical`-Features. Es gibt den Bereich der numerischen Werte an, die in Buckets unterteilt werden sollen, und zwar im folgenden Format `[lower-bound, upper-bound]`:
```
"range" : [20, 100]
```
Wenn ein Eigenschaftswert kleiner als der untere Grenzwert ist, wird er dem ersten Bucket zugewiesen. Wenn er größer als der obere Grenzwert ist, wird er dem letzten Bucket zugewiesen.
Siehe [Bucket-numerische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Das Feld bucket\$1cnt
Dies ist ein Pflichtfeld für `bucket_numerical`-Features. Es gibt die Anzahl der Buckets an, in die der numerische Bereich unterteilt werden soll, der durch den Parameter `range` definiert wird:
```
"bucket_cnt": 10
```
Siehe [Bucket-numerische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Das Feld slide\$1window\$1size
Dieses Feld wird optional mit `bucket_numerical`-Features verwendet, um mehr als einem Bucket Werte zuzuweisen:
```
"slide_window_size": 5
```
Ein Gleitfenster funktioniert, indem Neptune ML die Fenstergröße **`s`** übernimmt und jeden numerischen Wert **`v`** einer Eigenschaft in einen Bereich von ` v - s/2 ` bis ` v + s/2 ` transformiert. Der Wert wird dann jedem Bucket zugewiesen, in dem sich der Bereich überschneidet.
Siehe [Bucket-numerische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Das Imputer-Feld
Dieses Feld wird optional mit `numerical`- und `bucket_numerical`-Features verwendet, um eine Imputationstechnik zum Ausfüllen fehlender Werte bereitzustellen:
```
"imputer": "mean"
```
Die folgenden Imputationstechniken werden unterstützt:
+ `"mean"`
+ `"median"`
+ `"most-frequent"`
Wenn Sie diesen Parameter nicht angeben, wird die Datenvorverarbeitung angehalten und beendet, wenn ein fehlender Wert gefunden wird.
Siehe [Numerische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features) und [Bucket-numerische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Das Feld max\$1features
Dieses Feld wird optional von `text_tfidf`-Features verwendet, um die maximale Anzahl der Begriffe anzugeben, die kodiert werden sollen:
```
"max_features": 100
```
Die Einstellung 100 bewirkt, dass der TF-IDF-Vektorizer nur die 100 häufigsten Begriffe kodiert. Wenn Sie `max_features` nicht angeben, ist der Standardwert 5 000.
Siehe [TF-IDF-Kodierung von Text-Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## Das Feld min\$1df
Dieses Feld wird optional von `text_tfidf`-Features verwendet, um die Mindesthäufigkeit von Begriffen anzugeben, die kodiert werden sollen:
```
"min_df": 5
```
Die Einstellung 5 bewirkt, dass ein Begriff in mindestens 5 verschiedenen Eigenschaftswerten vorkommen muss, um kodiert zu werden.
Wenn Sie den Parameter `min_df` nicht angeben, ist der Standardwert `2`.
Siehe [TF-IDF-Kodierung von Text-Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## Das Feld ngram\$1range
Dieses Feld wird optional von `text_tfidf`-Features verwendet, um die Größe anzugeben, die Wortsequenzen oder Token haben sollten, um als potenzielle einzelne Begriffe kodiert zu werden.
```
"ngram_range": [2, 4]
```
Der Wert `[2, 4]` gibt an, dass Sequenzen von 2, 3 und 4 Wörtern als potenzielle einzelne Begriffe betrachtet werden sollen.
Wenn Sie `ngram_range` nicht explizit angeben, ist der Standardwert `[1, 1]`. Das bedeutet, dass nur einzelne Wörter oder Token kodiert werden.
Siehe [TF-IDF-Kodierung von Text-Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## Das Feld datetime\$1parts
Dieses Feld wird optional von `datetime`-Features verwendet, um anzugeben, welche Teile des datetime-Werts kategorisch kodiert werden sollen:
```
"datetime_parts": ["weekday", "hour"]
```
Wenn Sie `datetime_parts` nicht angeben, kodiert Neptune ML standardmäßig die Teile für Jahr, Monat, Wochentag und Stunden des datetime-Werts. Der Wert `["weekday", "hour"]` gibt an, dass nur die datetime-Werte für Wochentag und Stunde kategorisch im Feature kodiert werden sollen.
Wenn ein Teil nicht mehr als einen eindeutigen Wert im Trainingssatz hat, wird er nicht kodiert.
Siehe [Datetime-Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-datetime-features).
# Beispiele für die Verwendung von Parametern in additionalParams zur Optimierung der Modelltrainingskonfiguration
Die folgenden Beispiele zeigen, wie die Funktion „AdditionalParams“ in Property-Graph- und RDF-Datenmodellen verwendet werden kann, um verschiedene Aspekte des Modelltrainingsprozesses für eine Neptune ML-Anwendung zu konfigurieren. Die Beispiele decken ein breites Funktionsspektrum ab, darunter die Angabe von Standard-Split-Raten für training/validation/test Daten, die Definition von Aufgaben zur Knotenklassifizierung, Regression und Verbindungsvorhersage sowie die Konfiguration verschiedener Feature-Typen wie numerische Buckets, Texteinbettungen, Datetime und kategoriale Daten. Diese detaillierten Konfigurationen ermöglichen es Ihnen, die Machine-Learning-Pipeline an Ihre spezifischen Daten- und Modellierungsanforderungen anzupassen und so das volle Potenzial der Neptune ML-Funktionen auszuschöpfen.
**Contents**
+ [
## Beispiele für Eigenschaftsdiagramme mit AdditionalParams
](#machine-learning-property-graph-additionalParams-examples)
+ [
### Angabe einer Standard-Aufteilungsrate für die Modelltrainingskonfiguration
](#machine-learning-property-graph-additionalParams-default-split-rate-example)
+ [
### Angabe einer Knotenklassifizierungsaufgabe für die Modelltrainingskonfiguration
](#machine-learning-property-graph-additionalParams-node-classification-example)
+ [
### Angabe einer Klassifizierungsaufgabe für Knoten mit mehreren Klassen für die Modelltrainingskonfiguration
](#machine-learning-property-graph-additionalParams-multi-class-example)
+ [
### Angabe einer Knotenregressionsaufgabe für die Modelltrainingskonfiguration
](#machine-learning-property-graph-additionalParams-node-regression-example)
+ [
### Angabe einer Kantenklassifizierungsaufgabe für die Modelltrainingskonfiguration
](#machine-learning-property-graph-additionalParams-edge-classification-example)
+ [
### Angabe einer Klassifizierungsaufgabe für Kanten mit mehreren Klassen für die Modelltrainingskonfiguration
](#machine-learning-property-graph-additionalParams-multi-edge-classification-example)
+ [
### Angabe einer Kantenregression für die Modelltrainingskonfiguration
](#machine-learning-property-graph-additionalParams-edge-regression-example)
+ [
### Angabe einer Linkvorhersageaufgabe für die Modelltrainingskonfiguration
](#machine-learning-property-graph-additionalParams-link-prediction-example)
+ [
### Angabe eines numerischen Bucket-Features
](#machine-learning-property-graph-additionalParams-numeric-bucket-example)
+ [
### Angabe eines `Word2Vec`-Features
](#machine-learning-property-graph-additionalParams-word2vec-example)
+ [
### Angabe eines `FastText`-Features
](#machine-learning-property-graph-additionalParams-fasttext-example)
+ [
### Angabe eines `Sentence BERT`-Features
](#machine-learning-property-graph-additionalParams-sbert-example)
+ [
### Angabe eines `TF-IDF`-Features
](#machine-learning-property-graph-additionalParams-tf-idf-example)
+ [
### Angabe eines `datetime`-Features
](#machine-learning-property-graph-additionalParams-datetime-example)
+ [
### Angabe eines `category`-Features
](#machine-learning-property-graph-additionalParams-category-example)
+ [
### Angabe eines `numerical`-Features
](#machine-learning-property-graph-additionalParams-numerical-example)
+ [
### Angabe eines `auto`-Features
](#machine-learning-property-graph-additionalParams-auto-example)
+ [
## RDF-Beispiele mit `additionalParams`
](#machine-learning-RDF-additionalParams-examples)
+ [
### Angabe einer Standard-Aufteilungsrate für die Modelltrainingskonfiguration
](#machine-learning-RDF-additionalParams-default-split-rate-example)
+ [
### Angabe einer Knotenklassifizierungsaufgabe für die Modelltrainingskonfiguration
](#machine-learning-RDF-additionalParams-node-classification-example)
+ [
### Angabe einer Knotenregressionsaufgabe für die Modelltrainingskonfiguration
](#machine-learning-RDF-additionalParams-node-regression-example)
+ [
### Angabe einer Linkvorhersageaufgabe für bestimmte Kanten
](#machine-learning-RDF-additionalParams-link-prediction-example)
+ [
### Angabe einer Linkvorhersageaufgabe für alle Kanten
](#machine-learning-RDF-additionalParams-link-prediction-example)
## Beispiele für Eigenschaftsdiagramme mit AdditionalParams
### Angabe einer Standard-Aufteilungsrate für die Modelltrainingskonfiguration
Im folgenden Beispiel legt der Parameter `split_rate` die Standard-Aufteilungsrate für das Modelltraining fest. Wenn keine Standard-Aufteilungsrate angegeben ist, verwendet das Training den Wert [0,9, 0,1, 0,0]. Sie können den Standardwert pro Ziel überschreiben, indem Sie für jedes Ziel eine `split_rate` angeben.
Im folgenden Beispiel gibt das Feld `default split_rate` an, dass die Aufteilungsrate `[0.7,0.1,0.2]` verwendet werden sollte, wenn sie nicht pro Ziel überschrieben wird:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"split_rate": [0.7,0.1,0.2],
"targets": [
(...)
],
"features": [
(...)
]
}
}
```
### Angabe einer Knotenklassifizierungsaufgabe für die Modelltrainingskonfiguration
Zur Angabe der Knoteneigenschaft, die bezeichnete Beispiele für Trainingszwecke enthält, fügen Sie dem Array `targets` ein Element für die Knotenklassifizierung mit `"type" : "classification"` hinzu. Fügen Sie das Feld `split_rate` hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Im folgenden Beispiel zeigt das Ziel `node` an, dass die Eigenschaft `genre` jedes `Movie`-Knotens als Klassenbezeichnung eines Knotens behandelt werden soll. Der Wert `split_rate` überschreibt die Standard-Aufteilungsrate:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "genre",
"type": "classification",
"split_rate": [0.7,0.1,0.2]
}
],
"features": [
(...)
]
}
}
```
### Angabe einer Klassifizierungsaufgabe für Knoten mit mehreren Klassen für die Modelltrainingskonfiguration
Zur Angabe der Knoteneigenschaft, die mehrere bezeichnete Beispiele für Trainingszwecke enthält, fügen Sie mit `"type" : "classification"` dem Ziel-Array ein Knotenklassifikationselement und einen `separator` hinzu, um das Zeichen anzugeben, das zur Aufteilung eines Zieleigenschaftswerts in mehrere kategoriale Werte verwendet werden kann. Fügen Sie das Feld `split_rate` hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Im folgenden Beispiel zeigt das Ziel `node` an, dass die Eigenschaft `genre` jedes `Movie`-Knotens als Klassenbezeichnung eines Knotens behandelt werden soll. Das Feld `separator` zeigt an, dass jede Genre-Eigenschaft mehrere durch Semikolon getrennte Werte enthält:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "genre",
"type": "classification",
"separator": ";"
}
],
"features": [
(...)
]
}
}
```
### Angabe einer Knotenregressionsaufgabe für die Modelltrainingskonfiguration
Zur Angabe der Knoteneigenschaft, die bezeichnete Regressionen für Trainingszwecke enthält, fügen Sie mit `"type" : "regression"` dem Ziel-Array ein Element für die Knotenregression hinzu. Fügen Sie das Feld split\$1rate hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Im folgenden Beispiel zeigt das Ziel `node` an, dass die Eigenschaft `rating` jedes `Movie`-Knotens als Regressionsbezeichnung eines Knotens behandelt werden soll.
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "rating",
"type" : "regression",
"split_rate": [0.7,0.1,0.2]
}
],
"features": [
...
]
}
}
```
### Angabe einer Kantenklassifizierungsaufgabe für die Modelltrainingskonfiguration
Zur Angabe der Kanteneigenschaft, die bezeichnete Beispiele für Trainingszwecke enthält, fügen Sie mit `"type" : "regression"` dem Array `targets` ein Kantenelement hinzu. Fügen Sie das Feld split\$1rate hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Das folgende Ziel `edge` zeigt an, dass die Eigenschaft `metAtLocation` jeder `knows`-Kante als Kantenklassenbezeichnung behandelt werden soll:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Person", "knows", "Person"],
"property": "metAtLocation",
"type": "classification"
}
],
"features": [
(...)
]
}
}
```
### Angabe einer Klassifizierungsaufgabe für Kanten mit mehreren Klassen für die Modelltrainingskonfiguration
Zur Angabe der Kanteneigenschaft, die mehrere bezeichnete Beispiele für Trainingszwecke enthält, fügen Sie mit `"type" : "classification"` dem `targets`-Array ein Kantenelement und das Feld `separator` hinzu, um das Zeichen anzugeben, das zur Aufteilung eines Zieleigenschaftswerts in mehrere kategoriale Werte verwendet werden kann. Fügen Sie das Feld `split_rate` hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Das folgende Ziel `edge` zeigt an, dass die Eigenschaft `sentiment` jeder `repliedTo`-Kante als Kantenklassenbezeichnung behandelt werden soll: Das Separatorfeld zeigt an, dass jede Stimmungseigenschaft mehrere durch Komma getrennte Werte enthält:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Person", "repliedTo", "Message"],
"property": "sentiment",
"type": "classification",
"separator": ","
}
],
"features": [
(...)
]
}
}
```
### Angabe einer Kantenregression für die Modelltrainingskonfiguration
Zur Angabe der Kanteneigenschaft, die bezeichnete Regressionsbeispiele für Trainingszwecke enthält, fügen Sie mit `"type" : "regression"` dem Array `targets` das Element `edge` hinzu. Fügen Sie das Feld `split_rate` hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Das folgende Ziel `edge` zeigt an, dass die Eigenschaft `rating` jeder `reviewed`-Kante als Kantenregression behandelt werden soll:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Person", "reviewed", "Movie"],
"property": "rating",
"type" : "regression"
}
],
"features": [
(...)
]
}
}
```
### Angabe einer Linkvorhersageaufgabe für die Modelltrainingskonfiguration
Zur Angabe der Kanten, die für Linkvorhersagetrainings verwendet werden sollen, fügen Sie mit `"type" : "link_prediction"` dem Ziel-Array ein Kantenelement hinzu. Fügen Sie das Feld `split_rate` hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Das folgende Ziel `edge` zeigt an, dass `cites`-Kanten für die Linkvorhersage verwendet werden sollen:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Article", "cites", "Article"],
"type" : "link_prediction"
}
],
"features": [
(...)
]
}
}
```
### Angabe eines numerischen Bucket-Features
Sie können ein numerisches Daten-Feature für eine Knoteneigenschaft angeben, indem Sie `"type": "bucket_numerical"` zum `features`-Array hinzufügen.
Das folgende Feature `node` zeigt an, dass die Eigenschaft `age` jedes `Person`-Knotens als numerisches Bucket-Feature behandelt werden soll:
```
"additionalParams": {
"neptune_ml": {
"targets": [
...
],
"features": [
{
"node": "Person",
"property": "age",
"type": "bucket_numerical",
"range": [1, 100],
"bucket_cnt": 5,
"slide_window_size": 3,
"imputer": "median"
}
]
}
}
```
### Angabe eines `Word2Vec`-Features
Sie können ein `Word2Vec`-Feature für eine Knoteneigenschaft angeben, indem Sie `"type": "text_word2vec"` zum `features`-Array hinzufügen.
Das folgende Feature `node` zeigt an, dass die Eigenschaft `description` jedes `Movie`-Knotens als `Word2Vec`-Feature behandelt werden soll:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "description",
"type": "text_word2vec",
"language": "en_core_web_lg"
}
]
}
}
```
### Angabe eines `FastText`-Features
Sie können ein `FastText`-Feature für eine Knoteneigenschaft angeben, indem Sie `"type": "text_fasttext"` zum `features`-Array hinzufügen. Das Feld `language` ist ein Pflichtfeld und muss einen der folgenden Sprachcodes angeben:
+ `en` (Englisch)
+ `zh` (Chinesisch)
+ `hi` (Hindi)
+ `es` (Spanisch)
+ `fr` (Französisch)
Beachten Sie, dass die `text_fasttext`-Kodierung nicht mehr als eine Sprache gleichzeitig in einem Feature verarbeiten kann.
Das folgende Feature `node` zeigt an, dass die Eigenschaft `description` (Französisch) jedes `Movie`-Knotens als `FastText`-Feature behandelt werden soll:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "description",
"type": "text_fasttext",
"language": "fr",
"max_length": 1024
}
]
}
}
```
### Angabe eines `Sentence BERT`-Features
Sie können ein `Sentence BERT`-Feature für eine Knoteneigenschaft angeben, indem Sie `"type": "text_sbert"` zum `features`-Array hinzufügen. Sie müssen die Sprache nicht angeben, da die Methode Text-Features automatisch mithilfe eines mehrsprachigen Sprachmodells kodiert.
Das folgende Feature `node` zeigt an, dass die Eigenschaft `description` jedes `Movie`-Knotens als `Sentence BERT`-Feature behandelt werden soll:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "description",
"type": "text_sbert128",
}
]
}
}
```
### Angabe eines `TF-IDF`-Features
Sie können ein `TF-IDF`-Feature für eine Knoteneigenschaft angeben, indem Sie `"type": "text_tfidf"` zum `features`-Array hinzufügen.
Das folgende Feature `node` zeigt an, dass die Eigenschaft `bio` jedes `Person`-Knotens als `TF-IDF`-Feature behandelt werden soll:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "bio",
"type": "text_tfidf",
"ngram_range": [1, 2],
"min_df": 5,
"max_features": 1000
}
]
}
}
```
### Angabe eines `datetime`-Features
Beim Exportvorgang werden automatisch `datetime`-Features für Datumseigenschaften inferiert. Wenn Sie jedoch die `datetime_parts` einschränken möchten, die für ein `datetime`-Feature verwendet werden, oder eine Feature-Spezifikation überschreiben möchten, sodass eine Eigenschaft, die normalerweise als `auto`-Feature behandelt würde, explizit als `datetime`-Feature behandelt wird, fügen Sie dem Feature-Array `"type": "datetime"` hinzu.
Das folgende Feature `node` zeigt an, dass die Eigenschaft `createdAt` jedes `Post`-Knotens als `datetime`-Feature behandelt werden soll:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Post",
"property": "createdAt",
"type": "datetime",
"datetime_parts": ["month", "weekday", "hour"]
}
]
}
}
```
### Angabe eines `category`-Features
Der Exportvorgang inferiert automatisch `auto`-Features für Zeichenfolgeneigenschaften und numerische Eigenschaften, die mehrere Werte enthalten. Für numerische Eigenschaften, die Einzelwerte enthalten, werden `numerical`-Features inferiert. Für Datumseigenschaften werden `datetime`-Features inferiert.
Wenn Sie eine Feature-Spezifikation überschreiben möchten, damit eine Eigenschaft als kategoriales Feature behandelt wird, fügen Sie dem Feature-Array `"type": "category"` hinzu. Wenn die Eigenschaft mehrere Werte enthält, fügen Sie das Feld `separator` hinzu. Beispiel:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Post",
"property": "tag",
"type": "category",
"separator": "|"
}
]
}
}
```
### Angabe eines `numerical`-Features
Der Exportvorgang inferiert automatisch `auto`-Features für Zeichenfolgeneigenschaften und numerische Eigenschaften, die mehrere Werte enthalten. Für numerische Eigenschaften, die Einzelwerte enthalten, werden `numerical`-Features inferiert. Für Datumseigenschaften werden `datetime`-Features inferiert.
Wenn Sie eine Feature-Spezifikation überschreiben möchten, damit eine Eigenschaft als `numerical`-Feature behandelt wird, fügen Sie dem Feature-Array `"type": "numerical"` hinzu. Wenn die Eigenschaft mehrere Werte enthält, fügen Sie das Feld `separator` hinzu. Beispiel:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Recording",
"property": "duration",
"type": "numerical",
"separator": ","
}
]
}
}
```
### Angabe eines `auto`-Features
Der Exportvorgang inferiert automatisch `auto`-Features für Zeichenfolgeneigenschaften und numerische Eigenschaften, die mehrere Werte enthalten. Für numerische Eigenschaften, die Einzelwerte enthalten, werden `numerical`-Features inferiert. Für Datumseigenschaften werden `datetime`-Features inferiert.
Wenn Sie eine Feature-Spezifikation überschreiben möchten, damit eine Eigenschaft als `auto`-Feature behandelt wird, fügen Sie dem Feature-Array `"type": "auto"` hinzu. Wenn die Eigenschaft mehrere Werte enthält, fügen Sie das Feld `separator` hinzu. Beispiel:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "User",
"property": "role",
"type": "auto",
"separator": ","
}
]
}
}
```
## RDF-Beispiele mit `additionalParams`
### Angabe einer Standard-Aufteilungsrate für die Modelltrainingskonfiguration
Im folgenden Beispiel legt der Parameter `split_rate` die Standard-Aufteilungsrate für das Modelltraining fest. Wenn keine Standard-Aufteilungsrate angegeben ist, verwendet das Training den Wert [0,9, 0,1, 0,0]. Sie können den Standardwert pro Ziel überschreiben, indem Sie für jedes Ziel eine `split_rate` angeben.
Im folgenden Beispiel gibt das Feld `default split_rate` an, dass die Aufteilungsrate `[0.7,0.1,0.2]` verwendet werden sollte, wenn sie nicht pro Ziel überschrieben wird:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"split_rate": [0.7,0.1,0.2],
"targets": [
(...)
]
}
}
```
### Angabe einer Knotenklassifizierungsaufgabe für die Modelltrainingskonfiguration
Zur Angabe der Knoteneigenschaft, die bezeichnete Beispiele für Trainingszwecke enthält, fügen Sie dem Array `targets` ein Element für die Knotenklassifizierung mit `"type" : "classification"` hinzu. Fügen Sie ein Knotenfeld hinzu, um den Knotentyp der Zielknoten anzugeben. Fügen Sie ein `predicate`-Feld hinzu, um die Literaldaten zu definieren, die als Zielknoten-Feature des Zielknotens verwendet werden. Fügen Sie das Feld `split_rate` hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Im folgenden Beispiel zeigt das Ziel `node` an, dass die Eigenschaft `genre` jedes `Movie`-Knotens als Klassenbezeichnung eines Knotens behandelt werden soll. Der Wert `split_rate` überschreibt die Standard-Aufteilungsrate:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre",
"type": "classification",
"split_rate": [0.7,0.1,0.2]
}
]
}
}
```
### Angabe einer Knotenregressionsaufgabe für die Modelltrainingskonfiguration
Zur Angabe der Knoteneigenschaft, die bezeichnete Regressionen für Trainingszwecke enthält, fügen Sie mit `"type" : "regression"` dem Ziel-Array ein Element für die Knotenregression hinzu. Fügen Sie ein `node`-Feld hinzu, um den Knotentyp der Zielknoten anzugeben. Fügen Sie ein `predicate`-Feld hinzu, um die Literaldaten zu definieren, die als Zielknoten-Feature des Zielknotens verwendet werden. Fügen Sie das Feld `split_rate` hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Im folgenden Beispiel zeigt das Ziel `node` an, dass die Eigenschaft `rating` jedes `Movie`-Knotens als Regressionsbezeichnung eines Knotens behandelt werden soll.
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/rating",
"type": "regression",
"split_rate": [0.7,0.1,0.2]
}
]
}
}
```
### Angabe einer Linkvorhersageaufgabe für bestimmte Kanten
Zur Angabe der Kanten, die für Linkvorhersagetrainings verwendet werden sollen, fügen Sie mit `"type" : "link_prediction"` dem Ziel-Array ein Kantenelement hinzu. Fügen Sie die Felder `subject`, `predicate` und `object` hinzu, um den Kantentyp anzugeben. Fügen Sie das Feld `split_rate` hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
Das folgende `edge`-Ziel zeigt an, dass `directed`-Kanten, die `Directors` mit `Movies` verbinden, für die Linkvorhersage verwendet werden sollen:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"subject": "http://aws.amazon.com/neptune/csv2rdf/class/Director",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/directed",
"object": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"type" : "link_prediction"
}
]
}
}
```
### Angabe einer Linkvorhersageaufgabe für alle Kanten
Um anzugeben, dass alle Kanten für Linkvorhersagetrainings verwendet werden sollen, fügen Sie mit `"type" : "link_prediction"` dem Ziel-Array ein `edge`-Element hinzu. Fügen Sie keine Felder `subject`, `predicate` oder `object` hinzu. Fügen Sie das Feld `split_rate` hinzu, wenn Sie die Standard-Aufteilungsrate überschreiben möchten.
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"type" : "link_prediction"
}
]
}
}
```
# Verarbeitung der aus Neptune zu Trainingszwecken exportierten Diagrammdaten
Im Datenverarbeitungsschritt werden anhand der durch den Exportvorgang erstellten Neptune-Diagrammdaten die Informationen erstellt, die von der [Deep Graph Library (DGL](https://www.dgl.ai/)) beim Training verwendet werden. Dies umfasst die verschiedene Datenzuordnungen und -transformationen:
+ Analyse von Knoten und Kanten, um die von der DGL benötigten Diagramm- und ID-Zuordnungsdateien zu erstellen.
+ Konvertierung von Knoten- und Kanteneigenschaften in die von der DGL benötigten Knoten- und Kanten-Features.
+ Aufteilung der Daten in Trainings-, Validierungs- und Testsätze.
## Verwalten des Datenverarbeitungsschritts für Neptune ML
Nach dem Export der Daten aus Neptune, die Sie für das Modelltraining verwenden möchten, können Sie einen Datenverarbeitungsauftrag mit einem `curl`-Befehl (oder `awscurl`-Befehl) wie dem folgenden starten:
```
curl \
-X POST https://(your Neptune endpoint)/ml/dataprocessing \
-H 'Content-Type: application/json' \
-d '{
"inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)",
"id" : "(a job ID for the new job)",
"processedDataS3Location" : "s3://(S3 bucket name)/(path to your output folder)",
"configFileName" : "training-job-configuration.json"
}'
```
Details zur Verwendung dieses Befehls werden in [Der Datenverarbeitungsbefehl](machine-learning-api-dataprocessing.md) beschrieben. Dort finden Sie auch Informationen dazu, wie Sie ausgeführte Aufträge abrufen und beenden und alle ausgeführten Aufträge auflisten.
## Verarbeiten aktualisierter Diagrammdaten für Neptune ML
Sie können der API auch eine `previousDataProcessingJobId` bereitstellen, damit der neue Datenverarbeitungsauftrag dieselbe Verarbeitungsmethode wie ein vorheriger Auftrag verwendet. Dies ist erforderlich, wenn Sie Vorhersagen für aktualisierte Diagrammdaten in Neptune erhalten möchten, indem Sie entweder das alte Modell mit den neuen Daten trainieren oder die Modellartefakte anhand der neuen Daten neu berechnen.
Hierzu verwenden Sie einen `curl`-Befehl (oder`awscurl`-Befehl) wie diesen:
```
curl \
-X POST https://(your Neptune endpoint)/ml/dataprocessing \
-H 'Content-Type: application/json' \
-d '{ "inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)",
"id" : "(a job ID for the new job)",
"processedDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your output folder)",
"previousDataProcessingJobId", "(the job ID of the previous data-processing job)"}'
```
Legen Sie den Wert des Parameters `previousDataProcessingJobId` auf die Auftrags-ID des vorherigen Datenverarbeitungsauftrags für das trainierte Modell fest.
**Anmerkung**
Das Löschen von Knoten im aktualisierten Diagramm wird zurzeit nicht unterstützt. Wenn in einem aktualisierten Diagramm Knoten entfernt wurden, müssen Sie einen völlig neuen Datenverarbeitungsauftrag starten, statt `previousDataProcessingJobId` zu verwenden.
# Feature-Kodierung in Neptune ML
Eigenschaftswerte haben verschiedene Formate und Datentypen. Um eine gute Machine-Learning-Leistung zu erzielen, müssen diese Werte in numerische Kodierungen konvertiert werden, so genannte *features*.
Neptune ML extrahiert und kodiert Features im Rahmen der Schritte data-export und data-processing mit den hier beschrieben Feature-Kodierungs-Techniken.
**Anmerkung**
Wenn Sie eine eigene Feature-Kodierung in einer benutzerdefinierten Modellimplementierung implementieren möchten, können Sie die automatische Feature-Kodierung in der Datenvorverarbeitungsphase deaktivieren, indem Sie als Feature-Kodierungstyp `none` auswählen. In diesem Fall findet für diese Knoten- oder Kanteneigenschaft keine Feature-Kodierung statt. Stattdessen werden die rohen Eigenschaftswerte analysiert und in einem Verzeichnis gespeichert. Während der Datenvorverarbeitung wird weiter das DGL-Diagramm aus dem exportierten Datensatz erstellt, aber das konstruierte DGL-Diagramm verfügt nicht über keine vorverarbeiteten Features für das Training.
Sie sollten diese Option nur verwenden, wenn Sie eine benutzerdefinierte Feature-Kodierung als Teil eines benutzerdefinierten Modelltrainings ausführen möchten. Details dazu finden Sie unter [Benutzerdefinierte Modelle in Neptune ML](machine-learning-custom-models.md).
## Kategorische Features in Neptune ML
Eine Eigenschaft, die einen oder mehrere unterschiedliche Werte aus einer festen Liste möglicher Werte annehmen kann, ist ein kategorisches Feature. In Neptune ML werden kategorische Features mit [One-Hot-Kodierung](https://en.wikipedia.org/wiki/One-hot) kodiert. Das folgende Beispiel zeigt, wie die Eigenschaftsnamen verschiedener Lebensmittel entsprechend ihrer Kategorie mit One-Hot-Kodierung kodiert werden:
```
Food Veg. Meat Fruit Encoding
--------- ---- ---- ----- --------
Apple 0 0 1 001
Chicken 0 1 0 010
Broccoli 1 0 0 100
```
**Anmerkung**
Die maximale Anzahl von Kategorien in einem kategorischen Feature ist 100. Wenn eine Eigenschaft mehr als 100 Wertkategorien besitzt, werden nur die 99 häufigsten Kategorien in verschiedenen Kategorien platziert. Der Rest wird in einer speziellen Kategorie mit dem Namen `OTHER` platziert.
## Numerische Features in Neptune ML
Eine Eigenschaft, deren Werte reale Zahlen sind, kann in Neptune ML als numerisches Feature kodiert werden. Numerische Features werden mit Gleitkommazahlen kodiert.
Sie können eine Methode für die Datennormalisierung angeben, die beim Kodieren numerischer Features verwendet werden soll, z. B.: `"norm": "normalization technique"`. Die folgenden Normalisierungstechniken werden unterstützt:
+ **"none"** – Normalisiert die numerischen Werte während der Kodierung nicht.
+ **"min-max"** – Normalisiert jeden Wert, indem der Mindestwert subtrahiert wird und der Wert dann durch die Differenz zwischen Maximalwert und Mindestwert dividiert wird.
+ **"standard"** – Normalisiert jeden Wert, indem er durch die Summe aller Werte dividiert wird.
## Bucket-numerische Features in Neptune ML
Anstatt eine numerische Eigenschaft mit rohen Zahlen darzustellen, können Sie numerische Werte zu Kategorien kondensieren. Sie könnten beispielsweise das Alter von Personen in Kategorien wie Kinder (0–20), junge Erwachsene (20–40), Personen mittleren Alters (40–60) und ältere Menschen (ab 60) unterteilen. Mithilfe dieser numerischen Buckets würden Sie eine numerische Eigenschaft in eine Art kategorisches Feature transformieren.
In Neptune ML können Sie die Kodierung einer numerischen Eigenschaft als Bucket-numerisches Feature veranlassen. Sie müssen zwei Dinge angeben:
+ Ein numerischer Bereich im Format ` "range": [a, b] `, wobei `a` und `b` Ganzzahlen sind.
+ Eine Bucket-Zahl im Format ` "bucket_cnt": c `, wobei `c` die Anzahl der Buckets ist, ebenfalls eine Ganzzahl.
Neptune ML berechnet dann die Größe jedes Buckets als ` ( b - a ) / c ` und kodiert jeden numerischen Wert als Nummer des Buckets, zu dem er gehört. Jeder Wert kleiner als `a` wird als zum ersten Bucket gehörend betrachtet. Jeder Wert größer als `b` wird als zum letzten Bucket gehörend betrachtet.
Sie können optional auch festlegen, dass numerische Werte zu mehr als einem Bucket gehören, indem Sie eine Größe für das Gleitfenster angeben, z. B.: ` "slide_window_size": s `. Dabei ist `s` eine Zahl. Neptune ML transformiert anschließend jeden numerischen Wert `v` der Eigenschaft in einen Bereich von ` v - s/2 ` bis ` v + s/2 ` und weist den Wert `v` jedem Bucket zu, den der Bereich abdeckt.
Schließlich können Sie optional auch eine Möglichkeit zum Ausfüllen fehlender Werte für numerische Features und Bucket-numerische Features bereitstellen. Hierzu verwenden Sie ` "imputer": "imputation technique "`, wobei die Imputationstechnik entweder `"mean"`, `"median"` oder `"most-frequent"` ist. Wenn Sie keinen Imputer angeben, kann ein fehlender Wert dazu führen, dass die Verarbeitung angehalten wird.
## Text-Feature-Kodierung in Neptune ML
Für Freiformtext kann Neptune ML mehrere verschiedene Modelle verwenden, um die Sequenz von Token in einer Eigenschaftswert-Zeichenfolge in einen Realwertvektor fester Größe zu konvertieren:
+ [`text_fasttext`](#machine-learning-fasttext-features) – Verwendet [fastText](https://fasttext.cc/)-Kodierung. Dies ist die empfohlene Kodierung für Features, die eine und nur eine der fünf Sprachen verwenden, die fastText unterstützt.
+ [`text_sbert`](#machine-learning-sbert-features) – Verwendet die Kodierungsmodelle [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Dies ist die empfohlene Kodierung für Text, den `text_fasttext` nicht unterstützt.
+ [`text_word2vec`](#machine-learning-word2vec-features) – Verwendet die [Word2Vec](https://wikipedia.org/wiki/Word2vec)-Algorithmen (ursprünglich von [Google](https://code.google.com/archive/p/word2vec/) veröffentlicht), um Text zu kodieren. Word2Vec unterstützt nur Englisch.
+ [`text_tfidf`](#machine-learning-tfidf-features) – Verwendet den Vektorisierer [term frequency–inverse document frequency](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) für die Textkodierung. Die TF-IDF-Kodierung unterstützt statistische Features, die von den anderen Kodierungen nicht unterstützt werden.
### *fastText*-Kodierung von Texteigenschaftswerten in Neptune ML
Neptune ML kann die [fastText](https://fasttext.cc/)-Modelle verwenden, um Texteigenschaftswerte in Realwertvektoren fester Größe zu konvertieren. Dies ist die empfohlene Kodierungsmethode für Texteigenschaftswerte in einer der fünf Sprachen, die fastText unterstützt:
+ `en` (Englisch)
+ `zh` (Chinesisch)
+ `hi` (Hindi)
+ `es` (Spanisch)
+ `fr` (Französisch)
Beachten Sie, dass fastText keine Sätze verarbeiten kann, die Wörter in mehr als einer Sprache enthalten.
Die Methode `text_fasttext` kann optional das Feld `max_length` verwenden, das die maximale Anzahl von Token in einem Texteigenschaftswert angibt, die kodiert werden sollen. Anschließend wird die Zeichenfolge abgeschnitten. Dies kann die Leistung verbessern, wenn Texteigenschaftswerte lange Zeichenfolgen enthalten, da fastText alle Token unabhängig von der Zeichenfolgenlänge kodiert, wenn `max_length` nicht angegeben ist.
Dieses Beispiel gibt an, dass französische Filmtitel mit fastText kodiert werden:
```
{
"file_name" : "nodes/movie.csv",
"separator" : ",",
"node" : ["~id", "movie"],
"features" : [
{
"feature": ["title", "title", "text_fasttext"],
"language": "fr",
"max_length": 1024
}
]
}
```
### Sentence BERT (SBERT)-Satzkodierung von Text-Features in Neptune ML
Neptune ML kann die Sequenz von Token in einem Zeichenfolgen-Eigenschaftswert mithilfe von Sentence BERT (SBERT)-Modellen in einen Realwertvektor fester Größe konvertieren. Neptune unterstützt zwei SBERT-Methoden: `text_sbert128` (die Standardmethode, wenn Sie nur `text_sbert` angeben) und `text_sbert512`. Der Unterschied zwischen den beiden Methoden ist die maximale Länge einer kodierten Texteigenschaftswert-Zeichenfolge. Bei der `text_sbert128`-Kodierung werden Textzeichenfolgen nach der Kodierung von 128 Token abgeschnitten, während `text_sbert512` Textzeichenfolgen nach der Kodierung von 512 Token abschneidet. Daher erfordert `text_sbert512` mehr Verarbeitungszeit als `text_sbert128`. Beide Methoden sind langsamer als `text_fasttext`.
Die SBERT-Kodierung ist mehrsprachig. Daher müssen Sie keine Sprache für den Eigenschaftswerttext angeben, den Sie kodieren. SBERT unterstützt zahlreiche Sprachen und kann einen Satz kodieren, der mehr als eine Sprache enthält. Wenn Sie Eigenschaftswerte kodieren, die Text in einer oder mehreren Sprachen enthalten, die fastText nicht unterstützt, ist SBERT die empfohlene Kodierungsmethode.
Das folgende Beispiel gibt an, dass Filmtitel bis maximal 128 Token als SBERT kodiert werden:
```
{
"file_name" : "nodes/movie.csv",
"separator" : ",",
"node" : ["~id", "movie"],
"features" : [
{ "feature": ["title", "title", "text_sbert128"] }
]
}
```
### Word2Vec-Kodierung von Text-Features in Neptune ML
Neptune ML kann Zeichenfolgen-Eigenschaftswerte als Word2Vec-Feature kodieren. (Die [Word2Vec-Algorithmen](https://wikipedia.org/wiki/Word2vec) wurden ursprünglich von [Google](https://code.google.com/archive/p/word2vec/) veröffentlicht.) Die Methode `text_word2vec` kodiert die Token in einer Zeichenfolge als dichten Vektor unter Verwendung eines [von SpaCy trainierten Modells](https://spacy.io/models). Sie unterstützt nur die englische Sprache (unter Verwendung des Modells [en\$1core\$1web\$1lg](https://spacy.io/models/en#en_core_web_lg)).
Das folgende Beispiel gibt an, dass Filmtitel mit Word2Vec kodiert werden:
```
{
"file_name" : "nodes/movie.csv",
"separator" : ",",
"node" : ["~id", "movie"],
"features" : [
{
"feature": ["title", "title", "text_word2vec"],
"language": "en_core_web_lg"
}
]
}
```
Beachten Sie, dass das Sprachfeld optional ist, da das englische `en_core_web_lg`-Modell das einzige Modell ist, das Neptune unterstützt.
### TF-IDF-Kodierung von Text-Features in Neptune ML
Neptune ML kann Texteigenschaftswerte als `text_tfidf`-Features kodieren. Diese Kodierung konvertiert die Reihenfolge der Wörter im Text mittels des Vektorisierers [term frequency–inverse document frequency](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) in einen numerischen Vektor, gefolgt von einer Operation zur Reduzierung der Dimensionalität.
[TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) (term frequency – inverse document frequency) ist ein numerischer Wert, der misst, wie wichtig ein Wort in einem Dokumentensatz ist. Er wird berechnet, indem die Häufigkeit, mit der ein Wort in einem bestimmten Eigenschaftswert vorkommt, durch die Gesamtzahl der Eigenschaftswerte dividiert wird, in denen es vorkommt.
Wenn beispielsweise das Wort „Kiss“ zweimal in einem bestimmten Filmtitel vorkommt (z. B. „Kiss Kiss Bang Bang“) und „Kiss“ im Titel von insgesamt 4 Filmen vorkommt, dann wäre der TF-IDF-Wert für „Kiss“ im Titel „Kiss Kiss Bang Bang“ ` 2 / 4 `.
Der Vektor, der ursprünglich erstellt wird, hat ***d*** Dimensionen, wobei ***d*** die Anzahl der eindeutigen Begriffe in allen Eigenschaftswerten dieses Typs ist. Die Operation zur Reduzierung der Dimensionalität verwendet eine randomisierte Projektion mit geringer Dichte, um diese Zahl auf maximal 100 zu reduzieren. Anschließend wird das Vokabular eines Diagramms generiert, indem alle enthaltenen `text_tfidf`-Features zusammengeführt werden.
Sie können den TF-IDF-Vektorisierer auf verschiedene Arten steuern:
+ **`max_features`** – Mithilfe des Parameters `max_features` können Sie die Anzahl der Begriffe in `text_tfidf`-Features auf die häufigsten einschränken. Wenn Sie beispielsweise `max_features` auf 100 festlegen, sind nur die 100 am häufigsten verwendeten Begriffe enthalten. Wenn Sie `max_features` nicht explizit festlegen, ist der Standardwert 5 000.
+ **`min_df`** – Mithilfe des Parameters `min_df` können Sie die Anzahl der Begriffe in `text_tfidf`-Features auf Features einschränken, die mindestens mit einer angegebenen Häufigkeit im Dokumentsatz vorkommen. Wenn Sie beispielsweise `min_df` auf 5 festlegen, werden nur Begriffe verwendet, die in mindestens 5 verschiedenen Eigenschaftswerten vorkommen. Wenn Sie `min_df` nicht explizit festlegen, ist der Standardwert 2.
+ **`ngram_range`** – Der Parameter `ngram_range` bestimmt, welche Wortkombinationen als Begriffe behandelt werden. Wenn Sie beispielsweise `ngram_range` auf `[2, 4]` festlegen, würden die folgenden 6 Begriffe im Titel „Kiss Kiss Bang Bang“ vorkommen:
+ *Begriffe mit 2 Wörtern*: „Kiss Kiss“, „Kiss Bang“ und „Bang Bang“.
+ *Begriffe mit 3 Wörtern*: „Kiss Kiss Bang“ und „Kiss Bang Bang“.
+ *Begriffe mit 4 Wörtern*: „Kiss Kiss Bang Bang“.
Die Standardeinstellung für `ngram_range` ist `[1, 1]`.
## Datetime-Features in Neptune ML
Neptune ML kann Teile von `datetime`-Eigenschaftswerten in kategorische Features konvertieren, indem sie als [One-Hot-Arrays](https://en.wikipedia.org/wiki/One-hot) kodiert werden. Verwenden Sie den Parameter `datetime_parts`, um einen oder mehrere der folgenden Teile für die Kodierung anzugeben: `["year", "month", "weekday", "hour"]`. Wenn Sie `datetime_parts` nicht festlegen, werden standardmäßig alle vier Teile kodiert.
Wenn der Bereich der datetime-Werte beispielsweise die Jahre 2010 bis 2012 umfasst, sind die vier Teile des datetime-Eintrags `2011-04-22 01:16:34` wie folgt:
+ **year** – `[0, 1, 0]`.
Da der Zeitraum nur 3 Jahre umfasst (2010, 2011 und 2012), hat das One-Hot-Array drei Einträge, einen für jedes Jahr.
+ **month** – `[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]`.
Hier enthält das One-Hot-Array einen Eintrag für jeden Monat des Jahres.
+ **weekday** – `[0, 0, 0, 0, 1, 0, 0]`.
Nach dem ISO-8601-Standard ist Montag der erste Tag der Woche. Da der 22. April 2011 ein Freitag war, ist das entsprechende One-Hot-Wochentag-Array an der fünften Position aktiviert.
+ **hour** – `[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]`.
Die Stunde 01:00 Uhr ist in einem One-Hot-Array mit 24 Elementen festgelegt.
Tag des Monats, Minute und Sekunde sind nicht kategorisch kodiert.
Wenn der betreffende `datetime`-Bereich nur Daten innerhalb eines einzigen Jahres umfasst, wird kein `year`-Array kodiert.
Sie können eine Imputationsstrategie angeben, um fehlende `datetime`-Werte aufzufüllen, indem Sie den Parameter `imputer` und eine der für numerische Features verfügbaren Strategien verwenden.
## Auto-Feature-Kodierung in Neptune ML
Anstatt die Feature-Kodierungsmethoden manuell anzugeben, die für die Eigenschaften im Diagramm verwendet werden sollen, können Sie `auto` als Feature-Kodierungsmethode festlegen. Neptune ML versucht dann, anhand des zugrunde liegenden Datentyps die beste Feature-Kodierung für jede Eigenschaft zu inferieren.
Dies sind einige der Heuristiken, die Neptune ML bei der Auswahl der geeigneten Feature-Kodierungen verwendet:
+ Wenn die Eigenschaft nur numerische Werte besitzt und in numerische Datentypen konvertiert werden kann, kodiert Neptune ML sie im Allgemeinen als numerischen Wert. Wenn jedoch die Anzahl der eindeutigen Werte für die Eigenschaft weniger als 10 % der Gesamtzahl der Werte ist und die Kardinalität dieser eindeutigen Werte kleiner als 100 ist, verwendet Neptune ML eine kategorische Kodierung.
+ Wenn die Eigenschaftswerte in einen `datetime`-Typ konvertiert werden können, kodiert Neptune ML sie als `datetime`-Feature.
+ Wenn die Eigenschaftswerte in boolesche Werte (1/0 oder True/False) transformiert werden können, verwendet Neptune ML die Kategoriekodierung.
+ Wenn es sich bei der Eigenschaft um eine Zeichenfolge handelt, in der mehr als 10 % ihrer Werte eindeutig sind und die durchschnittliche Anzahl von Token pro Wert größer oder gleich 3 ist, inferiert Neptune ML den Eigenschaftstyp als Text und erkennt automatisch die verwendete Sprache. Wenn es sich bei der erkannten Sprache um eine der von [fastText](#machine-learning-fasttext-features) unterstützten Sprachen handelt (Englisch, Chinesisch, Hindi, Spanisch und Französisch), verwendet Neptune ML `text_fasttext` zur Kodierung des Texts. Andernfalls verwendet Neptune ML [`text_sbert`](#machine-learning-sbert-features).
+ Wenn die Eigenschaft eine nicht als Text-Feature klassifizierte Zeichenfolge ist, nimmt Neptune ML an, dass es sich um ein kategorisches Feature handelt, und verwendet die Kategoriekodierung.
+ Wenn jeder Knoten einen eigenen eindeutigen Wert für eine Eigenschaft hat, die als Kategorie-Feature inferiert wird, löscht Neptune ML die Eigenschaft aus dem Trainingsdiagramm, da es sich wahrscheinlich um eine ID handelt, die für das Lernen keine Informationen bereitstellt.
+ Wenn bekannt ist, dass die Eigenschaft gültige Neptune-Trennzeichen wie Semikolon („;“) enthält, kann Neptune ML die Eigenschaft nur als `MultiNumerical` oder `MultiCategorical` behandeln.
+ Neptune ML versucht zunächst, die Werte als numerische Features zu kodieren. Wenn dies erfolgreich ist, verwendet Neptune ML die numerische Kodierung, um numerische Vektor-Features zu erstellen.
+ Andernfalls kodiert Neptune ML die Werte als Werte mit mehreren Kategorien.
+ Wenn Neptune ML den Datentyp der Werte einer Eigenschaft nicht ableiten kann, Neptune MLdrops die Eigenschaft aus dem Trainingsdiagramm.
# Bearbeiten einer Trainingsdaten-Konfigurationsdatei
Der Neptune-Exportvorgang exportiert Neptune-ML-Daten aus einem Neptune-DB-Cluster in einen S3-Bucket. Er exportiert Knoten und Kanten getrennt in die Ordner `nodes/` und `edges/`. Er erstellt außerdem eine JSON-Konfigurationsdatei für Trainingsdaten, die standardmäßig den Namen `training-data-configuration.json` hat. Diese Datei enthält Informationen zum Schema des Diagramms, zu den Typen der Features, zu den Operationen für Feature-Transformation und -Normalisierung sowie zum Ziel-Feature für eine Klassifizierungs- oder Regressionsaufgabe.
Es kann Fälle geben, in denen Sie Konfigurationsdatei direkt ändern möchten. Ein solcher Fall liegt vor, wenn Sie ändern möchten, wie Features verarbeitet werden oder wie das Diagramm konstruiert wird, ohne den Export jedes Mal erneut ausführen zu müssen, wenn Sie die Spezifikation für die Machine-Learning-Aufgabe ändern, die Sie lösen möchten.
**Bearbeiten der Trainingsdaten-Konfigurationsdatei**
1. **Laden Sie die Datei zu Ihrem lokalen Computer herunter.**
Wenn Sie nicht einen oder mehrere benannte Aufträge in dem an den Exportvorgang übergebenen Parameter `additionalParams/neptune_ml` angegeben haben, hat die Datei den Standardnamen, `training-data-configuration.json`. Sie können einen AWS CLI-Befehl wie diesen verwenden, um die Datei herunterzuladen:
```
aws s3 cp \
s3://(your Amazon S3 bucket)/(path to your export folder)/training-data-configuration.json \
./
```
1. **Bearbeiten Sie die Datei mit einem Texteditor.**
1. **Laden Sie die geänderte Datei hoch.** Laden Sie die geänderte Datei mit einem AWS CLI-Befehl wie dem folgenden wieder an den gleichen Speicherort in Amazon S3 hoch, von dem Sie sie heruntergeladen haben:
```
aws s3 cp \
training-data-configuration.json \
s3://(your Amazon S3 bucket)/(path to your export folder)/training-data-configuration.json
```
# Beispiel für eine JSON-Konfigurationsdatei für Trainingsdaten
Dies ist ein Beispiel für eine Trainingsdaten-Konfigurationsdatei, die ein Diagramm für eine Aufgabe zur Knotenklassifizierung beschreibt:
```
{
"version" : "v2.0",
"query_engine" : "gremlin",
"graph" : [
{
"edges" : [
{
"file_name" : "edges/(movie)-included_in-(genre).csv",
"separator" : ",",
"source" : ["~from", "movie"],
"relation" : ["", "included_in"],
"dest" : [ "~to", "genre" ]
},
{
"file_name" : "edges/(user)-rated-(movie).csv",
"separator" : ",",
"source" : ["~from", "movie"],
"relation" : ["rating", "prefixname"], # [prefixname#value]
"dest" : ["~to", "genre"],
"features" : [
{
"feature" : ["rating", "rating", "numerical"],
"norm" : "min-max"
}
]
}
],
"nodes" : [
{
"file_name" : "nodes/genre.csv",
"separator" : ",",
"node" : ["~id", "genre"],
"features" : [
{
"feature": ["name", "genre", "category"],
"separator": ";"
}
]
},
{
"file_name" : "nodes/movie.csv",
"separator" : ",",
"node" : ["~id", "movie"],
"features" : [
{
"feature": ["title", "title", "word2vec"],
"language": ["en_core_web_lg"]
}
]
},
{
"file_name" : "nodes/user.csv",
"separator" : ",",
"node" : ["~id", "user"],
"features" : [
{
"feature": ["age", "age", "numerical"],
"norm" : "min-max",
"imputation": "median",
},
{
"feature": ["occupation", "occupation", "category"],
}
],
"labels" : [
{
"label": ["gender", "classification"],
"split_rate" : [0.8, 0.2, 0.0]
}
]
}
]
},
"warnings" : [ ]
]
}
```
# Die Struktur der JSON-Konfigurationsdateien für Trainingsdaten
Die Trainingskonfigurationsdatei verweist auf CSV-Dateien, die vom Exportvorgang in den Ordnern `nodes/` und `edges/` gespeichert wurden.
In jeder Datei unter `nodes/` werden Informationen zu Knoten gespeichert, die dieselbe Eigenschaftsdiagramm-Knotenbezeichnung besitzen. Jede Spalte in einer Knotendatei speichert entweder die Knoten-ID oder die Knoteneigenschaft. Die erste Zeile der Datei enthält eine Kopfzeile mit der `~id` oder dem Eigenschaftsnamen für jede Spalte.
In jeder Datei unter `edges/` werden Informationen zu Knoten gespeichert, die dieselbe Eigenschaftsdiagramm-Kantenbezeichnung besitzen. Jede Spalte in einer Knotendatei speichert entweder die Quellknoten-ID, die Zielknoten-ID oder die Kanteneigenschaft. Die erste Zeile der Datei enthält eine Kopfzeile mit `~from`, `~to` oder dem Eigenschaftsnamen für jede Spalte.
Die Trainingsdaten-Konfigurationsdatei besitzt auf der obersten Ebene drei Elemente:
```
{
"version" : "v2.0",
"query_engine" : "gremlin",
"graph" : [ ... ]
}
```
+ `version` – (Zeichenfolge) Die Version der verwendeten Konfigurationsdatei.
+ `query_engine` – (Zeichenfolge) Die Abfragesprache für den Export der Diagrammdaten. Zurzeit ist nur „Gremlin“ gültig.
+ `graph` – (JSON-Array) listet ein oder mehrere Konfigurationsobjekte auf, die Modellparameter für alle Knoten und Kanten enthalten, die verwendet werden sollen.
Die Konfigurationsobjekte im Diagramm-Array haben die im nächsten Abschnitt beschriebene Struktur.
## Inhalt eines im `graph`-Array aufgelisteten Konfigurationsobjekts
Ein Konfigurationsobjekt im `graph`-Array kann auf der obersten Ebene drei Knoten enthalten:
```
{
"edges" : [ ... ],
"nodes" : [ ... ],
"warnings" : [ ... ],
}
```
+ `edges` – (Array von JSON-Objekten) Jedes JSON-Objekt gibt eine Reihe von Parametern an, um die Behandlung einer Kante im Diagramm während Modellverarbeitung und -training zu definieren. Dieser Knoten wird nur mit der Gremlin-Engine verwendet.
+ `nodes` – (Array von JSON-Objekten) Jedes JSON-Objekt gibt eine Reihe von Parametern an, um die Behandlung eines Knotens im Diagramm während Modellverarbeitung und -training zu definieren. Dieser Knoten wird nur mit der Gremlin-Engine verwendet.
+ `warnings` – (Array von JSON-Objekten) Jedes Objekt enthält eine Warnung, die während des Datenexportvorgangs generiert wird.
## Inhalt eines im `edges`-Array aufgelisteten Kantenkonfigurationsobjekts
Ein in einem `edges`-Array aufgelistetes Kantenkonfigurationsobjekt kann auf der obersten Ebene die folgenden Felder enthalten:
```
{
"file_name" : "(path to a CSV file)",
"separator" : "(separator character)",
"source" : ["(column label for starting node ID)", "(starting node type)"],
"relation" : ["(column label for the relationship name)", "(the prefix name for the relationship name)"],
"dest" : ["(column label for ending node ID)", "(ending node type)"],
"features" : [(array of feature objects)],
"labels" : [(array of label objects)]
}
```
+ **`file_name`** – Eine Zeichenfolge, die den Pfad zu einer CSV-Datei angibt, in der Informationen zu Kanten mit derselben Eigenschaftsdiagramm-Bezeichnung gespeichert werden.
Die erste Zeile dieser Datei enthält eine Kopfzeile mit Spaltenbezeichnungen.
Die ersten beiden Spaltenbezeichnungen sind `~from` und `~to`. In der ersten Spalte (die Spalte `~from`) wird die ID des Startknotens der Kante gespeichert. In der zweiten Spalte (die Spalte `~to`) wird die ID des Endknotens der Kante gespeichert.
Die verbleibenden Spaltenbezeichnungen in der Kopfzeile geben für jede verbleibende Spalte den Namen der Kanteneigenschaft an, deren Werte in diese Spalte exportiert wurden.
+ **`separator`** – Eine Zeichenfolge mit dem Trennzeichen, das die Spalten in dieser CSV-Datei trennt.
+ **`source`** – Ein JSON-Array mit zwei Zeichenfolgen, die den Startknoten der Kante angeben. Die erste Zeichenfolge enthält den Kopfzeilennamen der Spalte, in der die Startknoten-ID gespeichert ist. Die zweite Zeichenfolge gibt den Knotentyp an.
+ **`relation`** – Ein JSON-Array mit zwei Zeichenfolgen, die den Beziehungstyp der Kante angeben. Die erste Zeichenfolge enthält den Kopfzeilennamen der Spalte, in der der Beziehungsname (`relname`) gespeichert ist. Die zweite Zeichenfolge enthält das Präfix für den Beziehungsnamen (`prefixname`).
Der vollständige Beziehungstyp besteht aus den beiden Zeichenfolgen mit einem Bindestrich zwischen ihnen wie folgt: `prefixname-relname`.
Wenn die erste Zeichenfolge leer ist, haben alle Kanten den gleichen Beziehungstyp, nämlich die `prefixname`-Zeichenfolge.
+ **`dest`** – Ein JSON-Array mit zwei Zeichenfolgen, die den Endknoten der Kante angeben. Die erste Zeichenfolge enthält den Kopfzeilennamen der Spalte, in der die Endknoten-ID gespeichert ist. Die zweite Zeichenfolge gibt den Knotentyp an.
+ **`features`** – Ein JSON-Array mit Eigenschaftswert-Feature-Objekten. Jedes Eigenschaftswert-Feature--Objekt enthält die folgenden Felder:
+ **feature** – Ein JSON-Array mit drei Zeichenfolgen. Die erste Zeichenfolge enthält den Kopfzeilennamen der Spalte, in der der Eigenschaftswert gespeichert ist. Die zweite Zeichenfolge enthält den Feature-Namen. Die dritte Zeichenfolge enthält den Feature-Typ.
+ **norm** – (*Optional*) Gibt die Normalisierungsmethode an, die auf die Eigenschaftswerte angewendet werden soll.
+ **`labels`** – Ein JSON-Array von Objekten. Jedes dieser Objekte definiert ein Ziel-Feature der Kanten und gibt die Proportionen der Kanten für die Trainings- und Validierungsphasen an. Jedes Objekt enthält die folgenden Felder:
+ **label** – Ein JSON-Array mit zwei Zeichenfolgen. Die erste Zeichenfolge enthält den Kopfzeilennamen der Spalte, in der der Ziel-Feature-Eigenschaftswert gespeichert ist. Die zweite Zeichenfolge gibt einen der folgenden Zielaufgabentypen an:
+ `"classification"` – Eine Aufgabe zur Kantenklassifizierung. Die Eigenschaftswerte in der Spalte, die durch die erste Zeichenfolge im `label`-Array identifiziert wird, werden als kategorische Werte behandelt. Bei einer Aufgabe zur Kantenklassifizierung darf die erste Zeichenfolge im `label`-Array nicht leer sein.
+ `"regression"` – Eine Kantenregressionsaufgabe. Die Eigenschaftswerte in der Spalte, die durch die erste Zeichenfolge im `label`-Array identifiziert wird, werden als numerische Werte behandelt. Für eine Aufgabe zur Kantenregression darf die erste Zeichenfolge im `label`-Array nicht leer sein.
+ `"link_prediction"` – Eine Aufgabe zur Linkvorhersage. Es sind keine Eigenschaftswerte erforderlich. Bei einer Aufgabe zur Linkvorhersage wird die erste Zeichenfolge im `label`-Array ignoriert.
+ **`split_rate`** – Ein JSON-Array mit drei Zahlen zwischen null und eins, die zusammen eins ergeben und eine Schätzung des Anteils der Knoten darstellen, die in der Trainings-, Validierungs- und Testphase jeweils verwendet werden. Sie können dieses Feld oder das Feld `custom_split_filenames` definieren, aber nicht beide. Siehe [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate).
+ **`custom_split_filenames`** – Ein JSON-Objekt, das die Dateinamen für die Dateien angibt, die die Trainings-, Validierungs- und Testpopulationen definieren. Sie können dieses Feld oder das Feld `split_rate` definieren, aber nicht beide. Weitere Informationen finden Sie unter [Benutzerdefinierte train-validation-test Proportionen](#machine-learning-custom-stages-splits).
## Inhalt eines im `nodes`-Array aufgelisteten Knotenkonfigurationsobjekts
Ein in einem `nodes`-Array aufgelistetes Knotenkonfigurationsobjekt kann die folgenden Felder enthalten:
```
{
"file_name" : "(path to a CSV file)",
"separator" : "(separator character)",
"node" : ["(column label for the node ID)", "(node type)"],
"features" : [(feature array)],
"labels" : [(label array)],
}
```
+ **`file_name`** – Eine Zeichenfolge, die den Pfad zu einer CSV-Datei angibt, in der Informationen zu Knoten mit derselben Eigenschaftsdiagramm-Bezeichnung gespeichert werden.
Die erste Zeile dieser Datei enthält eine Kopfzeile mit Spaltenbezeichnungen.
Die erste Spaltenbezeichnung ist `~id` und die erste Spalte (die Spalte `~id`) speichert die Knoten-ID.
Die verbleibenden Spaltenbezeichnungen in der Kopfzeile geben für jede verbleibende Spalte den Namen der Knoteneigenschaft an, deren Werte in diese Spalte exportiert wurden.
+ **`separator`** – Eine Zeichenfolge mit dem Trennzeichen, das die Spalten in dieser CSV-Datei trennt.
+ **`node`** – Ein JSON-Array mit zwei Zeichenfolgen. Die erste Zeichenfolge enthält den Header-Namen der Spalte, in der der Knoten gespeichert ist IDs. Die zweite Zeichenfolge gibt den Knotentyp im Diagramm an, der einer Eigenschaftsdiagrammbezeichnung des Knotens entspricht.
+ **`features`** – Ein JSON-Array mit Knoten-Feature-Objekten. Siehe [Inhalt eines Feature-Objekts, das in einem `features`-Array für einen Knoten oder eine Kante aufgelistet ist](#machine-learning-graph-node-features-config).
+ **`labels`** – Ein JSON-Array mit Knotenbezeichnungsobjekten. Siehe [Inhalt eines im `labels`-Knoten-Array aufgelisteten Knotenbezeichnungsobjekts](#machine-learning-graph-node-labels-config).
## Inhalt eines Feature-Objekts, das in einem `features`-Array für einen Knoten oder eine Kante aufgelistet ist
Ein in einem `features`-Array aufgelistetes Knoten-Feature-Objekt kann auf der obersten Ebene die folgenden Felder enthalten:
+ **`feature`** – Ein JSON-Array mit drei Zeichenfolgen. Die erste Zeichenfolge enthält den Kopfzeilennamen der Spalte, in der der Eigenschaftswert für das Feature gespeichert ist. Die zweite Zeichenfolge enthält den Feature-Namen.
Die dritte Zeichenfolge enthält den Feature-Typ. Gültige Feature-Typen werden in [Mögliche Werte des Typfeldes für Features](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-feature-types) aufgelistet.
+ **`norm`** – Dies ist ein Pflichtfeld für numerische Features. Es gibt die Normalisierungsmethode an, die für numerische Werte verwendet werden soll: Gültige Werte sind `"none"`, `"min-max"` und „Standard“. Details dazu finden Sie unter [Das Normfeld](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-norm).
+ **`language`** – Das Feld für die Sprache gibt die Sprache an, die in Texteigenschaftswerten verwendet wird. Die Nutzung ist von der Textkodierungsmethode abhängig:
+ Dieses Feld ist für die [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)-Kodierung erforderlich und es muss eine der folgenden Sprachen angegeben werden:
+ `en` (Englisch)
+ `zh` (Chinesisch)
+ `hi` (Hindi)
+ `es` (Spanisch)
+ `fr` (Französisch)
`text_fasttext` kann jedoch nicht mehr als eine Sprache gleichzeitig verarbeiten.
+ Dieses Feld wird für die [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)-Kodierung nicht verwendet, da die SBERT-Kodierung mehrsprachig ist.
+ Dieses Feld ist für die [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features)-Kodierung optional, da `text_word2vec` nur Englisch unterstützt. Wenn vorhanden, muss der Name des englischsprachigen Modells angegeben werden:
```
"language" : "en_core_web_lg"
```
+ Dieses Feld wird für die [`tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features)-Kodierung nicht verwendet.
+ **`max_length`** – Dieses Feld ist optional für [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)-Features. Es gibt die maximale Anzahl von Token in einem Eingabe-Text-Feature an, die kodiert werden. Text, der eingegeben wird, nachdem `max_length` erreicht wurde, wird ignoriert. Wenn Sie beispielsweise max\$1length auf 128 festlegen, werden alle Token in einer Textsequenz nach dem 128. Zeichen ignoriert.
+ **`separator`** – Dieses Feld wird optional mit den Features `category`, `numerical` und `auto` verwendet. Es gibt ein Zeichen an, das für die Aufteilung eines Eigenschaftswerts in mehrere kategorische oder numerische Werte verwendet werden kann:
Siehe [Das Trennfeld](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-separator).
+ **`range`** – Dies ist ein Pflichtfeld für `bucket_numerical`-Features. Es gibt den Bereich der numerischen Werte an, die in Buckets aufgeteilt werden sollen.
Siehe [Das Bereichsfeld](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-range).
+ **`bucket_cnt`** – Dies ist ein Pflichtfeld für `bucket_numerical`-Features. Es gibt die Anzahl der Buckets an, in die der numerische Bereich unterteilt werden soll, der durch den Parameter `range` definiert wird.
Siehe [Bucket-numerische Features in Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
+ **`slide_window_size`** – Dieses Feld wird optional mit `bucket_numerical`-Features verwendet, um mehr als einem Bucket Werte zuzuweisen.
Siehe [Das Feld slide\$1window\$1size](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-slide_window_size).
+ **`imputer`** – Dieses Feld wird optional mit `numerical`-, `bucket_numerical`- und `datetime`-Features verwendet, um eine Imputationstechnik zum Ausfüllen fehlender Werte bereitzustellen. Die unterstützten Imputationstechniken sind `"mean"`, `"median"` und `"most_frequent"`.
Siehe [Das Imputer-Feld](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-imputer).
+ **`max_features`** – Dieses Feld wird optional von `text_tfidf`-Features verwendet, um die maximale Anzahl der Begriffe anzugeben, die kodiert werden sollen:
Siehe [Das Feld max\$1features](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-max_features).
+ **`min_df`** – Dieses Feld wird optional von `text_tfidf`-Features verwendet, um die Mindesthäufigkeit von Begriffen anzugeben, die kodiert werden sollen:
Siehe [Das Feld min\$1df](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-min_df).
+ **`ngram_range`** – Dieses Feld wird optional von `text_tfidf`-Features verwendet, um den Bereich von Wörtern oder Token anzugeben, die als potenzielle einzelne Begriffe zur Kodierung betrachtet werden sollen.
Siehe [Das Feld ngram\$1range](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-ngram_range).
+ **`datetime_parts`** – Dieses Feld wird optional von `datetime`-Features verwendet, um anzugeben, welche Teile des datetime-Werts kategorisch kodiert werden sollen.
Siehe [Das Feld datetime\$1parts](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-datetime_parts).
## Inhalt eines im `labels`-Knoten-Array aufgelisteten Knotenbezeichnungsobjekts
Ein in einem `labels`-Knoten-Array aufgelistetes Bezeichnungsobjekt definiert ein Knotenziel-Feature und gibt die Proportionen der Knoten an, die in den Trainings-, Validierungs- und Testphasen verwendet werden. Jedes Objekt kann die folgenden Felder enthalten:
```
{
"label" : ["(column label for the target feature property value)", "(task type)"],
"split_rate" : [(training proportion), (validation proportion), (test proportion)],
"custom_split_filenames" : {"train": "(training file name)", "valid": "(validation file name)", "test": "(test file name)"},
"separator" : "(separator character for node-classification category values)",
}
```
+ **`label`** – Ein JSON-Array mit zwei Zeichenfolgen. Die erste Zeichenfolge enthält den Kopfzeilennamen der Spalte, in der die Eigenschaftswerte für das Feature gespeichert sind. Die zweite Zeichenfolge gibt den Zielaufgabentyp an, der Folgendes sein kann:
+ `"classification"` – Eine Aufgabe zur Knotenklassifizierung. Die Eigenschaftswerte in der angegebenen Spalte werden verwendet, um ein kategorisches Feature zu erstellen.
+ `"regression"` – Eine Aufgabe zur Knotenregression. Die Eigenschaftswerte in der angegebenen Spalte werden verwendet, um ein numerisches Feature zu erstellen.
+ **`split_rate`** – Ein JSON-Array mit drei Zahlen zwischen null und eins, die zusammen eins ergeben und eine Schätzung des Anteils der Knoten darstellen, die in der Trainings-, Validierungs- und Testphase jeweils verwendet werden. Siehe [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate).
+ **`custom_split_filenames`** – Ein JSON-Objekt, das die Dateinamen für die Dateien angibt, die die Trainings-, Validierungs- und Testpopulationen definieren. Sie können dieses Feld oder das Feld `split_rate` definieren, aber nicht beide. Weitere Informationen finden Sie unter [Benutzerdefinierte train-validation-test Proportionen](#machine-learning-custom-stages-splits).
+ **`separator`** – Eine Zeichenfolge, die das Trennzeichen enthält, das kategorische Feature-Werte für eine Klassifizierungsaufgabe trennt.
**Anmerkung**
Wenn kein Bezeichnungsobjekt sowohl für Kanten als auch für Knoten angegeben wird, wird automatisch angenommen, dass es sich bei der Aufgabe um eine Linkvorhersage handelt. Die Kanten werden randomisiert in 90 % zum Training und 10 % zur Validierung aufgeteilt.
## Benutzerdefinierte train-validation-test Proportionen
Standardmäßig wird der Parameter `split_rate` von Neptune ML verwendet, um das Diagramm anhand der im Parameter definierten Anteile randomisiert in Trainings-, Validierungs- und Testpopulationen aufzuteilen. Um eine genauere Kontrolle über die in diesen Populationen verwendeten Entitäten zu erhalten, können Dateien zu ihrer expliziten Definition erstellt werden. Anschließend [kann die Trainingsdaten-Konfigurationsdatei bearbeitet werden](machine-learning-processing-training-config-file.md), um diese indizierenden Dateien den Populationen zuzuordnen. Diese Zuordnung wird durch ein JSON-Objekt für den Schlüssel [`custom_split_filesnames`](#custom_split_filenames) in der Trainingskonfigurationsdatei spezifiziert. Wenn diese Option verwendet wird, müssen für die Schlüssel `train` und `validation` Dateinamen angegeben werden, optional auch für den Schlüssel `test`.
Die Formatierung dieser Dateien sollte dem [Gremlin-Datenformat](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-systemheaders) entsprechen. Insbesondere bei Aufgaben auf Knotenebene sollte jede Datei eine Spalte mit der `~id` Überschrift enthalten, in der der Knoten aufgeführt ist IDs, und bei Aufgaben auf Kantenebene sollten die Dateien die Quell `~from` - `~to` bzw. Zielknoten der Kanten spezifizieren und angeben. Diese Dateien müssen am selben Amazon-S3-Speicherort platziert werden wie die exportierten Daten, die für die Datenverarbeitung verwendet werden (siehe [`outputS3Path`](export-parameters.md#export-parameters-outputS3Path)).
Bei Aufgaben zur Klassifizierung oder Regression von Eigenschaften können diese Dateien optional die Bezeichnungen für die Machine-Learning-Aufgabe definieren. In diesem Fall müssen die Dateien eine Eigenschaftsspalte mit dem Kopfzeilennamen haben, der in der [Trainingsdaten-Konfigurationsdatei definiert](#machine-learning-graph-node-labels-config) ist. Wenn Eigenschaftsbezeichnungen sowohl in den exportierten Knoten- und Kantendateien als auch in den benutzerdefiniert aufgeteilten Dateien definiert sind, haben die benutzerdefiniert aufgeteilten Dateien Vorrang.
# Trainieren eines Modells mit Neptune ML
Nach der Verarbeitung der aus Neptune exportierten Daten für das Modelltraining können Sie einen Modelltrainingsauftrag mit einem `curl`-Befehl (oder `awscurl`-Befehl) wie dem folgenden starten:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
}'
```
Details zur Verwendung dieses Befehls werden in [Der Befehl modeltraining](machine-learning-api-modeltraining.md) beschrieben. Dort finden Sie auch Informationen dazu, wie Sie ausgeführte Aufträge abrufen und beenden und alle ausgeführten Aufträge auflisten.
Sie können auch eine `previousModelTrainingJobId` angeben, um mittels Informationen aus einem abgeschlossenen Neptune-ML-Modell-Trainingsauftrag die Hyperparametersuche in einem neuen Trainingsauftrag zu beschleunigen. Dies ist während [erneuter Modelltrainings anhand neuer Diagrammdaten](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-model-retraining) als auch während [inkrementeller Trainings anhand derselben Diagrammdaten](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) nützlich. Verwenden Sie einen Befehl wie diesen:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"previousModelTrainingJobId" : "(the model-training job-id of a completed job)"
}'
```
Sie können Ihre eigene Modellimplementierung in der Neptune-ML-Trainingsinfrastruktur trainieren, indem Sie ein `customModelTrainingParameters`-Objekt bereitstellen, z. B.:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"modelName": "custom",
"customModelTrainingParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"trainingEntryPointScript": "(your training script entry-point name in the Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
Weitere Informationen, z. B. zum Abrufen des Status eines ausgeführten Auftrags, zum Beenden eines ausgeführten Auftrags und zum Auflisten aller ausgeführten Aufträge, finden Sie unter [Der Befehl modeltraining](machine-learning-api-modeltraining.md). Informationen zur Implementierung eines benutzerdefinierten Modells finden Sie unter [Benutzerdefinierte Modelle in Neptune ML](machine-learning-custom-models.md).
**Topics**
+ [
# Modelle und Modelltraining in Amazon Neptune ML
](machine-learning-models-and-training.md)
+ [
# Anpassen von Modell-Hyperparameter-Konfigurationen in Neptune ML
](machine-learning-customizing-hyperparams.md)
+ [
# Bewährte Modelltrainingsmethoden
](machine-learning-improve-model-performance.md)
# Modelle und Modelltraining in Amazon Neptune ML
Neptune ML verwendet Graph Neural Networks (GNN), um Modelle für die verschiedenen Machine-Learning-Aufgaben zu erstellen. Es wurde gezeigt, dass neuronale Graphennetzwerke state-of-the-art Ergebnisse für Aufgaben des maschinellen Lernens mit Graphen erzielen und hervorragend darin sind, informative Muster aus graphstrukturierten Daten zu extrahieren.
## Neuronale Netzwerke (GNNs) in Neptune ML grafisch darstellen
Graph Neural Networks (GNNs) gehören zu einer Familie neuronaler Netze, die Knotenrepräsentationen berechnen, indem sie die Struktur und Merkmale nahegelegener Knoten berücksichtigen. GNNs ergänzen andere traditionelle Methoden des maschinellen Lernens und neuronaler Netzwerke, die für Graphdaten nicht gut geeignet sind.
GNNs werden verwendet, um Aufgaben des maschinellen Lernens wie Knotenklassifizierung und Regression (Vorhersage der Eigenschaften von Knoten) und Kantenklassifizierung und Regression (Vorhersage der Eigenschaften von Kanten) oder Linkvorhersage (Vorhersage, ob zwei Knoten im Graphen miteinander verbunden sein sollten oder nicht) zu lösen.
Im Allgemeinen umfasst die Verwendung eines GNN für eine Machine-Learning-Aufgabe zwei Phasen:
+ Eine Kodierungsphase, in der das GNN für jeden Knoten im Diagramm einen d-dimensionalen Vektor berechnet. Diese Vektoren werden auch *Repräsentationen* oder *Einbettungen* genannt.
+ Eine Dekodierungsphase, in der auf Grundlage der kodierten Repräsentationen Vorhersagen erstellt werden.
Bei der Klassifizierung und Regression von Knoten werden die Knotenrepräsentationen direkt für die Klassifizierungs- und Regressionsaufgaben verwendet. Bei der Klassifizierung und Regression von Kanten werden die Knotendarstellungen der Vorfallknoten an einer Kante als Eingabe für die Klassifizierung oder Regression verwendet. Für die Linkvorhersage wird anhand eines Paars von Knotenrepräsentationen und einer Kantentypdarstellung ein Kantenwahrscheinlichkeitswert berechnet.
Die [Deep Graph Library (DGL)](https://www.dgl.ai/) ermöglicht die effiziente Definition und Schulung dieser Aufgaben. GNNs
Verschiedene GNN-Modelle sind unter der Formulierung der Nachrichtenübergabe konsolidiert. In dieser Ansicht wird die Darstellung eines Knotens in einem Diagramm anhand der Darstellungen der Knotennachbarn (der Nachrichten) zusammen mit der ursprünglichen Darstellung des Knotens berechnet. In Neptune ML wird die ursprüngliche Darstellung eines Knotens von den Features abgeleitet, die aus dessen Eigenschaften extrahiert wurden. Sie kann auch erlernbar und von der Identität des Knotens abhängig sein.
Neptune ML ermöglicht auch die Verkettung von Knoten-Features und erlernbaren Knotendarstellungen, um als ursprüngliche Knotendarstellung verwendet zu werden.
Für die verschiedenen Aufgaben in Neptune ML, die Diagramme mit Knoteneigenschaften beinhalten, wird in der Kodierungsphase das [Relational Graph Convolutional Network](https://arxiv.org/abs/1703.06103) (R-GCN) verwendet. R-GCN ist eine GNN-Architektur, die gut für Diagramme mit mehreren Knoten- und Kantentypen geeignet ist (als heterogene Diagramme bezeichnet).
Das R-GCN-Netzwerk besteht aus einer festen Anzahl von Ebenen, die aufeinander gestapelt sind. Jede R-GCN-Ebene verwendet ihre erlernbaren Modellparameter, um Informationen aus der unmittelbaren 1-Hop-Nachbarschaft eines Knotens zu aggregieren. Da nachfolgende Ebenen die Ausgabedarstellungen der vorherigen Ebene als Eingabe verwenden, ist der Radius der Diagrammnachbarschaft, der die endgültige Einbettung eines Knotens beeinflusst, von der Anzahl der Ebenen (`num-layer`) des R-GCN-Netzwerks abhängig.
Das bedeutet beispielsweise, dass ein Netzwerk mit 2 Ebenen Informationen aus Knoten verwendet, die 2 Hops entfernt sind.
Weitere Informationen dazu finden Sie unter [Umfassender Überblick über GNNs neuronale Graphennetzwerke](https://arxiv.org/abs/1901.00596). Weitere Informationen zur Deep Graph Library (DGL) finden Sie auf der [DGL-Website](https://www.dgl.ai/). Ein praktisches Tutorial zur Verwendung von DGL mit GNNs finden Sie unter [Lernen neuronaler Graphennetze mit der Deep Graph Library](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library).
## Trainieren von Graph Neural Networks
Im Machine Learning wird der Vorgang, in dem ein Modell lernt, gute Vorhersagen für eine Aufgabe zu erstelen, als Modelltraining bezeichnet. Dies erfolgt in der Regel durch die Angabe eines Optimierungsziels und eines Algorithmus für die Ausführung dieser Optimierung.
Dieser Vorgang wird verwendet, um ein GNN für die Erstellung guter Darstellungen auch der nachgelagerten Aufgaben zu trainieren. Für diese Aufgabe wird eine Zielfunktion erstellt, die während des Modelltrainings minimiert wird. Für die Knotenklassifizierung verwenden [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html)wir beispielsweise das Ziel, wodurch Fehlklassifizierungen bestraft werden, und für die Knotenregression minimieren wir. [MeanSquareError](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html)
Das Ziel ist in der Regel eine Verlustfunktion, bei der die Modellvorhersagen für einen bestimmten Datenpunkt mit dem Grundwahrheitswert für diesen Datenpunkt verglichen werden. Sie gibt den Verlustwert zurück, der angibt, wie weit die Vorhersagen des Modells abweichen. Das Ziel des Trainings ist, den Verlust zu minimieren und sicherzustellen, dass Modellvorhersagen der Grundwahrheit nahe kommen.
Der Optimierungsalgorithmus, der beim Deep Learning für das Training verwendet wird, ist in der Regel eine Variante des Gradientenabstiegs. In Neptune ML wird [Adam](https://arxiv.org/pdf/1412.6980.pdf) verwendet, ein Algorithmus für die gradientenbasierte Optimierung erster Ordnung für stochastische Zielfunktionen, der auf adaptiven Schätzungen von Momenten niedrigerer Ordnung basiert.
Während das Modelltraining sicherstellen soll, dass die erlernten Modellparameter nahe bei den Mindestwerten der Zielfunktion liegen, ist die Gesamtleistung eines Modells auch von dessen *Hyperparametern* abhängig. Dies sind Modelleinstellungen, die nicht vom Trainingsalgorithmus erlernt werden. Beispielsweise ist die Dimensionalität der erlernten Knotendarstellung (`num-hidden`) ein Hyperparameter, der sich auf die Modellleistung auswirkt. Daher wird im Machine Learning in der Regel eine Hyperparameter-Optimierung (HPO) durchgeführt, um geeignete Hyperparameter auszuwählen.
Neptune ML verwendet einen SageMaker KI-Hyperparameter-Tuning-Job, um mehrere Instanzen von Modelltraining mit unterschiedlichen Hyperparameter-Konfigurationen zu starten, um zu versuchen, das beste Modell für eine Reihe von Hyperparameter-Einstellungen zu finden. Siehe [Anpassen von Modell-Hyperparameter-Konfigurationen in Neptune ML](machine-learning-customizing-hyperparams.md).
## Modelle zur Einbettung von Wissensdiagrammen in Neptune ML
Wissensgraphen (KGs) sind Graphen, die Informationen über verschiedene Entitäten (Knoten) und ihre Beziehungen (Kanten) kodieren. In Neptune ML werden standardmäßig Modelle zur Einbettung von Wissensdiagrammen für Linkvorhersagen verwendet, wenn ein Diagramm keine Knoteneigenschaften, sondern lediglich Beziehungen zu anderen Knoten enthält. Obwohl für diese Diagramme auch R-GCN-Modelle mit erlernbaren Einbettungen verwendet werden können, indem der Modelltyp als `"rgcn"` angegeben wird, sind Modelle zur Einbettung von Wissensdiagrammen einfacher und eine effektive Lösung für das Erlernen von Darstellungen für umfangreiche Wissensdiagramme.
Modelle zur Einbettung von Wissensdiagrammen werden in Aufgaben für die Linkvorhersage verwendet, um die Knoten oder Beziehungen vorherzusagen, die ein Tripel `(h, r, t)` bilden, wobei `h` der Quellknoten, `r` der Beziehungstyp und `t` der Zielknoten ist.
Die in Neptune ML implementierten Modelle zur Einbettung von Wissensdiagrammen sind `distmult`, `transE` und `rotatE`. Weitere Informationen zu Modellen zur Einbettung von Wissensdiagrammen finden Sie unter [DGL-KE](https://github.com/awslabs/dgl-ke).
## Trainieren benutzerdefinierter Modelle in Neptune ML
Mit Neptune ML können Sie für bestimmte Szenarien eigene benutzerdefinierte Modelle definieren und implementieren. Informationen zur Implementierung eines benutzerdefinierten Modells und zum Trainieren dieses Modells in der Neptune-ML-Infrastruktur finden Sie unter [Benutzerdefinierte Modelle in Neptune ML](machine-learning-custom-models.md).
# Anpassen von Modell-Hyperparameter-Konfigurationen in Neptune ML
Wenn Sie einen Neptune-ML-Modelltrainingsauftrag starten, verwendet Neptune ML automatisch die aus dem vorherigen [Datenverarbeitungsauftrag](machine-learning-on-graphs-processing.md) inferierten Informationen. Es verwendet die Informationen, um Hyperparameter-Konfigurationsbereiche zu generieren, die verwendet werden, um einen [SageMaker KI-Hyperparameter-Tuning-Job zu erstellen, um mehrere Modelle für Ihre Aufgabe](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html) zu trainieren. So müssen Sie keine lange Liste von Hyperparameterwerten für die Modelle angeben, mit denen trainiert werden soll. Stattdessen werden die Hyperparameterbereiche und Standardwerte des Modells auf Grundlage von Aufgabentyp, Diagrammtyp und Einstellungen des Optimierungsauftrags ausgewählt.
Sie können jedoch die Standard-Hyperparameterkonfiguration überschreiben und benutzerdefinierte Hyperparameter bereitstellen, indem Sie eine vom Datenverarbeitungsauftrag generierte JSON-Konfigurationsdatei ändern.
Mithilfe der Neptune-ML-API [modelTraining](machine-learning-api-modeltraining.md) können Sie mehrere Einstellungen für Hyperparameter-Optimierungsaufträge auf hoher Ebene wie `maxHPONumberOfTrainingJobs`, `maxHPOParallelTrainingJobs` und `trainingInstanceType` steuern. Zur genaueren Steuerung der Modellhyperparameter können Sie die Datei `model-HPO-configuration.json` ändern, die vom Datenverarbeitungsauftrag generiert wird. Die Datei wird an dem Amazon-S3-Speicherort gespeichert, den Sie für die Ausgabe von Verarbeitungsaufträgen angegeben haben.
Sie können die Datei herunterladen, zur Überschreibung der Standard-Hyperparameterkonfigurationen bearbeiten und wieder zum selben Amazon-S3-Speicherort hochladen. Ändern Sie den Namen der Datei nicht und befolgen Sie bei der Bearbeitung die folgenden Anweisungen.
Herunterladen der Datei von Amazon S3:
```
aws s3 cp \
s3://(bucket name)/(path to output folder)/model-HPO-configuration.json \
./
```
Wenn die Bearbeitung abgeschlossen ist, laden Sie die Datei wieder zum ursprünglichen Speicherort hoch:
```
aws s3 cp \
model-HPO-configuration.json \
s3://(bucket name)/(path to output folder)/model-HPO-configuration.json
```
## Struktur der Datei `model-HPO-configuration.json`
Die Datei `model-HPO-configuration.json` gibt das Modell an, das trainiert werden soll, den `task_type` für das Machine Learning sowie die Hyperparameter, die für die verschiedenen Modelltrainingsausführungen variabel oder fest sein sollten.
Die Hyperparameter werden verschiedenen Stufen zugeordnet, die die Priorität der Hyperparameter beim Aufruf des Hyperparameter-Optimierungsauftrags angeben:
+ Tier-1-Hyperparameter haben die höchste Priorität. Wenn Sie `maxHPONumberOfTrainingJobs` auf einen Wert unter 10 festlegen, werden nur Tier-1-Hyperparameter optimiert. Die übrigen Hyperparameter verwenden die Standardwerte.
+ Tier-2-Hyperparameter haben eine niedrigere Priorität. Wenn es also mehr als 10, aber insgesamt weniger als 50 Trainingsaufträge für einen Optimierungsjob gibt, werden sowohl Tier-1- als auch Tier-2-Hyperparameter optimiert.
+ Tier-3-Hyperparameter werden nur dann zusammen mit Tier-1- und Tier-2- optimiert, wenn es insgesamt mehr als 50 Trainingsaufträge gibt.
+ Und schließlich werden feste Hyperparameter überhaupt nicht optimiert und verwenden stets die Standardwerte.
### Beispiel für eine `model-HPO-configuration.json`-Datei
Das Folgende ist eine `model-HPO-configuration.json`-Beispieldatei:
```
{
"models": [
{
"model": "rgcn",
"task_type": "node_class",
"eval_metric": {
"metric": "acc"
},
"eval_frequency": {
"type": "evaluate_every_epoch",
"value": 1
},
"1-tier-param": [
{
"param": "num-hidden",
"range": [16, 128],
"type": "int",
"inc_strategy": "power2"
},
{
"param": "num-epochs",
"range": [3,30],
"inc_strategy": "linear",
"inc_val": 1,
"type": "int",
"node_strategy": "perM"
},
{
"param": "lr",
"range": [0.001,0.01],
"type": "float",
"inc_strategy": "log"
}
],
"2-tier-param": [
{
"param": "dropout",
"range": [0.0,0.5],
"inc_strategy": "linear",
"type": "float",
"default": 0.3
},
{
"param": "layer-norm",
"type": "bool",
"default": true
}
],
"3-tier-param": [
{
"param": "batch-size",
"range": [128, 4096],
"inc_strategy": "power2",
"type": "int",
"default": 1024
},
{
"param": "fanout",
"type": "int",
"options": [[10, 30],[15, 30], [15, 30]],
"default": [10, 15, 15]
},
{
"param": "num-layer",
"range": [1, 3],
"inc_strategy": "linear",
"inc_val": 1,
"type": "int",
"default": 2
},
{
"param": "num-bases",
"range": [0, 8],
"inc_strategy": "linear",
"inc_val": 2,
"type": "int",
"default": 0
}
],
"fixed-param": [
{
"param": "concat-node-embed",
"type": "bool",
"default": true
},
{
"param": "use-self-loop",
"type": "bool",
"default": true
},
{
"param": "low-mem",
"type": "bool",
"default": true
},
{
"param": "l2norm",
"type": "float",
"default": 0
}
]
}
]
}
```
### Elemente einer `model-HPO-configuration.json`-Datei
Die Datei enthält ein JSON-Objekt mit einem einzigen Array auf oberster Ebene mit dem Namen `models` und einem einzigen Modellkonfigurationsobjekt. Achten Sie beim Anpassen der Datei darauf, dass das `models`-Array nur ein einziges Modellkonfigurationsobjekt enthält. Wenn Ihre Datei mehr als ein Modellkonfigurationsobjekt enthält, schlägt der Optimierungsauftrag mit einer Warnung fehl.
Das Modellkonfigurationsobjekt enthält auf der obersten Ebene die folgenden Elemente:
+ **`model`** – (*Zeichenfolge*) Der Modelltyp, der trainiert werden soll (**nicht ändern**). Gültige Werte sind:
+ `"rgcn"` – Dies ist die Standardeinstellung für Aufgaben zur Klassifizierung und Regression von Knoten sowie heterogene Linkvorhersageaufgaben.
+ `"transe"` – Dies ist die Standardeinstellung für KGE-Linkvorhersageaufgaben.
+ `"distmult"` – Dies ist ein alternativer Modelltyp für KGE-Linkvorhersageaufgaben.
+ `"rotate"` – Dies ist ein alternativer Modelltyp für KGE-Linkvorhersageaufgaben.
Sie sollten den `model`-Wert nicht direkt ändern, da für verschiedene Modelltypen häufig sehr unterschiedliche Hyperparameter gelten, was nach dem Start des Trainingsauftrags zu Analysefehlern führen kann.
Um den Modelltyp zu ändern, verwenden Sie den Parameter `modelName` in der [modelTraining-API](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job), statt den Modelltyp in der `model-HPO-configuration.json`-Datei zu ändern.
Sie können den Modelltyp ändern und detaillierte Änderungen für die Hyperparameter ausführen, indem Sie die Modellkonfigurations-Standardvorlage des Modells kopieren, das Sie verwenden möchten, und in die `model-HPO-configuration.json`-Datei einfügen. Wenn der inferierte Aufgabentyp mehrere Modelle unterstützt, befindet sich am Amazon-S3-Speicherort der Datei `model-HPO-configuration.json` ein Ordner namens `hpo-configuration-templates`. Dieser Ordner enthält alle Standard-Hyperparameter-Konfigurationen für die übrigen Modelle für die Aufgabe.
Wenn Sie beispielsweise die Modell- und Hyperparameterkonfigurationen für eine `KGE`-Linkvorhersageaufgabe vom `transe`-Standardmodell in ein `distmult`-Modell ändern möchten, fügen Sie einfach den Inhalt der Datei `hpo-configuration-templates/distmult.json` in die Datei `model-HPO-configuration.json` und bearbeiten dann die Hyperparameter wie notwendig.
**Anmerkung**
Wenn Sie den Parameter `modelName` in der `modelTraining`-API festlegen sowie `model` und die Hyperparameterspezifikation in der Datei `model-HPO-configuration.json` ändern und sich diese unterscheiden, hat der Wert für `model` in der Datei `model-HPO-configuration.json` Priorität und der Wert für `modelName` wird ignoriert.
+ **`task_type`** – (*Zeichenfolge*) Der Machine-Learning-Aufgabentyp, der vom Datenverarbeitungsauftrag inferiert oder direkt an den Datenverarbeitungsauftrag übergeben wird (**nicht ändern**). Folgende sind gültige Werte:
+ `"node_class"`
+ `"node_regression"`
+ `"link_prediction"`
Der Datenverarbeitungsauftrag inferiert den Aufgabentyp durch die Untersuchung des exportierten Datensatzes und der generierten Trainingsauftrags-Konfigurationsdatei auf Eigenschaften des Datensatzes.
Dieser Wert sollte nicht geändert werden. Wenn Sie eine andere Aufgabe trainieren möchten, müssen Sie einen [neuen Datenverarbeitungsauftrag ausführen](machine-learning-on-graphs-processing.md). Wenn der Wert für `task_type` nicht wie erwartet ist, sollten Sie die Eingaben für den Datenverarbeitungsauftrag überprüfen, um sicherzustellen, dass sie korrekt sind. Dies umfasst die Parameter für die `modelTraining`-API sowie in der durch den Datenexportvorgang generierten Trainingsauftrags-Konfigurationsdatei.
+ **`eval_metric`** – (*Zeichenfolge*) Die Auswertungsmetrik sollte zur Auswertung der Modellleistung und zur Auswahl des Modells mit der besten Leistung für alle HPO-Ausführungen verwendet werden. Folgende sind gültige Werte:
+ `"acc"` – Genauigkeit der Standardklassifizierung. Dies ist die Standardeinstellung für Klassifizierungsaufgaben mit einer einzigen Bezeichnung, wenn während der Datenverarbeitung keine unausgewogenen Bezeichnungen gefunden werden. In diesem Fall ist die Standardeinstellung `"F1"`.
+ `"acc_topk"` – Die Häufigkeit, mit der sich die richtige Bezeichnung unter den Top-Vorhersagen für **`k`** befindet. Sie können den Wert für **`k`** auch festlegen, indem Sie `topk` als zusätzlichen Schlüssel übergeben.
+ `"F1"` – Das [F1-Ergebnis](https://en.wikipedia.org/wiki/F-score).
+ `"mse"` – [Mean-Squared-Fehler-Metrik](https://en.wikipedia.org/wiki/Mean_squared_error) für Regressionsaufgaben.
+ `"mrr"` – [Mean-Reciprocal-Rang-Metrik](https://en.wikipedia.org/wiki/Mean_reciprocal_rank).
+ `"precision"` – Die Modellpräzision, berechnet als Verhältnis der echten positiven Ergebnisse zu den vorhergesagten positiven Ergebnissen: `= true-positives / (true-positives + false-positives)`.
+ `"recall"` – Die Modellsensitivität, berechnet als Verhältnis der echten positiven Ergebnisse zu den tatsächlichen Ergebnissen: `= true-positives / (true-positives + false-negatives)`.
+ `"roc_auc"` – Die Fläche unter der [ROC-Kurve](https://en.wikipedia.org/wiki/Receiver_operating_characteristic). Dies ist die Standardeinstellung für Klassifizierungen mit mehreren Bezeichnungen.
Um die Metrik beispielsweise in `F1` zu ändern, ändern Sie den Wert für `eval_metric` wie folgt:
```
" eval_metric": {
"metric": "F1",
},
```
Um die Metrik in eine `topk`-Präzisionsbewertung zu ändern, würden Sie `eval_metric` wie folgt ändern:
```
"eval_metric": {
"metric": "acc_topk",
"topk": 2
},
```
+ **`eval_frequency`** – (*Objekt*) Gibt an, wie häufig die Leistung des Modells im Validierungssatz während des Trainings überprüft werden soll. Auf Grundlage der Validierungsleistung kann dann ein vorzeitiger Stopp eingeleitet und das beste Modell gespeichert werden.
Das `eval_frequency`-Objekt enthält zwei Elemente, `"type"` und `"value"`. Beispiel:
```
"eval_frequency": {
"type": "evaluate_every_pct",
"value": 0.1
},
```
Gültige Werte für `type` sind:
+ **`evaluate_every_pct`** – Gibt den Prozentsatz der Trainings an, die für jede Auswertung abgeschlossen werden müssen.
Für `evaluate_every_pct` enthält das Feld `"value"` eine Gleitkommazahl zwischen null und eins, die diesen Prozentsatz ausdrückt.
+ **`evaluate_every_batch`** – Gibt die Anzahl der Trainings-Batches an, die für jede Auswertung abgeschlossen werden müssen.
Für `"value"` enthält das Feld `evaluate_every_batch` eine Ganzzahl, die diese Batch-Anzahl ausdrückt.
+ **`evaluate_every_epoch`** – Gibt die Anzahl der Epochen pro Auswertung an, wobei eine neue Epoche stets um Mitternacht beginnt.
Für `evaluate_every_epoch` enthält das Feld `"value"` eine Ganzzahl, die diese Epochen-Anzahl ausdrückt.
Die Standardeinstellung für `eval_frequency` ist:
```
"eval_frequency": {
"type": "evaluate_every_epoch",
"value": 1
},
```
+ **`1-tier-param`** – (*Erforderlich*) Ein Array von Tier-1-Hyperparametern.
Wenn Sie keine Hyperparameter optimieren möchten, können Sie diesen Wert auf ein leeres Array festlegen. Dies hat keinen Einfluss auf die Gesamtzahl der Trainingsjobs, die durch den SageMaker KI-Hyperparameter-Tuning-Job gestartet wurden. Es bedeutet lediglich, dass alle Trainingsaufträge mit dem gleichen Satz von Hyperparametern ausgeführt werden, wenn es mehr als 1, aber weniger als 10 gibt.
Wenn Sie andererseits alle optimierbaren Hyperparameter mit gleicher Bedeutung behandeln möchten, können Sie alle Hyperparameter in dieses Array einfügen.
+ **`2-tier-param`** – (*Erforderlich*) Ein Array von Tier-2-Hyperparametern.
Diese Parameter werden nur optimiert, wenn der Wert für `maxHPONumberOfTrainingJobs` größer als 10 ist. Andernfalls werden die Standardwerte verwendet.
Wenn Sie über ein Trainingsbudget von maximal 10 Trainingsaufträgen verfügen oder aus einem anderen Grund keine Tier-2-Hyperparameter verwenden möchten, jedoch alle optimierbaren Hyperparameter optimieren möchten, können Sie diesen Wert auf ein leeres Array festlegen.
+ **`3-tier-param`** – (*Erforderlich*) Ein Array von Tier-3-Hyperparametern.
Diese Parameter werden nur optimiert, wenn der Wert für `maxHPONumberOfTrainingJobs` größer als 50 ist. Andernfalls werden die Standardwerte verwendet.
Wenn Sie keine Tier-3-Hyperparameter optimieren möchten, können Sie diesen Wert auf ein leeres Array festlegen.
+ **`fixed-param`** – (*Erforderlich*) Ein Array von festen Hyperparametern, die nur die Standardwerte annehmen und sich in unterschiedlichen Trainingsaufträgen nicht unterscheiden.
Wenn alle Hyperparameter variabel sein sollen, können Sie diesen Wert auf ein leeres Array festlegen und entweder den Wert für `maxHPONumberOfTrainingJobs` groß genug festlegen, um alle Stufen variabel zu machen, oder alle Hyperparameter auf Tier-1 festlegen.
Das JSON-Objekt, das jeden Hyperparameter in `1-tier-param`, `2-tier-param`, `3-tier-param` und `fixed-param` darstellt, enthält die folgenden Elemente:
+ **`param`** – (*Zeichenfolge*) Der Name des Hyperparameters (**nicht ändern**).
Siehe die [Liste der gültigen Hyperparameternamen in Neptune ML](#machine-learning-hyperparams-list).
+ **`type`** – (*Zeichenfolge*) Der Typ des Hyperparameters (**nicht ändern**).
Gültige Typen sind `bool`, `float` und `int`.
+ **`default`** – (*Zeichenfolge*) Der Standardwert für den Hyperparameter.
Sie können einen neuen Standardwert festlegen.
Optimierbare Hyperparameter können auch die folgenden Elemente enthalten:
+ **`range`** – (*Array*) Der Bereich für einen kontinuierlichen optimierbaren Hyperparameter.
Dies sollte ein Array mit zwei Werten sein, dem Minimum und dem Maximum für den Bereich (`[min, max]`).
+ **`options`** – (*Array*) Die Optionen für einen kategorischen optimierbaren Hyperparameter.
Dieses Array sollte alle relevanten Optionen enthalten:
```
"options" : [value1, value2, ... valuen]
```
+ **`inc_strategy`** – (*Zeichenfolge*) Der Typ der inkrementellen Änderung für kontinuierliche optimierbare Hyperparameterbereiche (**nicht ändern**).
Gültige Werte sind `log`, `linear` und `power2`. Gilt nur, wenn der Bereichsschlüssel festgelegt ist.
Wenn Sie dies ändern, wird möglicherweise nicht der gesamte Bereich des Hyperparameters für die Optimierung verwendet.
+ **`inc_val`** – (*Gleitkommazahl*) Der Betrag, um den sich aufeinanderfolgende Inkremente für kontinuierliche optimierbare Hyperparameter unterscheiden (**nicht ändern**).
Gilt nur, wenn der Bereichsschlüssel festgelegt ist.
Wenn Sie dies ändern, wird möglicherweise nicht der gesamte Bereich des Hyperparameters für die Optimierung verwendet.
+ **`node_strategy`** – (*Zeichenfolge*) Gibt an, dass sich der effektive Bereich für diesen Hyperparameter abhängig von der Anzahl der Knoten im Diagramm ändern soll (**nicht ändern**).
Gültige Werte sind `"perM"` (pro Million), `"per10M"` (pro 10 Millionen) und `"per100M"` (pro 100 Millionen).
Ändern Sie den Wert für `range`, statt diesen Wert zu ändern.
+ **`edge_strategy`** – (*Zeichenfolge*) Gibt an, dass sich der effektive Bereich für diesen Hyperparameter abhängig von der Anzahl der Kanten im Diagramm ändern soll (**nicht ändern**).
Gültige Werte sind `"perM"` (pro Million), `"per10M"` (pro 10 Millionen) und `"per100M"` (pro 100 Millionen).
Ändern Sie den Wert für `range`, statt diesen Wert zu ändern.
### Liste aller Hyperparameter in Neptune ML
Die folgende Liste enthält alle Hyperparameter, die in Neptune ML festgelegt werden können, für jeden Modelltyp und jede Aufgabe. Da diese Hyperparameter nicht auf alle Modelltype anwendbar sind, ist es wichtig, dass Sie in der Datei `model-HPO-configuration.json` nur die Hyperparameter festlegen, die in der Vorlage für das von Ihnen verwendete Modell enthalten sind.
+ **`batch-size`** – Die Größe des Zielknoten-Batches, der in einem einzigen Vorwärtspass verwendet wird. *Typ*: `int`.
Wenn Sie dies auf einen sehr viel größeren Wert festlegen, kann es zu Arbeitsspeicherproblemen beim Trainieren auf GPU-Instances kommen.
+ **`concat-node-embed`** – Gibt an, ob die ursprüngliche Darstellung eines Knotens durch die Verkettung der verarbeiteten Features mit erlernbaren ursprünglichen Knoteneinbettungen erstellt werden soll, um die Aussagekraft des Modells zu erhöhen. *Typ*: `bool`.
+ **`dropout`** – Die Dropout-Wahrscheinlichkeit, die auf Dropout-Ebenen angewendet wird. *Typ*: `float`.
+ **`edge-num-hidden`** – Die Größe der ausgeblendeten Ebene oder die Anzahl der Einheiten für das Kanten-Feature-Modul. Wird nur verwendet, wenn `use-edge-features` auf `True` festgelegt ist. *Typ*: Gleitkommazahl
+ **`enable-early-stop`** – Legt fest, ob das Feature für vorzeitiges Stoppen verwendet werden soll oder nicht. *Typ*: `bool`. *Standardwert*: `true`.
Mit diesem booleschen Parameter können Sie das Feature für vorzeitiges Stoppen deaktivieren.
+ **`fanout`** – Die Anzahl der Nachbarn, die für einen Zielknoten während der Probenahme von Nachbarn untersucht werden sollen. *Typ*: `int`.
Dieser Wert ist eng mit `num-layers` verbunden und sollte sich stets auf derselben Hyperparameter-Ebene befinden. Das liegt daran, dass Sie für jede potenzielle GNN-Ebene einen Fanout angeben können.
Da dieser Hyperparameter zu einer stark schwankenden Modellleistung führen kann, sollte er fest sein oder als Tier-2- oder Tier-3-Hyperparameter festgelegt werden. Wenn Sie dies auf einen großen Wert festlegen, kann es zu Arbeitsspeicherproblemen beim Trainieren auf GPU-Instances kommen.
+ **`gamma`** – Der Margenwert in der Bewertungsfunktion. *Typ*: `float`.
Dies gilt nur für `KGE`-Modelle für die Linkvorhersage.
+ **`l2norm`** – Der im Optimierer verwendete Weight-Decay-Wert, der den Gewichtungen eine L2-Normalisierungssanktion auferlegt. *Typ*: `bool`.
+ **`layer-norm`** – Gibt an, ob die Ebenennormalisierung für `rgcn`-Modelle verwendet werden soll. *Typ*: `bool`.
+ **`low-mem`** – Gibt an, ob auf Kosten der Geschwindigkeit eine Implementierung der Beziehungsnachrichten-Übergabefunktion mit wenig Arbeitsspeicher verwendet werden soll. *Typ*: `bool`.
+ **`lr`** – Die Lernrate. *Typ*: `float`.
Dies sollte als Tier-1-Hyperparameter festgelegt werden.
+ **`neg-share`** – Gibt bei Linkvorhersagen an, ob Kanten mit positiven Proben auch negative Kantenproben teilen können. *Typ*: `bool`.
+ **`num-bases`** – Die Anzahl der Basen für die Basiszerlegung in einem `rgcn`-Modell. Ein Wert für `num-bases`, der kleiner als die Anzahl der Kantentypen im Diagramm ist, dient zur Regularisierung des `rgcn`-Modells. *Typ*: `int`.
+ **`num-epochs`** – Die Anzahl der Trainingsepochen, die ausgeführt werden sollen. *Typ*: `int`.
Eine Epoche ist ein vollständiger Trainingsdurchgang durch das Diagramm.
+ **`num-hidden`** – Die Größe der ausgeblendeten Ebene oder die Anzahl der Einheiten. *Typ*: `int`.
Dies legt auch die anfängliche Einbettungsgröße für Knoten ohne Features fest.
Wenn Sie diesen Wert auf einen viel höheren Wert setzen, ohne ihn zu reduzieren, `batch-size` kann dies zu out-of-memory Problemen beim Training auf der GPU-Instanz führen.
+ **`num-layer`** – Die Anzahl der GNN-Ebenen im Modell. *Typ*: `int`.
Dieser Wert ist eng mit dem Fanout-Parameter verbunden und sollte sich auf derselben Hyperparameter-Ebene wie der Fanout-Parameter befinden.
Da dies zu einer stark schwankenden Modellleistung führen kann, sollte der Wert fest sein oder als Tier-2- oder Tier-3-Hyperparameter festgelegt werden.
+ **`num-negs`** – Bei Linkvorhersagen ist dies die Anzahl der negativen Proben pro positiver Probe. *Typ*: `int`.
+ **`per-feat-name-embed`** – Gibt an, ob jedes Feature eingebettet werden soll, indem es unabhängig transformiert wird, bevor Features kombiniert werden. *Typ*: `bool`.
Bei Festlegung auf `true` wird jedes Feature pro Knoten unabhängig in eine feste Dimensionsgröße transformiert, bevor alle transformierten Features für den Knoten verkettet und weiter in die Dimension `num_hidden` transformiert werden.
Bei Festlegung auf `false` werden die Features ohne Feature-spezifische Transformationen verkettet.
+ **`regularization-coef`** – Bei Linkvorhersagen ist dies der Koeffizient des Regularisierungsverlusts. *Typ*: `float`.
+ **`rel-part`** – Gibt an, ob für `KGE`-Linkvorhersagen Beziehungspartitionen verwendet werden sollen. *Typ*: `bool`.
+ **`sparse-lr`** – Die Lernrate für Einbettungen erlernbarer Knoten. *Typ*: `float`.
Erlernbare anfängliche Knoteneinbettungen werden für Knoten ohne Features oder bei Festlegung von `concat-node-embed` verwendet. Die Parameter der Sparse-Einbettungsebene für erlernbare Knoten werden mithilfe eines getrennten Optimierers trainiert, der eine eigene Lernrate haben kann.
+ **`use-class-weight`** – Gibt an, ob auf unausgewogene Klassifizierungsaufgaben Klassengewichtungen angewendet werden sollen. Bei Festlegung auf `true`, werden die Bezeichnungszahlen verwendet, um für jede Klassenbezeichnung eine Gewichtung festzulegen. *Typ*: `bool`.
+ **`use-edge-features`** – Gibt an, ob während der Nachrichtenübergabe Kanten-Features verwendet werden sollen. Bei Festlegung auf `true` wird der RGCN-Ebene ein benutzerdefiniertes Kanten-Feature-Modul für Kantentypen mit Features hinzugefügt. *Typ*: `bool`.
+ **`use-self-loop`** – Gibt an, ob Selbstschleifen in das Training eines `rgcn`-Modells einbezogen werden sollen. *Typ*: `bool`.
+ **`window-for-early-stop`** – Vergleicht die Anzahl der letzten Validierungsergebnisse mit dem Durchschnitt, um über einen vorzeitigen Stopp zu entscheiden. Der Standardtyp ist 3. type=int. Siehe auch [Vorzeitiges Stoppen des Modelltrainings in Neptune ML](machine-learning-improve-model-performance.md#machine-learning-model-training-early-stop). *Typ*: `int`. *Standardwert*: `3`.
Siehe .
## Anpassen von Hyperparametern in Neptune ML
Wenn Sie die Datei `model-HPO-configuration.json` bearbeiten, sind dies die häufigsten Arten von Änderungen:
+ Bearbeiten Sie die Mindest- und and/or Höchstwerte der `range` Hyperparameter.
+ Legen Sie einen Hyperparameter auf einen festen Wert fest, indem Sie ihn zum Abschnitt `fixed-param` verschieben und den Standardwert auf den festen Wert festlegen, den er annehmen soll.
+ Ändern Sie die Priorität eines Hyperparameters, indem Sie ihn in einer bestimmten Ebene platzieren, den Bereich bearbeiten und sicherstellen, dass der Standardwert korrekt festgelegt ist.
# Bewährte Modelltrainingsmethoden
Sie können die Leistung von Neptune ML-Modellen auf verschiedene Arten verbessern.
## Auswahl der richtigen Knoteneigenschaft
Möglicherweise sind nicht alle Eigenschaften im Diagramm für Ihre Machine-Learning-Aufgaben sinnvoll oder relevant. Irrelevante Eigenschaften sollten vom Datenexport ausgeschlossen werden.
Dies sind einige bewährte Methoden:
+ Lassen Sie sich von Fachexperten helfen, die Bedeutung von Features und die Möglichkeit ihrer Verwendung für Vorhersagen zu bewerten.
+ Entfernen Sie die Features, die Sie als überflüssig oder irrelevant betrachten, um das Datenrauschen und die Zahl der nicht wichtigen Korrelationen zu reduzieren.
+ Führen Sie während der Erstellung des Modells Iterationen durch. Passen Sie Features, Feature-Kombinationen und Optimierungsziele über die Zeit an.
im Abschnitt [Feature-Verarbeitung](https://docs.aws.amazon.com/machine-learning/latest/dg/feature-processing.html) im Amazon-Machine-Learning-Entwicklerhandbuch enthält weitere Anleitungen für die Feature-Verarbeitung, die für Neptune ML relevant sind.
## Behandlung von Ausreißer-Datenpunkten
Ein Ausreißer ist ein Datenpunkt, der sich erheblich von den übrigen Daten unterscheidet. Datenausreißer können den Trainingsvorgang korrumpieren oder fehlleiten, was zu längeren Trainingszeiten oder weniger genauen Modellen führt. Wenn sie nicht wirklich wichtig sind, sollten Sie Ausreißer vor dem Exportieren der Daten entfernen.
## Entfernen duplizierter Knoten und Kanten
In Neptune gespeicherte Diagramme können duplizierte Knoten oder Kanten enthalten. Diese redundanten Elemente führen beim Trainieren für ML-Modelle zu Rauschen. Entfernen Sie duplizierte Knoten oder Kanten, bevor Sie die Daten exportieren.
## Optimieren der Diagrammstruktur
Wenn das Diagramm exportiert wird, können Sie die Verarbeitung von Features und die Konstruktion des Diagramms ändern, um die Modellleistung zu verbessern.
Dies sind einige bewährte Methoden:
+ Wenn eine Kanteneigenschaft die Bedeutung von Kantenkategorien hat, lohnt es sich in einigen Fällen, sie in Kantentypen zu konvertieren.
+ Die Standard-Normalisierungsrichtlinie für eine numerische Eigenschaft ist `min-max`. In einigen Fällen funktionieren andere Normalisierungsrichtlinien jedoch besser. Sie können die Eigenschaft vorab verarbeiten und die Normalisierungsrichtlinie wie in [Elemente einer `model-HPO-configuration.json`-Datei](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements) beschrieben.
+ Beim Exportvorgang werden automatisch Feature-Typen basierend auf Eigenschaftstypen generiert. Beispielsweise werden `String`-Eigenschaften als kategorische Features und `Float`- und `Int`-Eigenschaften als numerische Features behandelt. Wenn notwendig, können Sie den Feature-Typ nach dem Export ändern (siehe [Elemente einer `model-HPO-configuration.json`-Datei](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements)).
## Optimieren von Hyperparameter-Bereichen und -Standardwerten
Die Datenverarbeitungsoperation leitet Hyperparameter-Konfigurationsbereiche aus dem Diagramm ab. Wenn die generierten Hyperparameterbereiche und Standardwerte des Modells für Ihre Diagrammdaten nicht gut funktionieren, können Sie die HPO-Konfigurationsdatei bearbeiten, um Ihre eigene Hyperparameter-Optimierungsstrategie zu erstellen.
Dies sind einige bewährte Methoden:
+ Wenn das Diagramm groß wird, reicht die Standardgröße ausgeblendeter Dimensionen möglicherweise nicht aus, um alle Informationen aufzunehmen. Sie können den Hyperparameter `num-hidden` ändern, um die Größe ausgeblendeter Dimensionen zu steuern.
+ Bei Knowledge Graph Embedding (KGE)-Modellen sollten Sie vielleicht das spezifische verwendete Modell auf der Basis von Diagrammstruktur und Budget ändern.
`TrainsE`Modelle haben Schwierigkeiten, mit one-to-many (1-N), many-to-one (N-1) und many-to-many (N-N) Beziehungen umzugehen. `DistMult`Modelle haben Schwierigkeiten, mit symmetrischen Beziehungen umzugehen. `RotatE`ist gut darin, alle Arten von Beziehungen zu modellieren, ist aber teurer als `TrainsE` und `DistMult` während des Trainings.
+ In einigen Fällen, in denen sowohl die Knoten-ID als auch Informationen zu Knoten-Features wichtig sind, sollten Sie das Neptune-ML-Modell mit ``concat-node-embed`` anweisen, die anfängliche Darstellung eines Knotens durch die Verkettung seiner Features mit den anfänglichen Einbettungen abzurufen.
+ Wenn Sie für einige Hyperparameter eine angemessene Leistung erzielen, können Sie die Hyperparameter-Suchumgebung entsprechend diesen Ergebnissen anpassen.
## Vorzeitiges Stoppen des Modelltrainings in Neptune ML
Ein vorzeitiger Stopp kann die Ausführungszeit und die Kosten für das Modelltraining deutlich reduzieren, ohne die Modellleistung zu beeinträchtigen. Dies verhindert auch, dass sich das Modell zu stark an die Trainingsdaten anpasst.
Ein vorzeitiger Abbruch ist von regelmäßigen Messungen der Validierungssatzleistung abhängig. Zunächst wird die Leistung mit fortschreitendem Training besser. Wenn sich das Modell jedoch zu stark anpasst, nimmt sie wieder ab. Das Feature für vorzeitige Stopps identifiziert den Punkt, ab dem sich ein Modell zu sehr anpasst, und stoppt das Modelltraining an diesem Punkt.
Neptune ML überwacht die Validierungsmetrikaufrufe und vergleicht die neueste Validierungsmetrik mit dem Durchschnitt der Validierungsmetriken der letzten **`n`** Auswertungen, wobei **`n`** ein Zahlensatz ist, der den Parameter `window-for-early-stop` verwendet. Sobald die Validierungsmetrik schlechter als dieser Durchschnitt ist, stoppt Neptune ML das Modelltraining und speichert das bisher beste Modell.
Sie können das vorzeitige Stoppen wie folgt mit den folgenden Parametern steuern:
+ **`window-for-early-stop`** – Der Wert dieses Parameters ist eine Ganzzahl und gibt die Zahl der letzten Validierungsergebnisse an, die für die Berechnung des Durchschnitts verwendet werden sollen, um über einen vorzeitigen Stopp zu entscheiden. Der Standardwert ist `3`.
+ **`enable-early-stop`** – Mit diesem booleschen Parameter können Sie das Feature für vorzeitiges Stoppen deaktivieren. Der Standardwert ist `true`.
## Vorzeitiges Stoppen des HPO-Vorgangs in Neptune ML
Die Early-Stop-Funktion in Neptune ML stoppt mithilfe der SageMaker AI HPO-Warmstartfunktion auch Trainingsjobs, die im Vergleich zu anderen Trainingsjobs nicht gut abschneiden. Auch dies kann die Kosten senken und die HPO-Qualität verbessern.
In [Ausführen eines Warmstart-Optimierungsaufgabe für Hyperparameter](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-warm-start.html) finden Sie eine Beschreibung der Funktionsweise.
Der Warmstart ermöglicht die Übergabe von Informationen aus früheren Trainingsaufträgen an nachfolgende Trainingsaufträge und hat zwei entscheidende Vorteile:
+ Erstens werden die Ergebnisse vorheriger Trainingsaufträge für die Auswahl guter Kombinationen von Hyperparametern verwendet, um sie im neuen Optimierungsauftrag zu durchsuchen.
+ Zweitens ermöglicht der Warmstart vorzeitige Stopps, um auf weitere Modellausführungen zugreifen zu können, was die Optimierungszeit reduziert.
Dieses Feature ist in Neptune ML automatisch aktiviert und ermöglicht Ihnen, ein Gleichgewicht zwischen Trainingszeit und Leistung herzustellen. Wenn Sie mit der Leistung des aktuellen Modells zufrieden sind, können Sie dieses Modell verwenden. Andernfalls laufen Sie mehr, HPOs die mit den Ergebnissen früherer Läufe warmgestartet wurden, um ein besseres Modell zu finden.
## Professionelle Support-Services
AWS bietet professionelle Support-Services, um Ihnen bei Problemen bei Ihren Projekten im Bereich maschinelles Lernen auf Neptune zu helfen. Wenn Sie nicht weiterkommen, nehmen Sie bitte Kontakt mit dem [AWS -Support](https://aws.amazon.com/premiumsupport/) auf.
# Verwenden trainierter Modelle zur Generierung neuer Modellartefakte
Mit dem Neptune-ML-Befehl für die Modelltransformation können Sie mit vorab trainierten Modellparametern Modellartefakte wie Knoteneinbettungen für verarbeitete Diagrammdaten berechnen.
## Modelltransformation für inkrementelle Inferenzen
Nach der Verarbeitung der aktualisierten Diagrammdaten, die Sie aus Neptune exportiert haben, können Sie im [Workflow für inkrementelle Modellinferenzen](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) einen Modelltransformationsauftrag mit einem curl- (oder awscurl)-Befehl wie dem folgenden starten:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"mlModelTrainingJobId": "(the ML model training job-id)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/"
}'
```
Anschließend können Sie die ID dieses Auftrags an den API-Aufruf create-endpoints übergeben, um einen neuen Endpunkt zu erstellen oder einen vorhandenen Endpunkt mit den neuen Modellartefakten zu aktualisieren, die von diesem Auftrag generiert wurden. So kann der neue oder aktualisierte Endpunkt Modellvorhersagen für die aktualisierten Diagrammdaten bereitstellen.
## Modelltransformation für Trainingsaufträge
Sie können auch einen `trainingJobName` Parameter angeben, um Modellartefakte für alle SageMaker KI-Trainingsjobs zu generieren, die während des Neptune ML-Modelltrainings gestartet wurden. Da ein Trainingsjob im Neptune-ML-Modell potenziell viele SageMaker KI-Schulungsjobs starten kann, haben Sie die Flexibilität, einen Inferenzendpunkt zu erstellen, der auf einem dieser SageMaker KI-Schulungsjobs basiert.
Zum Beispiel:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"trainingJobName" : "(name a completed SageMaker AI training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/"
}'
```
Wenn der ursprüngliche Trainingsauftrag für ein vom Benutzer bereitgestelltes benutzerdefiniertes Modell bestimmt war, müssen Sie beim Aufrufen einer Modelltransformation ein `customModelTransformParameters`-Objekt einfügen. Informationen zur Implementierung eines benutzerdefinierten Modells finden Sie unter [Benutzerdefinierte Modelle in Neptune ML](machine-learning-custom-models.md).
**Anmerkung**
Der `modeltransform` Befehl führt die Modelltransformation immer für den besten SageMaker KI-Trainingsjob für dieses Training aus.
Weitere Informationen zu Modelltransformationsaufträgen finden Sie unter [Der Befehl modeltransform](machine-learning-api-modeltransform.md).
# Artefakte, die von Modelltrainings in Neptune ML erzeugt wurden
Nach dem Modelltraining verwendet Neptune ML die am besten trainierten Modellparameter, um Modellartefakte zu generieren, die für den Start des Inferenzendpunkts und die Bereitstellung von Modellvorhersagen notwendig sind. Diese Artefakte werden für den Trainingsjob zusammengefasst und im Amazon S3-Ausgabespeicherort des besten SageMaker KI-Schulungsjobs gespeichert.
Die folgenden Abschnitte beschreiben, was in den Modellartefakten für die verschiedenen Aufgaben enthalten ist, und wie vorhandene, bereits trainierte Modelle vom Modelltransformationsbefehl verwendet werden, um auch für neue Diagrammdaten Artefakte zu erzeugen.
## Artefakte, die für verschiedene Aufgaben generiert werden
Der Inhalt der vom Training generierten Modellartefakte ist von der Machine-Learning-Zielaufgabe abhängig:
****
+ **Klassifizierung und Regression von Knoten** – Für Vorhersagen von Knoteneigenschaften gehören zu den Artefakten Modellparameter, Knoteneinbettungen aus dem [GNN-Encoder](machine-learning-models-and-training.md#machine-learning-gnns), Modellvorhersagen für Knoten im Trainingsdiagramm und einige Konfigurationsdateien für den Inferenzendpunkt. Bei Aufgaben für die Klassifizierung und Regression von Aufgaben werden zur Reduzierung der Abfragelatenz Modellvorhersagen für Knoten, die während des Trainings vorhanden sind, vorab berechnet.
+ **Klassifizierung und Regression von Kanten** – Für Vorhersagen von Kanteneigenschaften gehören zu den Artefakten auch Modellparameter und Knoteneinbettungen. Die Parameter des Modell-Decoders sind für die Inferenz besonders wichtig, da die Vorhersagen für die Klassifizierung oder Regression von Kanten durch die Anwendung des Modell-Decoders auf die Einbettungen des Quell- und Zieleckpunkts einer Kante berechnet werden.
+ **Linkvorhersage** – Für Linkvorhersagen ist neben den Artefakten, die für die Vorhersage der Kanteneigenschaften generiert werden, auch das DGL-Diagramm als Artefakt enthalten, da Linkvorhersagen die Ausführung von Vorhersagen durch das Trainingsdiagramm erfordern. Das Ziel von Linkvorhersagen besteht in der Vorhersage der Zieleckpunkte, die wahrscheinlich mit einem Quelleckpunkt kombiniert werden, um eine Kante eines bestimmten Typs im Diagramm zu bilden. Hierzu werden die Knoteneinbettung des Quelleckpunkts und eine erlernte Darstellung des Kantentyps mit den Knoteneinbettungen aller möglichen Zieleckpunkte kombiniert, sodass für jeden Zieleckpunkt ein Wert für die Kantenwahrscheinlichkeit berechnet wird. Die Werte werden anschließend sortiert, um die potenziellen Zieleckpunkte zu ordnen und die besten Kandidaten zurückzugeben.
Für jeden Aufgabentyp werden die Gewichtungen des Graph-Neural-Network-Modells aus der DGL im Modellartefakt gespeichert. Auf diese Weise kann Neptune ML neue Modellausgaben berechnen, wenn das Diagramm geändert wird (*induktive* Inferenz), und vorab berechnete Vorhersagen und Einbettungen (*transduktive* Inferenz) verwenden, um die Latenz zu reduzieren.
## Generieren neuer Modellartefakte
Die nach dem Modelltraining in Neptune ML generierten Modellartefakte sind direkt mit dem Trainingsvorgang verbunden. Die vorab berechneten Einbettungen und Vorhersagen sind daher nur für Entitäten im ursprünglichen Trainingsdiagramm vorhanden. Obwohl der induktive Inferenzmodus für Neptune-ML-Endpunkte Vorhersagen für neue Entitäten in Echtzeit berechnen kann, sollten Sie Batch-Vorhersagen für neue Entitäten ohne Abfrage eines Endpunkts generieren.
Um Batch-Modellvorhersagen für neue Entitäten zu erhalten, die dem Diagramm hinzugefügt wurden, müssen für die neuen Diagrammdaten neue Modellartefakte neu berechnet werden. Dies erfolgt mittels des Befehls `modeltransform`. Sie verwenden den Befehl `modeltransform`, wenn Sie nur Batch-Vorhersagen ohne Einrichtung eines Endpunkts erhalten möchten oder wenn alle Vorhersagen generiert werden sollen, damit Sie diese zurück zum Diagramm schreiben können.
Da Modelltrainings am Ende des Trainingsvorgangs implizit eine Modelltransformation durchführen, führen Trainingsaufträge stets eine Neuberechnung der Modellartefakte anhand der Trainingsdiagrammdaten durch. Der Befehl `modeltransform` kann Modellartefakte jedoch auch anhand von Diagrammdaten berechnen, die nicht zum Trainieren eines Modells verwendet wurden. Hierzu müssen die neuen Diagrammdaten mit denselben Feature-Kodierungen wie die ursprünglichen Diagrammdaten verarbeitet werden und dasselbe Diagrammschema verwenden.
Erstellen Sie zunächst einen Klon des Datenverarbeitungsauftrags, der für die ursprünglichen Trainingsdiagrammdaten ausgeführt wurde. Führen Sie diesen dann für die neuen Diagrammdaten aus (siehe [Verarbeiten aktualisierter Diagrammdaten für Neptune ML](machine-learning-on-graphs-processing.md#machine-learning-on-graphs-processing-updated)). Rufen Sie dann den Befehl `modeltransform` mit der neuen `dataProcessingJobId` und der alten `modelTrainingJobId` auf, um die Modellartefakte anhand der aktualisierten Diagrammdaten neu zu berechnen.
Für die Vorhersage von Knoteneigenschaften werden die Knoteneinbettungen und Vorhersagen anhand der neuen Diagrammdaten neu berechnet, auch für Knoten im ursprünglichen Trainingsdiagramm.
Für die Vorhersage von Kanteneigenschaften und Linkvorhersagen werden die Knoteneinbettungen ebenfalls neu berechnet. Diese überschreiben alle vorhandenen Knoteneinbettungen. Um die Knoteneinbettungen neu zu berechnen, wendet Neptune ML den erlernten GNN-Encoder aus dem zuvor trainierten Modell auf die Knoten der neuen Diagrammdaten mit ihren neuen Features an.
Für Knoten ohne Features werden die erlernten anfänglichen Darstellungen aus dem ursprünglichen Modelltraining wiederverwendet. Für neue Knoten ohne Features, die nicht im ursprünglichen Trainingsdiagramm vorhanden waren, initialisiert Neptune ML die Darstellung als Durchschnitt der erlernten anfänglichen Knotendarstellungen des Knotentyps im ursprünglichen Trainingsdiagramm. Dies kann zu Leistungsabfällen bei Modellvorhersagen führen, wenn es zahlreiche neue Knoten ohne Features gibt, da alle zur durchschnittlichen anfänglichen Einbettung für diesen Knotentyp initialisiert werden.
Wenn Ihr Modell mit `concat-node-embed` als „true“ trainiert wird, werden die anfänglichen Knotendarstellungen durch die Verkettung der Knoten-Features mit der erlernbaren Anfangsdarstellung erstellt. Daher verwendet die anfängliche Knotendarstellung neuer Knoten für das aktualisierte Diagramm ebenfalls die durchschnittlichen anfänglichen Knoteneinbettungen, verkettet mit neuen Knoten-Features.
Darüber hinaus wird das Löschen von Knoten zurzeit nicht unterstützt. Wenn Knoten aus dem aktualisierten Diagramm entfernt wurden, müssen Sie das Modell anhand der aktualisierten Diagrammdaten neu trainieren.
Bei der Neuberechnung der Modellartefakte werden die erlernten Modellparameter für ein neues Diagramm wiederverwendet. Dies sollte nur erfolgen, wenn das neue Diagramm dem alten Diagramm sehr ähnlich ist. Wenn das neue Diagramm nicht ausreichend ähnlich ist, müssen Sie das Modell neu trainieren, um eine vergleichbare Modellleistung mit den neuen Diagrammdaten zu erzielen. Was als ausreichend ähnlich gilt, ist von der Struktur der Diagrammdaten abhängig. Als Faustregel sollten Sie Ihr Modell jedoch neu trainieren, wenn sich Ihre neuen Daten um mehr als 10–20 % von den ursprünglichen Trainingsdiagrammdaten unterscheiden.
Für Diagramme, in denen alle Knoten Features besitzen, gilt das obere Ende des Schwellenwerts (20 % Unterschied). Für Diagramme, in denen viele Knoten keine Features besitzen und die neuen, dem Diagramm hinzugefügten Knoten keine Eigenschaften besitzen, ist der untere Schwellenwert (10 % Unterschied) möglicherweise sogar zu hoch.
Weitere Informationen zu Modelltransformationsaufträgen finden Sie unter [Der Befehl modeltransform](machine-learning-api-modeltransform.md).
# Benutzerdefinierte Modelle in Neptune ML
**Anmerkung**
Die Unterstützung benutzerdefinierter Neptune ML-Modelle basiert auf einer älteren Version von Python 3. [Um benutzerdefinierte GNN-Modelle mit up-to-date Abhängigkeiten zu erstellen und auszuführen, verwenden Sie on. GraphStorm SageMaker](https://graphstorm.readthedocs.io/en/v0.3.1/cli/model-training-inference/distributed/sagemaker.html)
[Induktive Inferenz in Echtzeit](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) wird zurzeit für benutzerdefinierte Modelle nicht unterstützt.
In Neptune ML können Sie mithilfe von Python Ihre eigenen benutzerdefinierten Modellimplementierungen definieren. Sie können in der Neptune-ML-Infrastruktur benutzerdefinierte Modelle wie die integrierten Modelle trainieren, bereitstellen und verwenden, um mittels Diagrammabfragen Vorhersagen zu erhalten.
Sie können mit der Implementierung eines eigenen benutzerdefinierten Modells in Python beginnen, indem Sie den [Beispielen im Neptune-ML-Toolkit-Beispielen](https://github.com/awslabs/neptuneml-toolkit/tree/main/examples/custom-models/) folgen und die im Neptune-ML-Toolkit bereitgestellten Modellkomponenten verwenden. In den folgenden Abschnitten finden Sie weitere Details.
**Contents**
+ [
# Übersicht über benutzerdefinierte Modelle in Neptune ML
](machine-learning-custom-model-overview.md)
+ [
## Wann sollte ein benutzerdefiniertes Modell in Neptune ML verwendet werden
](machine-learning-custom-model-overview.md#machine-learning-custom-models-when-to-use)
+ [
## Workflow für die Entwicklung und Verwendung eines benutzerdefinierten Modells in Neptune ML
](machine-learning-custom-model-overview.md#machine-learning-custom-model-workflow)
+ [
# Entwicklung kundenspezifischer Modelle in Neptune ML
](machine-learning-custom-model-development.md)
+ [
## Entwicklung benutzerdefinierter Modelltrainingsskripts in Neptune ML
](machine-learning-custom-model-development.md#machine-learning-custom-model-training-script)
+ [
## Entwicklung benutzerdefinierter Modelltransformationsskripts in Neptune ML
](machine-learning-custom-model-development.md#machine-learning-custom-model-transform-script)
+ [
## Benutzerdefinierte `model-hpo-configuration.json`-Datei in Neptune ML
](machine-learning-custom-model-development.md#machine-learning-custom-model-hpo-configuration-file)
+ [
## Lokale Tests Ihrer benutzerdefinierten Modellimplementierung in Neptune ML
](machine-learning-custom-model-development.md#machine-learning-custom-model-testing)
# Übersicht über benutzerdefinierte Modelle in Neptune ML
## Wann sollte ein benutzerdefiniertes Modell in Neptune ML verwendet werden
Die integrierten Modelle von Neptune ML behandeln alle von Neptune ML unterstützten Standardaufgaben. Es kann jedoch Fälle geben, in denen Sie das Modell für eine bestimmte Aufgabe genauer steuern möchten oder den Modelltrainingsprozess anpassen müssen. Sie sollten in den folgenden Situationen ein benutzerdefiniertes Modell verwenden:
+ Die Feature-Kodierung für Text-Features sehr großer Textmodelle muss auf einer GPU ausgeführt werden.
+ Sie möchten ein eigenes benutzerdefiniertes Graph-Neural-Network (GNN)-Modell verwenden, das in der Deep Graph Library (DGL) entwickelt wurde.
+ Sie möchten tabellarische Modelle oder Ensemblemodelle für die Klassifizierung und Regression von Knoten verwenden.
## Workflow für die Entwicklung und Verwendung eines benutzerdefinierten Modells in Neptune ML
Die Unterstützung benutzerdefinierter Modelle in Neptune ML soll die nahtlose Integration in vorhandene Neptune-ML-Workflows ermöglichen. Dabei wird benutzerdefinierter Code in Ihrem Quellmodul in der Neptune-ML-Infrastruktur ausgeführt, um das Modell zu trainieren. Genau wie bei einem integrierten Modus startet Neptune ML automatisch einen SageMaker HyperParameter KI-Tuning-Job und wählt anhand der Bewertungsmetrik das beste Modell aus. Anschließend werden über die in Ihrem Quellmodul bereitgestellte Implementierung Modellartefakte zur Bereitstellung generiert.
Datenexport, Trainingskonfiguration und Datenvorverarbeitung sind für benutzerdefinierte und integrierte Modelle identisch.
Nach der Datenvorverarbeitung können Sie Ihre benutzerdefinierte Modellimplementierung iterativ und interaktiv mit Python entwickeln und testen. Wenn Ihr Modell für die Produktion bereit ist, können Sie das resultierende Python-Modul wie folgt zu Amazon S3 hochladen:
```
aws s3 cp --recursive (source path to module) s3://(bucket name)/(destination path for your module)
```
Anschließend können Sie das Modell über den normalen [Standard-Daten-Workflow](machine-learning-overview.md#machine-learning-overview-starting-workflow) oder den [inkrementellen Daten-Workflow](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) in der Produktion bereitstellen. Es gibt jedoch einige Unterschiede.
Für das Modelltraining anhand eines benutzerdefinierten Modells müssen Sie der Neptune-ML-Modelltrainings-API das JSON-Objekt `customModelTrainingParameters` bereitstellen, um sicherzustellen, dass Ihr benutzerdefinierter Code verwendet wird. Die Felder im Objekt `customModelTrainingParameters` sind:
+ **`sourceS3DirectoryPath`** – (*Erforderlich*) Der Pfad zum Amazon-S3-Speicherort des Python-Moduls, das Ihr Modell implementiert. Dieser Pfad muss auf einen gültigen, vorhandenen Amazon-S3-Speicherort verweisen, der mindestens ein Trainingsskript, ein Transformationsskript und die Datei `model-hpo-configuration.json` enthält.
+ **`trainingEntryPointScript`** – (*Optional*) Der Name des Einstiegspunkts in Ihrem Modul für ein Skript, das Modelltrainings durchführt und Hyperparameter als Befehlszeilenargumente verwendet, einschließlich fester Hyperparameter.
*Standardwert*: `training.py`.
+ **`transformEntryPointScript`** – (*Optional*) Der Name des Einstiegspunkts in Ihrem Modul für ein Skript, das ausgeführt werden soll, nachdem das beste Modell aus der Hyperparametersuche identifiziert wurde, um die für die Modellbereitstellung notwendigen Modellartefakte zu berechnen. Es sollte ohne Befehlszeilenargumente ausgeführt werden können.
*Standardwert*: `transform.py`.
Beispiel:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"modelName": "custom",
"customModelTrainingParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"trainingEntryPointScript": "(your training script entry-point name in the Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
Um eine benutzerdefinierte Modelltransformation zu aktivieren, müssen Sie der Neptune-ML-Modelltransformations-API das JSON-Objekt `customModelTransformParameters` mit Feldwerten bereitstellen, die mit den gespeicherten Modellparametern aus dem Trainingsauftrag kompatibel sind. Das Objekt `customModelTransformParameters` enthält die folgenden Felder:
+ **`sourceS3DirectoryPath`** – (*Erforderlich*) Der Pfad zum Amazon-S3-Speicherort des Python-Moduls, das Ihr Modell implementiert. Dieser Pfad muss auf einen gültigen, vorhandenen Amazon-S3-Speicherort verweisen, der mindestens ein Trainingsskript, ein Transformationsskript und die Datei `model-hpo-configuration.json` enthält.
+ **`transformEntryPointScript`** – (*Optional*) Der Name des Einstiegspunkts in Ihrem Modul für ein Skript, das ausgeführt werden soll, nachdem das beste Modell aus der Hyperparametersuche identifiziert wurde, um die für die Modellbereitstellung notwendigen Modellartefakte zu berechnen. Es sollte ohne Befehlszeilenargumente ausgeführt werden können.
*Standardwert*: `transform.py`.
Beispiel:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"trainingJobName" : "(name of a completed SageMaker AI training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/"
"customModelTransformParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
# Entwicklung kundenspezifischer Modelle in Neptune ML
Eine gute Möglichkeit, mit der Entwicklung benutzerdefinierter Modelle zu beginnen, besteht darin, den [Beispielen im Neptune-ML-Toolkit](https://github.com/awslabs/neptuneml-toolkit/tree/main/examples/custom-models/introduction) zu folgen, um Ihr Trainingsmodul zu strukturieren und zu schreiben. Das Neptune-ML-Toolkit implementiert auch modularisierte Diagramm-ML-Modellkomponenten im [modelzoo](https://github.com/awslabs/neptuneml-toolkit/tree/main/src/neptuneml_toolkit/modelzoo), die Sie stapeln und zur Erstellung Ihres benutzerdefinierten Modells verwenden können.
Darüber hinaus bietet das Toolkit Dienstprogrammfunktionen, mit denen Sie während Modelltraining und Modelltransformation die notwendigen Artefakte erzeugen können. Sie können dieses Python-Paket in Ihre benutzerdefinierte Implementierung importieren. Alle im Toolkit enthaltenen Funktionen oder Module sind auch in der Neptune-ML-Trainingsumgebung verfügbar.
Wenn Ihr Python-Modul zusätzliche externe Abhängigkeiten besitzt, können Sie diese zusätzlichen Abhängigkeiten einfügen, indem Sie im Verzeichnis Ihres Moduls die Datei `requirements.txt` erstellen. Die in der Datei `requirements.txt` aufgelisteten Pakete werden anschließend installiert, bevor Ihr Trainingsskript ausgeführt wird.
Das Python-Modul, das Ihr benutzerdefiniertes Modell implementiert, muss mindestens Folgendes enthalten:
+ Einen Einstiegspunkt für ein Trainingsskript
+ Einen Einstiegspunkt für ein Transformationsskript
+ Eine `model-hpo-configuration.json`-Datei
## Entwicklung benutzerdefinierter Modelltrainingsskripts in Neptune ML
Ihr benutzerdefiniertes Modelltrainingsskript sollte ein ausführbares Python-Skript sein, siehe das Beispielskript [https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py) im Neptune-ML-Toolkit. Es muss Hyperparameternamen und -werte als Befehlszeilenargumente akzeptieren. Während des Modelltrainings werden die Hyperparameternamen aus der Datei `model-hpo-configuration.json` abgerufen. Die Hyperparameterwerte liegen entweder innerhalb des gültigen Hyperparameterbereichs, wenn der Hyperparameter optimierbar ist, oder nehmen den Standard-Hyperparameterwert an, wenn er nicht optimierbar ist.
Ihr Trainingsskript wird auf einer SageMaker AI-Trainingsinstanz mit einer Syntax wie der folgenden ausgeführt:
```
python3 (script entry point) --(1st parameter) (1st value) --(2nd parameter) (2nd value) (...)
```
Für alle Aufgaben AutoTrainer sendet das Neptune ML zusätzlich zu den von Ihnen angegebenen Hyperparametern mehrere erforderliche Parameter an Ihr Trainingsskript, und Ihr Skript muss in der Lage sein, diese zusätzlichen Parameter zu verarbeiten, um ordnungsgemäß zu funktionieren.
Diese zusätzlichen erforderlichen Parameter sind von der jeweiligen Aufgabe abhängig:
**Für die Klassifizierung oder Regression von Knoten**
+ **`task`** – Der intern von Neptune ML verwendete Aufgabentyp. Für die Knotenklassifikation ist dies `node_class`, für die Knotenregression `node_regression`.
+ **`model`** – Der intern von Neptune ML verwendete Modellname, in diesem Fall `custom`.
+ **`name`** – Der Name der intern von Neptune ML verwendeten Aufgabe, in diesem Fall `node_class-custom` für die Knotenklassifizierung und `node_regression-custom` für die Knotenregression.
+ **`target_ntype`** – Der Name des Knotentyps für die Klassifizierung oder Regression.
+ **`property`** – Der Name der Knoteneigenschaft für die Klassifizierung oder Regression.
**Für Linkvorhersagen**
+ **`task`** – Der intern von Neptune ML verwendete Aufgabentyp. Für Linkvorhersagen ist dies `link_predict`.
+ **`model`** – Der intern von Neptune ML verwendete Modellname, in diesem Fall `custom`.
+ **`name`** – Der intern von Neptune ML verwendete Aufgabenname, in diesem Fall `link_predict-custom`.
**Für die Klassifizierung oder Regression von Kanten**
+ **`task`** – Der intern von Neptune ML verwendete Aufgabentyp. Für die Kantenklassifikation ist dies `edge_class`, für die Kantenregression `edge_regression`.
+ **`model`** – Der intern von Neptune ML verwendete Modellname, in diesem Fall `custom`.
+ **`name`** – Der Name der intern von Neptune ML verwendeten Aufgabe, in diesem Fall `edge_class-custom` für die Kantenklassifizierung und `edge_regression-custom` für die Kantenregression.
+ **`target_etype`** – Der Name des Kantentyps für die Klassifizierung oder Regression.
+ **`property`** – Der Name der Kanteneigenschaft für die Klassifizierung oder Regression.
Ihr Skript sollte die Modellparameter sowie alle weiteren Artefakte speichern, die am Ende des Trainings benötigt werden.
Sie können die Dienstprogrammfunktionen des Neptune-ML-Toolkits verwenden, um den Speicherort der verarbeiteten Diagrammdaten, den Speicherort der Modellparameter und die auf der Trainings-Instance verfügbaren GPU-Geräte zu bestimmen. Beispiele für die Verwendung dieser Dienstprogrammfunktionen finden Sie im Beispiel-Trainingsskript [train.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py).
## Entwicklung benutzerdefinierter Modelltransformationsskripts in Neptune ML
Ein Transformationsskript ist erforderlich, um den [inkrementellen Neptune-ML-Workflow](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) für Modellinferenzen für neue Diagramme zu nutzen, ohne das Modell neu zu trainieren. Auch wenn alle für die Modellbereitstellung notwendigen Artefakte durch das Trainingsskript generiert werden, müssen Sie dennoch ein Transformationsskript bereitstellen, wenn Sie aktualisierte Modelle generieren möchten, ohne das Modell neu zu trainieren.
**Anmerkung**
[Induktive Inferenz in Echtzeit](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) wird zurzeit für benutzerdefinierte Modelle nicht unterstützt.
Ihr benutzerdefiniertes Modelltransformationsskript sollte ein ausführbares Python-Skript sein, siehe das Beispielskript [transform.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/transform.py) im Neptune-ML-Toolkit. Da dieses Skript während des Modelltrainings ohne Befehlszeilenargumente aufgerufen wird, müssen alle Befehlszeilenargumente, die das Skript akzeptiert, Standardwerte haben.
Das Skript läuft auf einer SageMaker KI-Trainingsinstanz mit einer Syntax wie dieser:
```
python3 (your transform script entry point)
```
Ihr Transformationsskript benötigt verschiedene Informationen, z. B.:
+ Der Speicherort der verarbeiteten Diagrammdaten.
+ Der Speicherort der Modellparameter und der Speicherort für neue Modellartefakte.
+ Die auf der Instance verfügbaren Geräte.
+ Die Hyperparameter, die das beste Modell generiert haben.
Diese Eingaben werden über Neptune-ML-Dienstprogrammfunktionen abgerufen, die Ihr Skript aufrufen kann. Beispiele hierfür finden Sie im Beispielskript [transform.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/transform.py) im Toolkit.
Das Skript sollte Knoteneinbettungen, Knoten-ID-Zuordnungen und alle anderen Artefakte speichern, die für die Modellbereitstellung für die einzelnen Aufgaben notwendig sind. Weitere Informationen zu den für verschiedene Neptune-ML-Aufgaben erforderlichen Modellartefakten finden Sie in der [Dokumentation zu Modellartefakten](machine-learning-model-artifacts.md).
## Benutzerdefinierte `model-hpo-configuration.json`-Datei in Neptune ML
Die Datei `model-hpo-configuration.json` definiert Hyperparameter für Ihr benutzerdefiniertes Modell. Sie hat dasselbe [Format](machine-learning-customizing-hyperparams.md) wie die Datei `model-hpo-configuration.json`, die mit den integrierten Neptune-ML-Modellen verwendet wird, und hat Priorität gegenüber der Version, die von Neptune ML automatisch generiert und zum Speicherort Ihrer verarbeiteten Daten hochgeladen wird.
Wenn Sie Ihrem Modell einen neuen Hyperparameter hinzufügen, müssen Sie in dieser Datei auch einen Eintrag für den Hyperparameter hinzufügen, damit dieser an Ihr Trainingsskript übergeben wird.
Sie müssen einen Bereich für einen Hyperparameter angeben, wenn er optimierbar sein soll, und diesen als `tier-1`-, `tier-2`- oder `tier-3`-Parameter festlegen. Der Hyperparameter wird optimiert, wenn die Gesamtzahl der konfigurierten Trainingsaufträge die Optimierung von Hyperparametern in seiner Stufe zulässt. Für einen nicht optimierbaren Parameter müssen Sie einen Standardwert angeben und den Hyperparameter zum Abschnitt `fixed-param` der Datei hinzufügen. Ein Beispiel dafür, wie Sie dies tun, finden Sie in der [Beispieldatei `model-hpo-configuration.json`](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/model-hpo-configuration.json) im Toolkit.
Sie müssen auch die Metrikdefinition angeben, anhand SageMaker derer der HyperParameter KI-Optimierungsjob die trainierten Kandidatenmodelle bewertet. Hierzu fügen Sie der Datei `model-hpo-configuration.json` das JSON-Objekt `eval_metric` wie folgt hinzu:
```
"eval_metric": {
"tuning_objective": {
"MetricName": "(metric_name)",
"Type": "Maximize"
},
"metric_definitions": [
{
"Name": "(metric_name)",
"Regex": "(metric regular expression)"
}
]
},
```
Das `metric_definitions` Array im `eval_metric` Objekt listet Objekte mit Metrikdefinitionen für jede Metrik auf, die SageMaker KI aus der Trainingsinstanz extrahieren soll. Jedes Metrikdefinitionsobjekt besitzt einen `Name`-Schlüssel, mit dem Sie einen Namen für die Metrik angeben können (z. B. „Genauigkeit“, „F1“ usw.). Mit diesem `Regex`-Schlüssel können Sie eine Zeichenfolge mit einem regulären Ausdruck angeben, der mit der Ausgabe dieser Metrik in den Trainingsprotokollen übereinstimmt. Weitere Informationen zur Definition von Metriken finden Sie auf der [Seite SageMaker KI HyperParameter Tuning](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-metrics.html).
Mit dem Objekt `tuning_objective` in `eval_metric` können Sie dann angeben, welche der Metriken in `metric_definitions` als die Auswertungsmetrik verwendet werden soll, die als Zielmetrik für die Hyperparameter-Optimierung dient. Der Wert für `MetricName` muss mit dem Wert von `Name` in einer der Definitionen in `metric_definitions` übereinstimmen. Der Wert für `Type` sollte entweder „Maximieren“ oder „Minimieren“ lauten, je nachdem, ob die Metrik als greater-is-better (wie „Genauigkeit“) oder less-is-better (wie „“ mean-squared-error interpretiert werden soll).
Fehler in diesem Abschnitt der `model-hpo-configuration.json` Datei können dazu führen, dass der API-Job für das Neptune ML-Modelltraining fehlschlägt, da der SageMaker AI HyperParameter Tuning-Job nicht in der Lage ist, das beste Modell auszuwählen.
## Lokale Tests Ihrer benutzerdefinierten Modellimplementierung in Neptune ML
Sie können Ihren Code lokal in der Conda-Umgebung des Neptune-ML-Toolkits ausführen, um Ihr Modell zu testen und zu validieren. Wenn Sie auf einer Neptune-Notebook-Instance entwickeln, wird die Conda-Umgebung auf der Neptune-Notebook-Instanz vorinstalliert. Wenn Sie auf einer anderen Instance entwickeln, müssen Sie die [Anweisungen für die lokale Einrichtung](https://github.com/awslabs/neptuneml-toolkit#local-installation) im Neptune-ML-Toolkit befolgen.
Die Conda-Umgebung reproduziert exakt die Umgebung, in der Ihr Modell ausgeführt werden wird, wenn Sie die [Modelltrainings-API](machine-learning-api-modeltraining.md) aufrufen. Alle Beispielskripts für Training und Transformation ermöglichen Ihnen die Übergabe des Befehlszeilen-Flags `--local`, um die Skripts zum einfachen Debuggen in einer lokalen Umgebung auszuführen. Sie sollten diese Umgebung bei der Entwicklung Ihres eigenen Modells nutzen, um Ihre Modellimplementierung interaktiv und iterativ zu testen. Beim Modelltraining in der Produktionstrainingsumgebung von Neptune ML wird dieser Parameter ausgelassen.
# Erstellen eines Inferenzendpunkts zur Abfrage
Mit einem Inferenzendpunkt können Sie ein einzelnes Modell abfragen, das im Rahmen des Modelltrainingsprozesses erstellt wurde. Der Endpunkt wird dem Modell eines bestimmten Typs mit der besten Leistung angefügt, das beim Training generiert werden konnte. Der Endpunkt kann anschließend Gremlin-Abfragen von Neptune akzeptieren und Modellvorhersagen für die Eingaben in den Abfragen zurückgeben. Nach der Erstellung bleibt ein Inferenzendpunkt aktiv, bis Sie ihn löschen.
## Verwalten von Inferenzendpunkten für Neptune ML
Nach dem Abschluss des Modelltrainings mit Daten, die Sie aus Neptune exportiert haben, können Sie mit einem `curl`- (oder`awscurl`-Befehl) wie dem folgenden einen Inferenzendpunkt erstellen:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"mlModelTrainingJobId": "(the model-training job-id of a completed job)"
}'
```
Sie können auf ähnliche Weise einen Inferenzendpunkt anhand eines Modells erstellen, das durch einen abgeschlossenen Modelltransformationsauftrag erstellt wurde:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"mlModelTransformJobId": "(the model-transform job-id of a completed job)"
}'
```
Die Einzelheiten zur Verwendung dieser Befehle werden in [Der Befehl endpoints](machine-learning-api-endpoints.md) beschrieben. Dort finden Sie auch Informationen zum Abrufen des Status eines Endpunkts, zum Löschen eines Endpunkts und zum Auflisten aller Inferenzendpunkte.
# Inferenzabfragen in Neptune ML
Sie können Gremlin oder SPARQL verwenden, um einen Neptune-ML-Inferenzendpunkt abzufragen. Die [induktive Inferenz in Echtzeit](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) wird derzeit jedoch nur für Gremlin-Abfragen unterstützt.
# Gremlin-Inferenzabfragen in Neptune ML
Wie in [Neptune-ML-Fähigkeiten](machine-learning.md#machine-learning-capabilities) beschrieben, unterstützt Neptune ML Trainingsmodelle, die die folgenden Arten von Inferenzaufgaben ausführen können:
+ **Knotenklassifizierung** – Sagt das kategorische Feature einer Eckpunkteigenschaft vorher.
+ **Knotenregression** – Sagt eine numerische Eigenschaft eines Eckpunkts vorher.
+ **Kantenklassifizierung** – Sagt das kategorische Feature einer Kanteneigenschaft vorher.
+ **Kantenregression** – Sagt eine numerische Eigenschaft eines Eckpunkts vorher.
+ **Linkvorhersage** – Sagt anhand eines Quellknotens und einer ausgehenden Kante Zielknoten oder anhand eines Zielknotens und einer eingehenden Kante Quellknoten voraus.
Wir können diese verschiedenen Aufgaben anhand von Beispielen veranschaulichen, die den von [GroupLens Research](https://grouplens.org/datasets/movielens/) bereitgestellten [MovieLens 100.000 Datensatz](https://grouplens.org/datasets/movielens/100k/) verwenden. Dieser Datensatz besteht aus Filmen, Benutzern und Bewertungen der Filme durch die Benutzer. Aus diesen Daten haben wir das folgende Eigenschaftsdiagramm erstellt:
![\[Beispiel für ein Diagramm mit Filmeigenschaften unter Verwendung des MovieLens 100.000 Datensatzes\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/movie_property_graph_example.png)
**Knotenklassifizierung**: Im Datensatz oben ist `Genre` ein Eckpunkttyp, der über die Kante `included_in` mit dem Eckpunkttyp `Movie` verbunden ist. Wenn der Datensatz jedoch so angepasst wird, dass `Genre` zum [kategorischen](https://en.wikipedia.org/wiki/Categorical_variable) Feature für den Eckpunkttyp `Movie` wird, kann das Problem der Ableitung des Werts für `Genre` für neue, zum Wissensdiagramm hinzugefügte Filme mit Knotenklassifizierungsmodellen gelöst werden.
**Knotenregression**: Bei Betrachtung des Eckpunkttyps `Rating`, der Eigenschaften wie `timestamp` und `score` besitzt, kann das Problem der Ableitung des numerischen Werts für `Score` für `Rating` mit Knotenregressionsmodellen gelöst werden.
**Kantenklassifizierung**: Wenn wir bei einer `Rated` Kante über eine Eigenschaft verfügen, `Scale` die einen der Werte,,,,, haben kann `Love` `Like` `Dislike` `Neutral``Hate`, das Problem der Rückschlüsse auf die Kante `Scale` für eine neue `Rated` movies/ratings Kante ebenfalls mithilfe von Kantenklassifizierungsmodellen gelöst werden.
**Kantenregression**: Ähnlich kann für die gleiche `Rated`-Kante mit einer Eigenschaft `Score`, die einen numerischen Wert für die Bewertung enthält, kann dies anhand von Kantenregressionsmodellen abgeleitet werden.
**Linkvorhersage**: Probleme wie die Suche nach den zehn Benutzern, die einen bestimmten Film am wahrscheinlichsten bewerten werden, oder der Suche nach den zehn Filmen, die ein bestimmter Benutzer am wahrscheinlichsten bewerten wird, werden mit Linkvorhersagen gelöst.
**Anmerkung**
Für Neptune-ML-Anwendungsfälle gibt es einen sehr umfangreichen Satz von Notebooks, die Ihnen ein praktisches Verständnis jedes Anwendungsfalls vermitteln sollen. Sie können diese Notizbücher zusammen mit Ihrem Neptune-Cluster erstellen, wenn Sie die Neptune [CloudFormation ML-Vorlage verwenden, um einen Neptune-ML-Cluster](machine-learning-quick-start.md) zu erstellen. Diese Notebooks sind auch auf [github](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning) verfügbar.
**Topics**
+ [
# In Gremlin-Inferenzabfragen verwendete Neptune-ML-Prädikate
](machine-learning-gremlin-inference-query-predicates.md)
+ [
# Gremlin-Knotenklassifizierungsabfragen in Neptune ML
](machine-learning-gremlin-vertex-classification-queries.md)
+ [
# Gremlin-Abfragen zur Knotenregression in Neptune ML
](machine-learning-gremlin-vertex-regression-queries.md)
+ [
# Gremlin-Kantenklassifizierungsabfragen in Neptune ML
](machine-learning-gremlin-edge-classification-queries.md)
+ [
# Gremlin-Abfragen zur Kantenregression in Neptune ML
](machine-learning-gremlin-edge-regression.md)
+ [
# Gremlin-Linkvorhersageabfragen mit Linkvorhersagemodellen in Neptune ML
](machine-learning-gremlin-link-prediction-queries.md)
+ [
# Liste der Ausnahmen für Neptune-ML-Gremlin-Inferenzabfragen
](machine-learning-gremlin-exceptions.md)
# In Gremlin-Inferenzabfragen verwendete Neptune-ML-Prädikate
## `Neptune#ml.deterministic`
Dieses Prädikat ist eine Option für induktive Inferenzabfragen, d. h. für Abfragen, die das Prädikat [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference) enthalten.
Bei Verwendung der induktiven Inferenz erstellt die Neptune-Engine das entsprechende Unterdiagramm zur Auswertung des trainierten GNN-Modells. Die Anforderungen dieses Unterdiagramms sind von den Parametern des endgültigen Modells abhängig. Insbesondere bestimmt der Parameter `num-layer` die Anzahl der Traversierungs-Hops von den Zielknoten oder -kanten. Der Parameter `fanouts` gibt an, wie viele Nachbarn bei jedem Hop abgefragt werden sollen (siehe [HPO-Parameter](machine-learning-customizing-hyperparams.md)).
Standardmäßig werden induktive Inferenzabfragen nicht deterministisch ausgeführt, d. h. Neptune erstellt die Nachbarschaft in randomisierter Weise. Diese normalen Abfragen randomisierter Nachbarschaften führen manchmal zu unterschiedlichen Vorhersagen.
Wenn Sie `Neptune#ml.deterministic` in eine induktive Inferenzabfrage einfügen, versucht die Neptune-Engine, Nachbarn deterministisch abzufragen, sodass mehrere Aufrufe derselben Abfrage jedes Mal dieselben Ergebnisse zurückgeben. Es kann jedoch nicht garantiert werden, dass die Ergebnisse vollständig deterministisch sind, da Änderungen des zugrunde liegenden Diagramms und Artefakte verteilter Systeme weiter zu Schwankungen führen können.
Sie fügen das Prädikat `Neptune#ml.deterministic` in eine Abfrage wie die folgende ein:
```
.with("Neptune#ml.deterministic")
```
Wenn das Prädikat `Neptune#ml.deterministic` in einer Abfrage enthalten ist, die nicht auch `Neptune#ml.inductiveInference` enthält, wird es einfach ignoriert.
## `Neptune#ml.disableInductiveInferenceMetadataCache`
Dieses Prädikat ist eine Option für induktive Inferenzabfragen, d. h. für Abfragen, die das Prädikat [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference) enthalten.
Für induktive Inferenzabfragen verwendet Neptune eine in Amazon S3 gespeicherte Metadatendatei, um bei der Erstellung der Nachbarschaft die Anzahl der Hops und den Fanout zu bestimmen. Neptune speichert diese Modellmetadaten normalerweise im Cache, um zu vermeiden, dass die Datei wiederholt aus Amazon S3 abgerufen wird. Das Caching kann durch Einfügen des Prädikats `Neptune#ml.disableInductiveInferenceMetadataCache` deaktiviert werden. Obwohl es für Neptune langsamer sein kann, die Metadaten direkt von Amazon S3 abzurufen, ist es nützlich, wenn der SageMaker KI-Endpunkt nach einem erneuten Training oder einer Transformation aktualisiert wurde und der Cache veraltet ist.
Sie fügen das Prädikat `Neptune#ml.disableInductiveInferenceMetadataCache` in eine Abfrage wie folgt ein:
```
.with("Neptune#ml.disableInductiveInferenceMetadataCache")
```
Dies ist ein Beispielabfrage in einem Jupyter-Notebook:
```
%%gremlin
g.with("Neptune#ml.endpoint", "ep1")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.with("Neptune#ml.disableInductiveInferenceMetadataCache")
.V('101').properties("rating")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
```
## `Neptune#ml.endpoint`
Das Prädikat `Neptune#ml.endpoint` wird in einem `with()`-Schritt verwendet, um den Inferenzendpunkt anzugeben, wenn notwendig:
```
.with("Neptune#ml.endpoint", "the model's SageMaker AI inference endpoint")
```
Sie können den Endpunkt anhand der `id` oder der URL identifizieren. Beispiel:
```
.with( "Neptune#ml.endpoint", "node-classification-movie-lens-endpoint" )
```
Oder:
```
.with( "Neptune#ml.endpoint", "https://runtime.sagemaker.us-east-1.amazonaws.com/endpoints/node-classification-movie-lens-endpoint/invocations" )
```
**Anmerkung**
Wenn Sie [den Parameter`neptune_ml_endpoint`](machine-learning-cluster-setup.md#machine-learning-set-inference-endpoint-cluster-parameter) in Ihrer Neptune-DB-Cluster-Parametergruppe auf den Endpunkt `id` oder die URL festlegen, müssen Sie das Prädikat `Neptune#ml.endpoint` nicht in jede Abfrage einfügen.
## `Neptune#ml.iamRoleArn`
`Neptune#ml.iamRoleArn`wird in einem `with()` Schritt verwendet, um den ARN der SageMaker AI-Ausführungs-IAM-Rolle anzugeben, falls erforderlich:
```
.with("Neptune#ml.iamRoleArn", "the ARN for the SageMaker AI execution IAM role")
```
Informationen zum Erstellen der IAM-Rolle für die SageMaker AI-Ausführung finden Sie unter. [Erstellen Sie eine benutzerdefinierte Rolle NeptuneSageMaker IAMRole](machine-learning-manual-setup.md#ml-manual-setup-sm-role)
**Anmerkung**
Wenn Sie [den `neptune_ml_iam_role` Parameter](machine-learning-cluster-setup.md#machine-learning-enabling-create-param-group) in Ihrer Neptune DB-Cluster-Parametergruppe auf den ARN Ihrer IAM-Rolle für die SageMaker KI-Ausführung festlegen, müssen Sie das `Neptune#ml.iamRoleArn` Prädikat nicht in jede Abfrage aufnehmen.
## Neptune\$1ml.inductiveInference
Die transduktive Inferenz ist in Gremlin standardmäßig aktiviert. Um eine [induktive Inferenzabfrage in Echtzeit](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) zu erstellen, fügen Sie das Prädikat `Neptune#ml.inductiveInference` wie folgt hinzu:
```
.with("Neptune#ml.inductiveInference")
```
Wenn Ihr Diagramm dynamisch ist, ist die induktive Inferenz häufig die beste Wahl. Wenn Ihr Diagramm jedoch statisch ist, ist die transduktive Inferenz schneller und effizienter.
## `Neptune#ml.limit`
Das Prädikat `Neptune#ml.limit` begrenzt optional die Anzahl der Ergebnisse, die pro Entität zurückgegeben werden:
```
.with( "Neptune#ml.limit", 2 )
```
Standardmäßig ist der Grenzwert 1. Die maximale Anzahl, die festgelegt werden kann, ist 100.
## `Neptune#ml.threshold`
Das Prädikat `Neptune#ml.threshold` legt optional einen Mindestwert für Ergebniswerte fest:
```
.with( "Neptune#ml.threshold", 0.5D )
```
So werden alle Ergebnisse verworfen, deren Werte unter dem angegebenen Schwellenwert liegen.
## `Neptune#ml.classification`
Das `Neptune#ml.classification` Prädikat wird an den `properties()` Schritt angehängt, um festzulegen, dass die Eigenschaften vom SageMaker KI-Endpunkt des Knotenklassifikationsmodells abgerufen werden müssen:
```
.properties( "property key of the node classification model" ).with( "Neptune#ml.classification" )
```
## `Neptune#ml.regression`
Das `Neptune#ml.regression` Prädikat wird an den `properties()` Schritt angehängt, um festzulegen, dass die Eigenschaften vom SageMaker KI-Endpunkt des Knotenregressionsmodells abgerufen werden müssen:
```
.properties( "property key of the node regression model" ).with( "Neptune#ml.regression" )
```
## `Neptune#ml.prediction`
Das Prädikat `Neptune#ml.prediction` wird an die Schritte `in()` und `out()` angefügt, um festzulegen, dass es sich um eine Linkvorhersage-Abfrage handelt:
```
.in("edge label of the link prediction model").with("Neptune#ml.prediction").hasLabel("target node label")
```
## `Neptune#ml.score`
Das Prädikat `Neptune#ml.score` wird in Abfragen zur Klassifizierung von Gremlin-Knoten oder -Kanten verwendet, um Machine-Learning-Konfidenzwerte abzurufen. Das Prädikat `Neptune#ml.score` sollte zusammen mit dem Abfrageprädikat im Schritt `properties()` übergeben werden, um ML-Konfidenzwerte für Abfragen zur Klassifizierung von Knoten oder Kanten zu erhalten.
Sie finden ein Beispiel für die Knotenklassifizierung mit [weiteren Beispielen für die Knotenklassifizierung](machine-learning-gremlin-vertex-classification-queries.md#machine-learning-gremlin-node-class-other-queries) und ein Beispiel für die Kantenklassifizierung im Abschnitt für die [Kantenklassifizierung](machine-learning-gremlin-edge-classification-queries.md).
# Gremlin-Knotenklassifizierungsabfragen in Neptune ML
Für die Gremlin-Knotenklassifizierung in Neptune ML:
+ Das Modell wird anhand einer einzelnen Eigenschaft der Eckpunkte trainiert. Der Satz der eindeutigen Werte dieser Eigenschaft wird als Satz von Knotenklassen oder einfach Klassen bezeichnet.
+ Die Knotenklasse oder der kategorische Eigenschaftswert einer Eckpunkteigenschaft kann aus dem Knotenklassifikationsmodell abgeleitet werden. Dies ist nützlich, wenn diese Eigenschaft dem Eckpunkt noch nicht angefügt ist.
+ Um eine oder mehrere Klassen aus einem Knotenklassifikationsmodell abzurufen, müssen Sie den Schritt `with()` mit dem Prädikat `Neptune#ml.classification` verwenden, um den Schritt `properties()` zu konfigurieren. Das Ausgabeformat ist dem Ausgabeformat für Eckpunkteigenschaften ähnlich.
**Anmerkung**
Die Knotenklassifizierung funktioniert nur mit Zeichenfolgen-Eigenschaftswerten. Das bedeutet, dass numerische Eigenschaftswerte wie `0` oder `1` nicht unterstützt werden, auch wenn die Zeichenfolgenäquivalente `"0"` und `"1"` unterstützt werden. Ähnlich funktionieren die booleschen Eigenschaftswerte `true` und `false` nicht, während `"true"` und `"false"` funktionieren.
Dies ist ein Beispiel für eine Abfrage zur Knotenklassifizierung:
```
g.with( "Neptune#ml.endpoint","node-classification-movie-lens-endpoint" )
.with( "Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role" )
.with( "Neptune#ml.limit", 2 )
.with( "Neptune#ml.threshold", 0.5D )
.V( "movie_1", "movie_2", "movie_3" )
.properties("genre").with("Neptune#ml.classification")
```
Die Ausgabe dieser Abfrage sieht ähnlich wie folgt aus:
```
==>vp[genre->Action]
==>vp[genre->Crime]
==>vp[genre->Comedy]
```
In der Abfrage oben werden die Schritte `V()` und `properties()` wie folgt verwendet:
Der Schritt `V()` enthält den Satz von Eckpunkten, für die Sie die Klassen aus dem Knotenklassifizierungsmodell abrufen möchten:
```
.V( "movie_1", "movie_2", "movie_3" )
```
Der Schritt `properties()` enthält den Schlüssel, mit dem das Modell trainiert wurde, und besitzt `.with("Neptune#ml.classification")`, um anzugeben, dass es sich um eine ML-Inferenzabfrage zur Knotenklassifizierung handelt.
Der Schritt `properties().with("Neptune#ml.classification")` unterstützt zurzeit mehrere Eigenschaftsschlüssel nicht. Die folgende Abfrage führt beispielsweise zu einer Ausnahme:
```
g.with("Neptune#ml.endpoint", "node-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V( "movie_1", "movie_2", "movie_3" )
.properties("genre", "other_label").with("Neptune#ml.classification")
```
Die spezifische Fehlermeldung finden Sie in der [Liste der Neptune-ML-Ausnahmen](machine-learning-gremlin-exceptions.md).
Der Schritt `properties().with("Neptune#ml.classification")` kann in Kombination mit einem der folgenden Schritte verwendet werden:
+ `value()`
+ `value().is()`
+ `hasValue()`
+ `has(value,"")`
+ `key()`
+ `key().is()`
+ `hasKey()`
+ `has(key,"")`
+ `path()`
## Weitere Abfragen zur Knotenklassifizierung
Wenn sowohl der Inferenzendpunkt als auch die entsprechende IAM-Rolle in der DB-Cluster-Parametergruppe gespeichert wurden, kann eine Knotenklassifizierungsabfrage so einfach wie die folgende sein:
```
g.V("movie_1", "movie_2", "movie_3").properties("genre").with("Neptune#ml.classification")
```
Mit dem Schritt `union()` können Sie Eckpunkteigenschaften und Klassen in einer Abfrage kombinieren:
```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V( "movie_1", "movie_2", "movie_3" )
.union(
properties("genre").with("Neptune#ml.classification"),
properties("genre")
)
```
Sie können auch eine unbegrenzte Abfrage wie die folgende erstellen:
```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V()
.properties("genre").with("Neptune#ml.classification")
```
Sie können die Knotenklassen zusammen mit Eckpunkten abrufen, indem Sie den Schritt `select()` zusammen mit dem Schritt `as()` ausführen:
```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V( "movie_1", "movie_2", "movie_3" ).as("vertex")
.properties("genre").with("Neptune#ml.classification").as("properties")
.select("vertex","properties")
```
Sie können auch nach Knotenklassen filtern, wie in den folgenden Beispielen gezeigt:
```
g.with("Neptune#ml.endpoint", "node-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V( "movie_1", "movie_2", "movie_3" )
.properties("genre").with("Neptune#ml.classification")
.has(value, "Horror")
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V( "movie_1", "movie_2", "movie_3" )
.properties("genre").with("Neptune#ml.classification")
.has(value, P.eq("Action"))
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V( "movie_1", "movie_2", "movie_3" )
.properties("genre").with("Neptune#ml.classification")
.has(value, P.within("Action", "Horror"))
```
Sie können mithilfe des Prädikats `Neptune#ml.score` einen Konfidenzwert für die Knotenklassifizierung abrufen:
```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V( "movie_1", "movie_2", "movie_3" )
.properties("genre", "Neptune#ml.score").with("Neptune#ml.classification")
```
Die Antwort würde wie folgt aussehen:
```
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.01234567]
==>vp[genre->Crime]
==>vp[Neptune#ml.score->0.543210]
==>vp[genre->Comedy]
==>vp[Neptune#ml.score->0.10101]
```
## Verwenden der induktiven Inferenz in einer Abfrage zur Knotenklassifizierung
Angenommen, Sie fügen einem vorhandenen Diagramm in einem Jupyter-Notebook einen neuen Knoten wie folgt hinzu:
```
%%gremlin
g.addV('label1').property(id,'101').as('newV')
.V('1').as('oldV1')
.V('2').as('oldV2')
.addE('eLabel1').from('newV').to('oldV1')
.addE('eLabel2').from('oldV2').to('newV')
```
Sie könnten dann eine induktive Inferenzabfrage verwenden, um ein Genre und einen Konfidenzwert abzurufen, die den neuen Knoten widerspiegeln:
```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').properties("genre", "Neptune#ml.score")
.with("Neptune#ml.classification")
.with("Neptune#ml.inductiveInference")
```
Wenn Sie die Abfrage jedoch mehrmals ausgeführt haben, erhalten Sie möglicherweise etwas andere Ergebnisse:
```
# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.21365921]
```
Sie könnten dieselbe Abfrage deterministisch machen:
```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').properties("genre", "Neptune#ml.score")
.with("Neptune#ml.classification")
.with("Neptune#ml.inductiveInference")
.with("Neptune#ml.deterministic")
```
In diesem Fall wären die Ergebnisse jedes Mal ungefähr gleich:
```
# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
```
# Gremlin-Abfragen zur Knotenregression in Neptune ML
Die Knotenregression ist der Knotenklassifizierung ähnlich. Der aus dem Regressionsmodell für jeden Knoten abgeleitete Wert ist jedoch numerisch. Sie können für die Knotenregression die gleichen Gremlin-Abfragen wie für die Knotenklassifizierung verwenden, mit einigen Unterschieden:
+ In Neptune ML beziehen sich Knoten auf Eckpunkte.
+ Der Schritt `properties()` hat statt `properties().with("Neptune#ml.regression")` das Format `properties().with("Neptune#ml.classification")`.
+ Die Prädikate `"Neptune#ml.limit` und `"Neptune#ml.threshold"` sind nicht anwendbar.
+ Wenn Sie nach dem Wert filtern, müssen Sie einen numerischen Wert angeben.
Dies ist ein Beispiel für eine Abfrage zur Eckklassifizierung:
```
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1","movie_2","movie_3")
.properties("revenue").with("Neptune#ml.regression")
```
Sie können mithilfe eines Regressionsmodells nach dem abgeleiteten Wert filtern, wie in den folgenden Beispielen gezeigt:
```
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1","movie_2","movie_3")
.properties("revenue").with("Neptune#ml.regression")
.value().is(P.gte(1600000))
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1","movie_2","movie_3")
.properties("revenue").with("Neptune#ml.regression")
.hasValue(P.lte(1600000D))
```
## Verwenden der induktiven Inferenz in einer Knotenregressionsabfrage
Angenommen, Sie fügen einem vorhandenen Diagramm in einem Jupyter-Notebook einen neuen Knoten wie folgt hinzu:
```
%%gremlin
g.addV('label1').property(id,'101').as('newV')
.V('1').as('oldV1')
.V('2').as('oldV2')
.addE('eLabel1').from('newV').to('oldV1')
.addE('eLabel2').from('oldV2').to('newV')
```
Sie könnten dann eine induktive Inferenzabfrage verwenden, um eine Bewertung zu erhalten, die den neuen Knoten berücksichtigt:
```
%%gremlin
g.with("Neptune#ml.endpoint", "nr-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').properties("rating")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
```
Da die Abfrage nicht deterministisch ist, kann sie je nach Nachbarschaft zu etwas anderen Ergebnissen führen, wenn Sie sie mehrmals ausführen:
```
# First time
==>vp[rating->9.1]
# Second time
==>vp[rating->8.9]
```
Wenn Sie konsistentere Ergebnisse benötigen, können Sie die Abfrage deterministisch gestalten:
```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').properties("rating")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
.with("Neptune#ml.deterministic")
```
Jetzt werden die Ergebnisse jedes Mal ungefähr gleich sein:
```
# First time
==>vp[rating->9.1]
# Second time
==>vp[rating->9.1]
```
# Gremlin-Kantenklassifizierungsabfragen in Neptune ML
Für die Gremlin-Kantenklassifizierung in Neptune ML:
+ Das Modell wird anhand einer einzelnen Eigenschaft der Kanten trainiert. Der Satz der eindeutigen Werte dieser Eigenschaft wird als Satz von Klassen bezeichnet.
+ Der Klassen- oder kategorische Eigenschaftswert einer Kante kann aus dem Kantenklassifizierungsmodell abgeleitet werden. Dies ist nützlich, wenn diese Eigenschaft noch nicht mit der Kante verknüpft ist.
+ Um eine oder mehrere Klassen aus einem Kantenklassifikationsmodell abzurufen, müssen Sie den Schritt `with()` mit dem Prädikat `"Neptune#ml.classification"` verwenden, um den Schritt `properties()` zu konfigurieren. Das Ausgabeformat ist dem Ausgabeformat für Kanteneigenschaften ähnlich.
**Anmerkung**
Die Kantenklassifizierung funktioniert nur mit Zeichenfolgen-Eigenschaftswerten. Das bedeutet, dass numerische Eigenschaftswerte wie `0` oder `1` nicht unterstützt werden, auch wenn die Zeichenfolgenäquivalente `"0"` und `"1"` unterstützt werden. Ähnlich funktionieren die booleschen Eigenschaftswerte `true` und `false` nicht, während `"true"` und `"false"` funktionieren.
Dies ist ein Beispiel für eine Abfrage zur Kantenklassifizierung, bei der mithilfe des Prädikats `Neptune#ml.score` ein Konfidenzwert angefordert wird:
```
g.with("Neptune#ml.endpoint","edge-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("relationship_1","relationship_2","relationship_3")
.properties("knows_by", "Neptune#ml.score").with("Neptune#ml.classification")
```
Die Antwort würde wie folgt aussehen:
```
==>p[knows_by->"Family"]
==>p[Neptune#ml.score->0.01234567]
==>p[knows_by->"Friends"]
==>p[Neptune#ml.score->0.543210]
==>p[knows_by->"Colleagues"]
==>p[Neptune#ml.score->0.10101]
```
## Syntax einer Gremlin-Kantenklassifizierungsabfrage
Für ein einfaches Diagramm, in dem `User` der Kopf- und Endknoten ist und `Relationship` die Kante ist, die sie verbindet, wäre dies beispielsweise eine Abfrage zur Kantenklassifizierung:
```
g.with("Neptune#ml.endpoint","edge-classification-social-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("relationship_1","relationship_2","relationship_3")
.properties("knows_by").with("Neptune#ml.classification")
```
Die Ausgabe dieser Abfrage sieht ähnlich wie folgt aus:
```
==>p[knows_by->"Family"]
==>p[knows_by->"Friends"]
==>p[knows_by->"Colleagues"]
```
In der Abfrage oben werden die Schritte `E()` und `properties()` wie folgt verwendet:
+ Der Schritt `E()` enthält den Satz von Kanten, für die Sie die Klassen aus dem Kantenklassifizierungsmodell abrufen möchten:
```
.E("relationship_1","relationship_2","relationship_3")
```
+ Der Schritt `properties()` enthält den Schlüssel, mit dem das Modell trainiert wurde, und besitzt `.with("Neptune#ml.classification")`, um anzugeben, dass es sich um eine ML-Inferenzabfrage zur Kantenklassifizierung handelt.
Der Schritt `properties().with("Neptune#ml.classification")` unterstützt zurzeit mehrere Eigenschaftsschlüssel nicht. Die folgende Abfrage löst beispielsweise eine Ausnahme aus:
```
g.with("Neptune#ml.endpoint","edge-classification-social-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("relationship_1","relationship_2","relationship_3")
.properties("knows_by", "other_label").with("Neptune#ml.classification")
```
Spezifische Fehlermeldungen finden Sie unter [Liste der Ausnahmen für Neptune-ML-Gremlin-Inferenzabfragen](machine-learning-gremlin-exceptions.md).
Der Schritt `properties().with("Neptune#ml.classification")` kann in Kombination mit einem der folgenden Schritte verwendet werden:
+ `value()`
+ `value().is()`
+ `hasValue()`
+ `has(value,"")`
+ `key()`
+ `key().is()`
+ `hasKey()`
+ `has(key,"")`
+ `path()`
## Verwenden der induktiven Inferenz in einer Abfrage zur Kantenklassifizierung
Angenommen, Sie fügen einem vorhandenen Diagramm in einem Jupyter-Notebook eine neue Kante wie folgt hinzu:
```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```
Sie könnten dann eine induktive Inferenzabfrage verwenden, um eine Skala zu erhalten, die die neue Kante berücksichtigt:
```
%%gremlin
g.with("Neptune#ml.endpoint", "ec-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("scale", "Neptune#ml.score")
.with("Neptune#ml.classification")
.with("Neptune#ml.inductiveInference")
```
Da die Abfrage nicht deterministisch ist, kann sie je nach randomisierter Nachbarschaft zu etwas anderen Ergebnissen führen, wenn sie mehrmals ausgeführt wird:
```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.21365921]
```
Wenn Sie konsistentere Ergebnisse benötigen, können Sie die Abfrage deterministisch gestalten:
```
%%gremlin
g.with("Neptune#ml.endpoint", "ec-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("scale", "Neptune#ml.score")
.with("Neptune#ml.classification")
.with("Neptune#ml.inductiveInference")
.with("Neptune#ml.deterministic")
```
Jetzt sind die Ergebnisse bei jeder Ausführung der Abfrage mehr oder weniger gleich:
```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
```
# Gremlin-Abfragen zur Kantenregression in Neptune ML
Die Kantenregression ist der Kantenklassifizierung ähnlich. Der aus dem ML-Modell abgeleitete Wert ist jedoch numerisch. Neptune ML unterstützt für die Kantenregression dieselben Abfragen wie für die Klassifizierung.
Wichtige Punkte, die beachtet werden müssen, sind:
+ Sie müssen das ML-Prädikat `"Neptune#ml.regression"` verwenden, um den Schritt `properties()` für diesen Anwendungsfall zu konfigurieren.
+ Die Prädikate `"Neptune#ml.limit"` und `"Neptune#ml.threshold"` sind in diesem Anwendungsfall nicht anwendbar.
+ Um nach dem Wert zu filtern, müssen Sie den Wert als numerisch angeben.
## Syntax einer Gremlin-Kantenregressionsabfrage
Für ein einfaches Diagramm, bei dem `User` der Kopfknoten, `Movie` der Endknoten und `Rated` die Kante ist, die diese verbindet, wäre dies ein Beispiel für eine Kantenregressionsabfrage, die den numerischen Wert der Bewertung (hier als Punktzahl bezeichnet) für die Kante `Rated` sucht:
```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("rating_1","rating_2","rating_3")
.properties("score").with("Neptune#ml.regression")
```
Sie können auch nach einem Wert filtern, der aus dem ML-Regressionsmodell abgeleitet wurde. Für die vorhandenen `Rated`-Kanten (von `User` bis`Movie`), identifiziert durch`"rating_1"`, `"rating_2"` und `"rating_3"`, wobei die Kanteneigenschaft `Score` für diese Bewertungen nicht vorhanden ist, können Sie eine Abfrage wie die folgende verwenden, um `Score` für die Kanten abzuleiten, deren Wert größer oder gleich 9 ist:
```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("rating_1","rating_2","rating_3")
.properties("score").with("Neptune#ml.regression")
.value().is(P.gte(9))
```
## Verwenden der induktiven Inferenz in einer Kantenregressionsabfrage
Angenommen, Sie fügen einem vorhandenen Diagramm in einem Jupyter-Notebook eine neue Kante wie folgt hinzu:
```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```
Sie könnten dann eine induktive Inferenzabfrage verwenden, um eine Punktzahl zu erhalten, die die neue Kante berücksichtigt:
```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("score")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
```
Da die Abfrage nicht deterministisch ist, kann sie je nach randomisierter Nachbarschaft zu etwas anderen Ergebnissen führen, wenn sie mehrmals ausgeführt wird:
```
# First time
==>ep[score->96]
# Second time
==>ep[score->91]
```
Wenn Sie konsistentere Ergebnisse benötigen, können Sie die Abfrage deterministisch gestalten:
```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("score")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
.with("Neptune#ml.deterministic")
```
Jetzt sind die Ergebnisse bei jeder Ausführung der Abfrage mehr oder weniger gleich:
```
# First time
==>ep[score->96]
# Second time
==>ep[score->96]
```
# Gremlin-Linkvorhersageabfragen mit Linkvorhersagemodellen in Neptune ML
Modelle zur Linkvorhersage können Probleme wie die folgenden lösen:
+ **Vorhersage des Kopfknotens**: Mit welchen Eckpunkten ist ein bestimmter Eckpunkt wahrscheinlich verbunden, wenn ein Eckpunkt und ein Kantentyp vorhanden sind?
+ **Vorhersage des Endknotens**: Mit welchen Eckpunkten ist ein bestimmter Eckpunkt wahrscheinlich verbunden, wenn ein Eckpunkt und eine Kantenbezeichnung vorhanden sind?
**Anmerkung**
Die Kantenvorhersage wird in Neptune ML noch nicht unterstützt.
Stellen Sie sich für die folgenden Beispiele ein einfaches Diagramm mit den Eckpunkten `User` und `Movie` vor, die durch die Kante `Rated` verbunden sind.
Dies ist ein Beispiel für eine Abfrage zur Vorhersage des Kopfknotens, um die fünf Benutzer vorherzusagen, die die Filme `"movie_1"`, `"movie_2"` und `"movie_3"` am wahrscheinlichsten bewerten werden:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.with("Neptune#ml.limit", 5)
.V("movie_1", "movie_2", "movie_3")
.in("rated").with("Neptune#ml.prediction").hasLabel("user")
```
Dies ist eine ähnliche Abfrage zur Vorhersage des Endknotens, um die fünf Filme vorherzusagen, die der Benutzer `"user_1"` wahrscheinlich bewerten wird:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out("rated").with("Neptune#ml.prediction").hasLabel("movie")
```
Sowohl die Kantenbezeichnung als auch die vorhergesagte Eckpunktbezeichnung sind erforderlich. Wird eins von beiden ausgelassen, wird eine Ausnahme ausgelöst. Beispielsweise löst die folgende Abfrage ohne vorhergesagte Eckpunktbezeichnung eine Ausnahme aus:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out("rated").with("Neptune#ml.prediction")
```
In ähnlicher Weise löst die folgende Abfrage ohne Kantenbezeichnung eine Ausnahme aus:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out().with("Neptune#ml.prediction").hasLabel("movie")
```
Die spezifische, von diesen Ausnahmen zurückgegebene Fehlermeldung finden Sie in der [Liste der Neptune-ML-Ausnahmen](machine-learning-gremlin-exceptions.md).
## Weitere Abfragen zur Linkvorhersage
Sie können Schritt `select()` mit Schritt `as(`) verwenden, um die vorhergesagten Eckpunkte zusammen mit den eingegebenen Eckpunkten auszugeben:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1").as("source")
.in("rated").with("Neptune#ml.prediction").hasLabel("user").as("target")
.select("source","target")
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1").as("source")
.out("rated").with("Neptune#ml.prediction").hasLabel("movie").as("target")
.select("source","target")
```
Sie können unbegrenzte Abfragen wie die folgenden erstellen:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out("rated").with("Neptune#ml.prediction").hasLabel("movie")
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1")
.in("rated").with("Neptune#ml.prediction").hasLabel("user")
```
## Verwenden der induktiven Inferenz in einer Linkvorhersageabfrage
Angenommen, Sie fügen einem vorhandenen Diagramm in einem Jupyter-Notebook einen neuen Knoten wie folgt hinzu:
```
%%gremlin
g.addV('label1').property(id,'101').as('newV1')
.addV('label2').property(id,'102').as('newV2')
.V('1').as('oldV1')
.V('2').as('oldV2')
.addE('eLabel1').from('newV1').to('oldV1')
.addE('eLabel2').from('oldV2').to('newV2')
```
Sie könnten dann eine induktive Inferenzabfrage verwenden, um den Kopfknoten unter Berücksichtigung des neuen Knotens vorherzusagen:
```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').out("eLabel1")
.with("Neptune#ml.prediction")
.with("Neptune#ml.inductiveInference")
.hasLabel("label2")
```
Ergebnis:
```
==>V[2]
```
Sie könnten dann auf ähnliche Weise mit einer induktiven Inferenzabfrage den Endknoten unter Berücksichtigung des neuen Knotens vorhersagen:
```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('102').in("eLabel2")
.with("Neptune#ml.prediction")
.with("Neptune#ml.inductiveInference")
.hasLabel("label1")
```
Ergebnis:
```
==>V[1]
```
# Liste der Ausnahmen für Neptune-ML-Gremlin-Inferenzabfragen
Dies ist eine umfassende Liste von Ausnahmen, die bei der Ausführung von Neptune ML Gremlin-Inferenzabfragen auftreten können. Diese Ausnahmen decken eine Reihe von Problemen ab, von Problemen mit der angegebenen IAM-Rolle oder dem angegebenen Endpunkt bis hin zu nicht unterstützten Gremlin-Schritten und Einschränkungen bei der Anzahl der ML-Inferenzabfragen pro Abfrage. Jeder Eintrag enthält eine ausführliche Meldung, in der das Problem beschrieben wird.
+ **`BadRequestException`** – Die Anmeldeinformationen für die angegebene Rolle können nicht geladen werden.
*Meldung*: `Unable to load credentials for role: the specified IAM Role ARN.`
+ **`BadRequestException`**— Die angegebene IAM-Rolle ist nicht berechtigt, den SageMaker KI-Endpunkt aufzurufen.
*Meldung*: `User: the specified IAM Role ARN is not authorized to perform: sagemaker:InvokeEndpoint on resource: the specified endpoint.`
+ **`BadRequestException`** – Der angegebene Endpunkt ist nicht vorhanden.
*Meldung*: `Endpoint the specified endpoint not found.`
+ **`InternalFailureException`** – Es können keine Neptune-ML-Metadaten für induktive Inferenzen in Echtzeit aus Amazon S3 abgerufen werden.
*Meldung*: `Unable to fetch Neptune ML - Real-Time Inductive Inference metadata from S3. Check the permissions of the S3 bucket or if the Neptune instance can connect to S3.`
+ **`InternalFailureException`** – Neptune ML kann die Metadatendatei für induktive Inferenzen in Echtzeit nicht in Amazon S3 finden.
*Meldung*: `Neptune ML cannot find the metadata file for Real-Time Inductive Inference in S3.`
+ **`InvalidParameterException`** – Die Syntax des angegebenen Endpunkts ist nicht gültig.
*Meldung*: `Invalid endpoint provided for external service query.`
+ **`InvalidParameterException`**— Der angegebene SageMaker Ausführungs-IAM-Rollen-ARN ist syntaktisch nicht gültig.
*Meldung*: `Invalid IAM role ARN provided for external service query.`
+ **`InvalidParameterException`** – In Schritt `properties()` einer Abfrage sind mehrere Eigenschaftsschlüssel angegeben.
*Meldung*: `ML inference queries are currently supported for one property key.`
+ **`InvalidParameterException`** – In einer Abfrage sind mehrere Kantenbezeichnungen angegeben.
*Meldung*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`** – In einer Abfrage sind mehrere Einschränkungen für Eckpunktbezeichnungen angegeben.
*Meldung*: `ML inference are currently supported only with one vertex label constraint.`
+ **`InvalidParameterException`** – In derselben Abfrage sind sowohl das Prädikat `Neptune#ml.classification` als auch das Prädikat `Neptune#ml.regression` vorhanden.
*Meldung*: `Both regression and classification ML predicates cannot be specified in the query.`
+ **`InvalidParameterException`** – In Schritt `in()` oder `out()` einer Abfrage zur Linkvorhersage wurde mehr als eine Kantenbezeichnung angegeben.
*Meldung*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`** – Es wurde mehr als ein Eigenschaftsschlüssel mit Neptune\$1ml.score angegeben.
*Meldung*: `Neptune ML inference queries are currently supported for one property key and one Neptune#ml.score property key.`
+ **`MissingParameterException`** – Der Endpunkt wurde weder in der Abfrage noch als DB-Cluster-Parameter angegeben.
*Meldung*: `No endpoint provided for external service query.`
+ **``MissingParameterException**— Die IAM-Rolle für die SageMaker AI-Ausführung wurde weder in der Abfrage noch als DB-Cluster-Parameter angegeben.
*Meldung*: `No IAM role ARN provided for external service query.`
+ **`MissingParameterException`** – In Schritt `properties()` einer Abfrage fehlt der Eigenschaftsschlüssel.
*Meldung*: `Property key needs to be specified using properties() step for ML inference queries.`
+ **`MissingParameterException`** – In Schritt `in()` oder `out()` einer Abfrage zur Linkvorhersage wurde keine Kantenbezeichnung angegeben.
*Meldung*: `Edge label needs to be specified while using in() or out() step for ML inference queries.`
+ **`MissingParameterException`** – Es wurde kein Eigenschaftsschlüssel mit Neptune\$1ml.score angegeben.
*Meldung*: `Property key needs to be specified along with Neptune#ml.score property key while using the properties() step for Neptune ML inference queries.`
+ **`UnsupportedOperationException`** – In einer Abfrage zur Linkvorhersage wird Schritt `both()` verwendet.
*Meldung*: `ML inference queries are currently not supported with both() step.`
+ **`UnsupportedOperationException`** – In Schritt `has()` mit Schritt `in()` oder `out()` einer Abfrage zur Linkvorhersage-Abfrage wurde keine vorhergesagte Eckpunktbezeichnung angegeben.
*Meldung*: `Predicted vertex label needs to be specified using has() step for ML inference queries.`
+ **`UnsupportedOperationException`** – Induktive Gremlin-ML-Inferenzabfragen werden zurzeit nicht mit nicht optimierten Schritten unterstützt.
*Meldung*: `Neptune ML - Real-Time Inductive Inference queries are currently not supported with Gremlin steps which are not optimized for Neptune. Check the Neptune User Guide for a list of Neptune-optimized steps.`
+ **`UnsupportedOperationException`** – Neptune-ML-Inferenzabfragen werden zurzeit nicht innerhalb des Schritts `repeat` unterstützt.
*Meldung*: `Neptune ML inference queries are currently not supported inside a repeat step.`
+ **`UnsupportedOperationException`** – Zurzeit wird nur eine Neptune-ML-Inferenzabfrage pro Gremlin-Abfrage unterstützt.
*Meldung*: `Neptune ML inference queries are currently supported only with one ML inference query per gremlin query.`
# SPARQL-Inferenzabfragen in Neptune ML
Neptune ML setzt das RDF-Diagramm in ein Eigenschaftsdiagramm um, um die ML-Aufgabe zu modellieren. Derzeit werden die folgenden Anwendungsfälle unterstützt:
+ **Objektklassifizierung** – Vorhersage des kategorischen Features eines Objekts.
+ **Objektregression** – Vorhersage der numerischen Eigenschaft eines Objekts.
+ **Objektvorhersage** – Vorhersage eines Objekts anhand eines Subjekts und einer Beziehung.
+ **Subjektvorhersage** – Vorhersage eines Subjekts anhand eines Objekts und einer Beziehung.
**Anmerkung**
Neptune ML unterstützt keine Anwendungsfälle für Subjektklassifizierung und -regression mit SPARQL.
# In SPARQL-Inferenzabfragen verwendete Neptune-ML-Prädikate
Die folgenden Prädikate werden für SPARQL-Inferenzen verwendet:
## Prädikat
Gibt das Timeout für die Verbindung mit dem Remoteserver an. Dies sollte nicht mit dem Timeout für Abfrageanforderungen verwechselt werden, bei dem es sich um die maximale Zeit handelt, die der Server für die Bearbeitung einer Anforderung benötigen darf.
Wenn das Abfragetimeout vor dem durch das Prädikat `neptune-ml:timeout` angegebenen Service-Timeout eintritt, wird auch die Service-Verbindung abgebrochen.
## Prädikat `neptune-ml:outputClass`
Das Prädikat `neptune-ml:outputClass` wird nur für die Definition der Klasse des vorhergesagten Objekts für die Objektvorhersage oder des vorhergesagten Subjekts für die Subjektvorhersage verwendet.
## Prädikat `neptune-ml:outputScore`
Das Prädikat `neptune-ml:outputScore` ist eine positive Zahl zur Darstellung der Wahrscheinlichkeit, mit der die Ausgabe eines Machine-Learning-Modells korrekt ist.
## Prädikat `neptune-ml:modelType`
Das Prädikat `neptune-ml:modelType` gibt den Typ des Machine-Learning-Modells an, das trainiert wird:
+ `OBJECT_CLASSIFICATION`
+ `OBJECT_REGRESSION`
+ `OBJECT_PREDICTION`
+ `SUBJECT_PREDICTION`
## Prädikat `neptune-ml:input`
Das `neptune-ml:input` Prädikat bezieht sich auf die Liste der als Eingaben für Neptune ML URIs verwendeten.
## Prädikat `neptune-ml:output`
Das Prädikat `neptune-ml:output` verweist auf die Liste der Bindungssätze, in denen Neptune ML Ergebnisse zurückgibt.
## Prädikat `neptune-ml:predicate`
Das Prädikat `neptune-ml:predicate` wird je nach ausgeführter Aufgabe unterschiedlich verwendet:
+ Für die **Objekt- oder Subjektvorhersage**: Definition des Typs des Prädikats (Kanten- oder Beziehungstyp).
+ Für die **Objektklassifizierung und -regression**: Definition des Literals (der Eigenschaft), die vorhergesagt werden soll.
## Prädikat `neptune-ml:batchSize`
Das Prädikat `neptune-ml:batchSize` gibt die Eingabegröße für den Remote-Serviceaufruf an.
# Beispiele für die SPARQL-Objektklassifizierung
Für die SPARQL-Objektklassifizierung in Neptune ML wird das Modell anhand eines Prädikatwerts trainiert. Dies ist nützlich, wenn das betreffende Prädikat für ein bestimmtes Subjekt noch nicht vorhanden ist.
Mit dem Objektklassifizierungsmodell können nur kategorische Prädikatwerte abgeleitet werden.
Die folgende Abfrage versucht, den Prädikatwert für für alle Eingaben des Typs `foaf:Person` vorherzusagen:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'OBJECT_CLASSIFICATION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
Diese Abfrage kann wie folgt angepasst werden:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ;
neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;
neptune-ml:batchSize "40"^^xsd:integer ;
neptune-ml:timeout "1000"^^xsd:integer ;
neptune-ml:modelType 'OBJECT_CLASSIFICATION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
# Beispiele für die SPARQL-Objektregression
Die Objektregression ist der Objektklassifizierung ähnlich. Der aus dem Regressionsmodell für jeden Knoten abgeleitete Prädikatwert ist jedoch numerisch. Sie können für die Objektregression dieselben SPARQL-Abfragen wie für die Objektklassifizierung verwenden, mit der Ausnahme, dass die Prädikate `the Neptune#ml.limit` und `Neptune#ml.threshold` nicht anwendbar sind.
Die folgende Abfrage versucht, den Prädikatwert für für alle Eingaben des Typs `foaf:Person` vorherzusagen:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'OBJECT_REGRESSION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
Diese Abfrage kann wie folgt angepasst werden:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ;
neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;
neptune-ml:batchSize "40"^^xsd:integer ;
neptune-ml:timeout "1000"^^xsd:integer ;
neptune-ml:modelType 'OBJECT_REGRESSION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
# Beispiel für eine SPARQL-Objektvorhersage
Die *Objektvorhersage* sagt den Objektwert für ein bestimmtes Subjekt und Prädikat voraus.
Mit der folgenden Abfrage zur Objektvorhersage soll vorhergesagt werden, welchen Film eine Eingabe des Typs `foaf:Person` mit einem „Like“ bewerten würde:
```
?x a foaf:Person .
?x ?m .
?m a .
## Query
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'OBJECT_PREDICTION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output ;
neptune-ml:outputClass .
}
}
```
Die Abfrage selbst könnte wie folgt angepasst werden:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:endpoint 'node-prediction-user-movie-prediction-endpoint' ;
neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;
neptune-ml:limit "5"^^xsd:integer ;
neptune-ml:batchSize "40"^^xsd:integer ;
neptune-ml:threshold "0.1"^^xsd:double ;
neptune-ml:timeout "1000"^^xsd:integer ;
neptune-ml:outputScore ?score ;
neptune-ml:modelType 'OBJECT_PREDICTION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output ;
neptune-ml:outputClass .
}
}
```
# Beispiel für eine SPARQL-Subjektvorhersage
Die *Subjektvorhersage* sagt den Subjektwert für ein bestimmtes Objekt und Prädikat voraus.
Die folgende Abfrage sagt beispielsweise voraus, wer (des Typs `foaf:User`) sich einen bestimmten Film ansehen wird:
```
SELECT * WHERE { ?input (a foaf:Movie) .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'SUBJECT_PREDICTION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output ;
neptune-ml:outputClass ; }
}
```
# Liste der Ausnahmen für Neptune-ML-SPARQL-Inferenzabfragen
****
+ **`BadRequestException`** – *Meldung*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at least 1 value for the parameter (parameter name), found zero.`
+ **`BadRequestException`** – *Meldung*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at most 1 value for the parameter (parameter name), found (a number) values.`
+ **`BadRequestException`** – *Meldung*: `Invalid predicate (predicate name) provided for external service http://aws.amazon.com/neptune/vocab/v01/services/ml#inference query.`
+ **`BadRequestException`** – *Meldung*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the predicate (predicate name) to be defined`
+ **`BadRequestException`** – *Meldung*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the value of (parameter) (parameter name) to be a variable, found: (type)"`
+ **`BadRequestException`** – *Meldung*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the input (parameter name) to be a constant, found: (type)`
+ **`BadRequestException`** – *Meldung*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference is expected to return only 1 value`
+ **`BadRequestException`** – *Meldung*: `"The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference only allows StatementPatternNodes`
+ **`BadRequestException`** – *Meldung*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference does not allow the predicate (predicate name)`
+ **`BadRequestException`** – *Meldung*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates cannot be variables, found: (type)`
+ **`BadRequestException`** – *Meldung*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates are expected to be part of the namespace (namespace name), found: (namespace name)`
# Neptune-ML-Management-API-Referenz
**Contents**
+ [Der Datenverarbeitungsbefehl](machine-learning-api-dataprocessing.md)
+ [Erstellen eines Datenverarbeitungsauftrags](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-create-job)
+ [Abrufen des Auftragsstatus](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-get-job-status)
+ [Stoppen eines Auftrags](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-stop-job)
+ [Auflisten von Aufträgen](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-list-jobs)
+ [Der Befehl modeltraining](machine-learning-api-modeltraining.md)
+ [Erstellen eines Modelltrainingsauftrags](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job)
+ [Abrufen des Auftragsstatus](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-get-job-status)
+ [Stoppen eines Auftrags](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-stop-job)
+ [Auflisten von Aufträgen](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-list-jobs)
+ [Der Befehl modeltransform](machine-learning-api-modeltransform.md)
+ [Erstellen eines Modelltransformationsauftrags](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-create-job)
+ [Abrufen des Auftragsstatus](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-get-job-status)
+ [Stoppen eines Auftrags](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-stop-job)
+ [Auflisten von Aufträgen](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-list-jobs)
+ [Der Befehl endpoints](machine-learning-api-endpoints.md)
+ [Erstellen eines Inferenzendpunkts](machine-learning-api-endpoints.md#machine-learning-api-endpoints-create-job)
+ [Abrufen des Endpunktstatus](machine-learning-api-endpoints.md#machine-learning-api-endpoints-get-endpoint-status)
+ [Löschen eines Endpunkts](machine-learning-api-endpoints.md#machine-learning-api-endpoints-delete-endpoint)
+ [Auflisten von Inferenzendpunkten](machine-learning-api-endpoints.md#machine-learning-api-endpoints-list-endpoints)
+ [Ausnahmen](machine-learning-api-exceptions.md)
# Datenverarbeitung mit dem Befehl `dataprocessing`
Mit dem Neptune-ML-Befehl `dataprocessing` können Sie einen Datenverarbeitungsauftrag erstellen, dessen Status überprüfen, ihn beenden oder alle aktiven Datenverarbeitungsaufträge auflisten.
## Erstellen eines Datenverarbeitungsauftrags mit dem Neptune-ML-Befehl `dataprocessing`
Der Neptune-ML-Befehl `dataprocessing` zum Erstellen eines neuen Auftrags sieht in der Regel wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/dataprocessing \
-H 'Content-Type: application/json' \
-d '{
"inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)",
"id" : "(a job ID for the new job)",
"processedDataS3Location" : "s3://(S3 bucket name)/(path to your output folder)"
}'
```
Ein Befehl zum Initiieren einer inkrementellen Neuverarbeitung sieht wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/dataprocessing \
-H 'Content-Type: application/json' \
-d '{
"inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)",
"id" : "(a job ID for this job)",
"processedDataS3Location" : "s3://(S3 bucket name)/(path to your output folder)"
"previousDataProcessingJobId" : "(the job ID of a previously completed job to update)"
}'
```
**Parameter für die Erstellung eines `dataprocessing`-Auftrags**
+ **`id`** – (*Optional*) Eine eindeutige ID für den neuen Auftrag.
*Typ:* Zeichenfolge. *Standardwert*: eine automatisch generierte UUID.
+ **`previousDataProcessingJobId`** – (*Optional*) Die Auftrags-ID eines abgeschlossenen Datenverarbeitungsauftrags, der für eine frühere Version der Daten ausgeführt wurde.
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
*Hinweis*: Verwenden Sie diese Option für die inkrementelle Datenverarbeitung, um das Modell zu aktualisieren, wenn die Diagrammdaten geändert wurden (jedoch nicht, wenn Daten gelöscht wurden).
+ **`inputDataS3Location`**— (*Erforderlich*) Die URI des Amazon S3 S3-Standorts, an den SageMaker KI die für die Ausführung des Datenverarbeitungsjobs erforderlichen Daten herunterladen soll.
*Typ:* Zeichenfolge.
+ **`processedDataS3Location`**— (*Erforderlich*) Die URI des Amazon S3 S3-Standorts, an dem SageMaker KI die Ergebnisse eines Datenverarbeitungsauftrags speichern soll.
*Typ:* Zeichenfolge.
+ **`sagemakerIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle für die SageMaker KI-Ausführung.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`neptuneIamRoleArn`**— (*Optional*) Der Amazon-Ressourcenname (ARN) einer IAM-Rolle, die SageMaker KI übernehmen kann, um Aufgaben in Ihrem Namen auszuführen.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`processingInstanceType`** – (*Optional*) Der Typ der ML-Instance, die während der Datenverarbeitung verwendet wird. Der Speicher sollte groß genug für den verarbeiteten Datensatz sein.
*Typ:* Zeichenfolge. *Standardwert*: Der kleinste `ml.r5`-Typ, dessen Arbeitsspeicher zehnmal größer als die Größe der exportierten Diagrammdaten auf der Festplatte ist.
*Hinweis*: Neptune ML kann den Instance-Typ automatisch auswählen. Siehe [Auswahl einer Instance für die Datenverarbeitung](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-processing-instance-size).
+ **`processingInstanceVolumeSizeInGB`** – (*Optional*) Die Größe des Festplattenvolumens der verarbeitenden Instance. Da sowohl Eingabedaten als auch verarbeitete Daten auf der Festplatte gespeichert werden, muss das Volume groß genug für beide Datensätze sein.
*Typ*: Ganzzahl. *Standardwert*: `0`.
*Hinweis*: Wenn nicht angegeben oder 0, wählt Neptune ML die Volume-Größe automatisch auf Grundlage der Datengröße aus.
+ **`processingTimeOutInSeconds`** – (*Optional*) Timeout in Sekunden für den Datenverarbeitungsauftrag.
*Typ*: Ganzzahl. *Default*: `86,400` (1 Tag).
+ **`modelType`** – (*Optional*) Einer der beiden Modelltypen, die Neptune ML zurzeit unterstützt: heterogene Diagrammmodelle (`heterogeneous`) und Wissensdiagramme (`kge`).
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
*Hinweis*: Wenn nicht angegeben, wählt Neptune ML dem Modelltyp automatisch auf Grundlage der Daten aus.
+ **`configFileName`** – (*Optional*) Eine Datenspezifikationsdatei, die das Laden der exportierten Diagrammdaten für das Training beschreibt. Die Datei wird automatisch vom Neptune-Export-Toolkit generiert.
*Typ:* Zeichenfolge. *Standardwert*: `training-data-configuration.json`.
+ **`subnets`**— (*Optional*) Die Subnetze in IDs der Neptune VPC.
*Typ*: Auflistung von Zeichenfolgen. *Standardwert*: *keiner*.
+ **`securityGroupIds`**— (*Optional*) Die VPC-Sicherheitsgruppe IDs.
*Typ*: Auflistung von Zeichenfolgen. *Standardwert*: *keiner*.
+ **`volumeEncryptionKMSKey`**— (*Optional*) Der Schlüssel AWS Key Management Service (AWS KMS), den SageMaker AI verwendet, um Daten auf dem Speichervolume zu verschlüsseln, das den ML-Compute-Instances zugeordnet ist, die den Verarbeitungsjob ausführen.
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
+ **`enableInterContainerTrafficEncryption`** – (*Optional*) Aktiviert oder deaktiviert die Verschlüsselung des Datenverkehrs zwischen Containern bei Trainings- oder Hyperparameter-Optimierungsaufträgen.
*Typ*: boolescher Wert. *Standardwert*: *True*.
**Anmerkung**
Der Parameter `enableInterContainerTrafficEncryption` ist nur in [Engine-Version 1.2.0.2.R3](engine-releases-1.2.0.2.R3.md) verfügbar.
+ **`s3OutputEncryptionKMSKey`**— (*Optional*) Der Schlüssel AWS Key Management Service (AWS KMS), den SageMaker KI verwendet, um die Ausgabe des Trainingsjobs zu verschlüsseln.
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
## Abrufen des Status eines Datenverarbeitungsauftrags mit dem Neptune ML-Befehl `dataprocessing`
Dies ist ein Beispiel für den Neptune-ML-Befehl `dataprocessing` für den Abruf des Status eines Auftrags:
```
curl -s \
"https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)" \
| python -m json.tool
```
**Parameter für den Abruf des Status des `dataprocessing`-Auftrags**
+ **`id`** – (*Erforderlich*) Die eindeutige ID des Datenverarbeitungsauftrags.
*Typ:* Zeichenfolge.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
## Stoppen eines Datenverarbeitungsauftrags mit dem Neptune-ML-Befehl `dataprocessing`
Dies ist ein Beispiel für den Neptune-ML-Befehl `dataprocessing` für das Stoppen eines Auftrags:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)"
```
Oder:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)?clean=true"
```
**Parameter für das Stoppen eines `dataprocessing`-Auftrags**
+ **`id`** – (*Erforderlich*) Die eindeutige ID des Datenverarbeitungsauftrags.
*Typ:* Zeichenfolge.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`clean`** – (*Optional*) Dieses Flag gibt an, dass alle Amazon-S3-Artefakte gelöscht werden sollen, wenn der Auftrag gestoppt wird.
*Typ*: boolescher Wert. *Standardwert*: `FALSE`.
## Auflisten aktiver Datenverarbeitungsaufträge mit dem Neptune-ML-Befehl `dataprocessing`
Dies ist ein Beispiel für den Neptune-ML-Befehl `dataprocessing` für das Auflisten aktiver Aufträge:
```
curl -s "https://(your Neptune endpoint)/ml/dataprocessing"
```
Oder:
```
curl -s "https://(your Neptune endpoint)/ml/dataprocessing?maxItems=3"
```
**Parameter für das Auflisten von `dataprocessing`-Aufträgen**
+ **`maxItems`** – (*Optional*) Die maximale Anzahl der Elemente, die zurückgegeben werden sollen.
*Typ*: Ganzzahl. *Standardwert*: `10`. *Maximal zulässiger Wert*: `1024`.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
# Modelltraining mit dem Befehl `modeltraining`
Mit dem Neptune-ML-Befehl `modeltraining` können Sie einen Modelltrainingsauftrag erstellen, seinen Status überprüfen, ihn beenden oder alle aktiven Modelltrainingsaufträge auflisten.
## Erstellen eines Modelltrainingsauftrags mit dem Neptune-ML-Befehl `modeltraining`
Ein Neptune-ML-Befehl `modeltraining` zum Erstellen eines vollständig neuen Auftrags sieht in der Regel wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
}'
```
Ein Neptune-ML-Befehl `modeltraining` zum Erstellen eines Aktualisierungsauftrags für das inkrementelle Modelltraining sieht wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"previousModelTrainingJobId" : "(the job ID of a completed model-training job to update)",
}'
```
Ein Neptune-ML-Befehl `modeltraining` zum Erstellen eines neuen Auftrags mit einer vom Benutzer bereitgestellten benutzerdefinierten Modellimplementierung sieht wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"modelName": "custom",
"customModelTrainingParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"trainingEntryPointScript": "(your training script entry-point name in the Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
**Parameter für die Erstellung eines `modeltraining`-Auftrags**
+ **`id`** – (*Optional*) Eine eindeutige ID für den neuen Auftrag.
*Typ:* Zeichenfolge. *Standardwert*: eine automatisch generierte UUID.
+ **`dataProcessingJobId`** – (*Erforderlich*) Die Auftrags-ID des abgeschlossenen Datenverarbeitungsauftrags, der die Daten für das Training erstellt hat.
*Typ:* Zeichenfolge.
+ **`trainModelS3Location`** – (*Erforderlich*) Der Speicherort in Amazon S3, an dem die Modellartefakte gespeichert werden sollen.
*Typ:* Zeichenfolge.
+ **`previousModelTrainingJobId`** – (*Optional*) Die Auftrags-ID eines abgeschlossenen Modelltrainingsauftrags, den Sie anhand von aktualisierten Daten schrittweise aktualisieren möchten.
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
+ **`sagemakerIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle für die SageMaker KI-Ausführung.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`modelName`** – (*Optional*) Der Modelltyp für das Training. Standardmäßig basiert das ML-Modell automatisch auf dem `modelType`, der in der Datenverarbeitung verwendet wird. Sie können hier jedoch einen anderen Modelltyp angeben.
*Typ:* Zeichenfolge. *Standardwert*: `rgcn` für heterogene Diagramme und `kge` für Wissensdiagramme. *Gültige Werte*: für heterogene Graphen: `rgcn`. Für `kge`-Diagramme: `transe`, `distmult` oder `rotate`. Für eine benutzerdefinierte Modellimplementierung: `custom`.
+ **`baseProcessingInstanceType`** – (*Optional*) Der Typ der ML-Instance, die zur Vorbereitung und Verwaltung des Trainings von ML-Modellen verwendet wird.
*Typ:* Zeichenfolge. *Hinweis*: Diese CPU-Instance wird anhand der Speicheranforderungen für die Verarbeitung von Trainingsdaten und Trainingsmodell ausgewählt. Siehe [Auswahl einer Instance für Modelltraining und Modelltransformation](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`trainingInstanceType`** – (*Optional*) Der Typ der ML-Instance, die für das Modelltraining verwendet wird. Alle Neptune-ML-Modelle unterstützen CPU-, GPU- und MultiGPU-Trainings.
*Typ:* Zeichenfolge. *Standardwert*: `ml.p3.2xlarge`.
*Hinweis*: Die Auswahl des richtigen Instance-Typs für ein Training ist von Aufgabentyp, Diagrammgröße und Budget abhängig. Siehe [Auswahl einer Instance für Modelltraining und Modelltransformation](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`trainingInstanceVolumeSizeInGB`** – (*Optional*) Die Größe des Festplatten-Volumes der Trainings-Instance. Da sowohl Eingabedaten als auch das Ausgabemodell auf der Festplatte gespeichert werden, muss das Volume groß genug für beide Datensätze sein.
*Typ*: Ganzzahl. *Standardwert*: `0`.
*Hinweis*: Wenn nicht angegeben oder 0, wählt Neptune ML die Größe des Festplatten-Volumes anhand der im Datenverarbeitungsschritt generierten Empfehlung aus. Siehe [Auswahl einer Instance für Modelltraining und Modelltransformation](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`trainingTimeOutInSeconds`** – (*Optional*) Timeout in Sekunden für den Trainingsauftrag.
*Typ*: Ganzzahl. *Default*: `86,400` (1 Tag).
+ **`maxHPONumberOfTrainingJobs`** – Maximale Gesamtzahl der Trainingsaufträge, die für den Hyperparameter-Optimierungsauftrag gestartet werden sollen.
*Typ*: Ganzzahl. *Standardwert*: `2`.
*Hinweis*: Neptune ML optimiert automatisch die Hyperparameter des Machine-Learning-Modells. Um ein Modell mit guter Leistung zu erhalten, müssen Sie mindestens 10 Aufträge verwenden (mit anderen Worten, `maxHPONumberOfTrainingJobs` auf 10 festlegen). Im Allgemeinen gilt: Je mehr Optimierungsausführungen, desto besser die Ergebnisse.
+ **`maxHPOParallelTrainingJobs`** – Maximale Anzahl der parallelen Trainingsaufträge, die für den Hyperparameter-Optimierungsauftrag gestartet werden sollen.
*Typ*: Ganzzahl. *Standardwert*: `2`.
*Hinweis*: Die Anzahl der parallelen Aufträge, die Sie ausführen können, wird durch die verfügbaren Ressourcen auf Ihrer Trainings-Instance begrenzt.
+ **`subnets`**— (*Optional*) Die Subnetze in IDs der Neptune VPC.
*Typ*: Auflistung von Zeichenfolgen. *Standardwert*: *keiner*.
+ **`securityGroupIds`**— (*Optional*) Die VPC-Sicherheitsgruppe IDs.
*Typ*: Auflistung von Zeichenfolgen. *Standardwert*: *keiner*.
+ **`volumeEncryptionKMSKey`**— (*Optional*) Der Schlüssel AWS Key Management Service (AWS KMS), den SageMaker KI verwendet, um Daten auf dem Speichervolume zu verschlüsseln, das den ML-Compute-Instances zugeordnet ist, die den Trainingsjob ausführen.
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
+ **`s3OutputEncryptionKMSKey`**— (*Optional*) Der Schlüssel AWS Key Management Service (AWS KMS), den SageMaker AI verwendet, um die Ausgabe des Verarbeitungsjobs zu verschlüsseln.
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
+ **`enableInterContainerTrafficEncryption`** – (*Optional*) Aktiviert oder deaktiviert die Verschlüsselung des Datenverkehrs zwischen Containern bei Trainings- oder Hyperparameter-Optimierungsaufträgen.
*Typ*: boolescher Wert. *Standardwert*: *True*.
**Anmerkung**
Der Parameter `enableInterContainerTrafficEncryption` ist nur in [Engine-Version 1.2.0.2.R3](engine-releases-1.2.0.2.R3.md) verfügbar.
+ **`enableManagedSpotTraining`**— (*Optional*) Optimiert die Kosten für das Training von Machine-Learning-Modellen mit Amazon-Elastic-Compute-Cloud-Spot-Instances. Weitere Informationen finden Sie unter [Managed Spot Training bei Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html).
*Typ*: boolescher Wert. *Standardwert*: *False*.
+ **`customModelTrainingParameters`** – (*Optional*) Die Konfiguration für das Training benutzerdefinierter Modelle. Dies ist ein JSON-Objekt mit den folgenden Feldern:
+ **`sourceS3DirectoryPath`** – (*Erforderlich*) Der Pfad zum Amazon-S3-Speicherort des Python-Moduls, das Ihr Modell implementiert. Dieser Pfad muss auf einen gültigen, vorhandenen Amazon-S3-Speicherort verweisen, der mindestens ein Trainingsskript, ein Transformationsskript und die Datei `model-hpo-configuration.json` enthält.
+ **`trainingEntryPointScript`** – (*Optional*) Der Name des Einstiegspunkts in Ihrem Modul für ein Skript, das Modelltrainings durchführt und Hyperparameter als Befehlszeilenargumente verwendet, einschließlich fester Hyperparameter.
*Standardwert*: `training.py`.
+ **`transformEntryPointScript`** – (*Optional*) Der Name des Einstiegspunkts in Ihrem Modul für ein Skript, das ausgeführt werden soll, nachdem das beste Modell aus der Hyperparametersuche identifiziert wurde, um die für die Modellbereitstellung notwendigen Modellartefakte zu berechnen. Es sollte ohne Befehlszeilenargumente ausgeführt werden können.
*Standardwert*: `transform.py`.
+ **`maxWaitTime`** – (*Optional*) Die maximale Wartezeit in Sekunden, wenn ein Modelltraining mit Spot-Instances durchgeführt wird. Der Wert sollte größer als `trainingTimeOutInSeconds` sein.
*Typ*: Ganzzahl.
## Abrufen des Status eines Modelltrainingsauftrags mit dem Neptune-ML-Befehl `modeltraining`
Dies ist ein Beispiel für den Neptune-ML-Befehl `modeltraining` für den Abruf des Status eines Auftrags:
```
curl -s \
"https://(your Neptune endpoint)/ml/modeltraining/(the job ID)" \
| python -m json.tool
```
**Parameter für den Abruf des Status des `modeltraining`-Auftrags**
+ **`id`** – (*Erforderlich*) Die eindeutige ID des Modelltrainingsauftrags.
*Typ:* Zeichenfolge.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
## Stoppen eines Modelltrainingsauftrags mit dem Neptune-ML-Befehl `modeltraining`
Dies ist ein Beispiel für den Neptune-ML-Befehl `modeltraining` für das Stoppen eines Auftrags:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)"
```
Oder:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)?clean=true"
```
**Parameter für das Stoppen eines `modeltraining`-Auftrags**
+ **`id`** – (*Erforderlich*) Die eindeutige ID des Modelltrainingsauftrags.
*Typ:* Zeichenfolge.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`clean`** – (*Optional*) Dieses Flag gibt an, dass alle Amazon-S3-Artefakte gelöscht werden sollen, wenn der Auftrag gestoppt wird.
*Typ*: boolescher Wert. *Standardwert*: `FALSE`.
## Auflisten aktiver Modelltrainingsaufträge mit dem Neptune-ML-Befehl `modeltraining`
Dies ist ein Beispiel für den Neptune-ML-Befehl `modeltraining` für das Auflisten aktiver Aufträge:
```
curl -s "https://(your Neptune endpoint)/ml/modeltraining" | python -m json.tool
```
Oder:
```
curl -s "https://(your Neptune endpoint)/ml/modeltraining?maxItems=3" | python -m json.tool
```
**Parameter für das Auflisten von `modeltraining`-Aufträgen**
+ **`maxItems`** – (*Optional*) Die maximale Anzahl der Elemente, die zurückgegeben werden sollen.
*Typ*: Ganzzahl. *Standardwert*: `10`. *Maximal zulässiger Wert*: `1024`.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
# Modelltransformation mit dem Befehl `modeltransform`
Mit dem Neptune-ML-Befehl `modeltransform` können Sie einen Modelltransformationsauftrag erstellen, seinen Status überprüfen, ihn beenden oder alle aktiven Modelltransformationsaufträge auflisten.
## Erstellen eines Modelltransformationsauftrags mit dem Neptune-ML-Befehl `modeltransform`
Ein Neptune-ML-Befehl `modeltransform` zum Erstellen eines inkrementellen Transformationsauftrags ohne erneutes Modelltraining sieht wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-transform job ID)",
"dataProcessingJobId" : "(the job-id of a completed data-processing job)",
"mlModelTrainingJobId" : "(the job-id of a completed model-training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform"
}'
```
Ein Neptune `modeltransform` ML-Befehl zum Erstellen eines Jobs aus einem abgeschlossenen SageMaker AI-Trainingsjob sieht so aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-transform job ID)",
"trainingJobName" : "(name of a completed SageMaker AI training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform",
"baseProcessingInstanceType" : ""
}'
```
Ein Neptune-ML-Befehl `modeltransform` zum Erstellen eines Auftrags mit einer benutzerdefinierten Modellimplementierung sieht wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"trainingJobName" : "(name of a completed SageMaker AI training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/"
"customModelTransformParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
**Parameter für die Erstellung eines `modeltransform`-Auftrags**
+ **`id`** – (*Optional*) Eine eindeutige ID für den neuen Auftrag.
*Typ:* Zeichenfolge. *Standardwert*: eine automatisch generierte UUID.
+ **`dataProcessingJobId`** – Die Auftrags-ID eines abgeschlossenen Datenverarbeitungsauftrags.
*Typ:* Zeichenfolge.
*Hinweis*: Sie müssen entweder `dataProcessingJobId` und `mlModelTrainingJobId` oder `trainingJobName` angeben.
+ **`mlModelTrainingJobId`** – Die Auftrags-ID eines abgeschlossenen Modelltrainingsauftrags.
*Typ:* Zeichenfolge.
*Hinweis*: Sie müssen entweder `dataProcessingJobId` und `mlModelTrainingJobId` oder `trainingJobName` angeben.
+ **`trainingJobName`**— Der Name eines abgeschlossenen SageMaker KI-Schulungsjobs.
*Typ:* Zeichenfolge.
*Hinweis*: Sie müssen entweder die Parameter `dataProcessingJobId` und `mlModelTrainingJobId` oder den Parameter `trainingJobName` angeben.
+ **`sagemakerIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle für die SageMaker KI-Ausführung.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`customModelTransformParameters `** – (*Optional*) Informationen zur Konfiguration einer Modelltransformation anhand eines benutzerdefinierten Modells. Das `customModelTransformParameters`-Objekt enthält die folgenden Felder, deren Werte mit den gespeicherten Modellparametern aus dem Trainingsauftrag kompatibel sein müssen:
+ **`sourceS3DirectoryPath`** – (*Erforderlich*) Der Pfad zum Amazon-S3-Speicherort des Python-Moduls, das Ihr Modell implementiert. Dieser Pfad muss auf einen gültigen, vorhandenen Amazon-S3-Speicherort verweisen, der mindestens ein Trainingsskript, ein Transformationsskript und die Datei `model-hpo-configuration.json` enthält.
+ **`transformEntryPointScript`** – (*Optional*) Der Name des Einstiegspunkts in Ihrem Modul für ein Skript, das ausgeführt werden soll, nachdem das beste Modell aus der Hyperparametersuche identifiziert wurde, um die für die Modellbereitstellung notwendigen Modellartefakte zu berechnen. Es sollte ohne Befehlszeilenargumente ausgeführt werden können.
*Standardwert*: `transform.py`.
+ **`baseProcessingInstanceType`** – (*Optional*) Der Typ der ML-Instance, die zur Vorbereitung und Verwaltung des Trainings von ML-Modellen verwendet wird.
*Typ:* Zeichenfolge. *Hinweis*: Diese CPU-Instance wird anhand der Speicheranforderungen für die Verarbeitung von Transformationsdaten und Transformationsmodell ausgewählt. Siehe [Auswahl einer Instance für Modelltraining und Modelltransformation](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`baseProcessingInstanceVolumeSizeInGB`** – (*Optional*) Die Größe des Festplatten-Volumes der Trainings-Instance. Da sowohl Eingabedaten als auch das Ausgabemodell auf der Festplatte gespeichert werden, muss das Volume groß genug für beide Datensätze sein.
*Typ*: Ganzzahl. *Standardwert*: `0`.
*Hinweis*: Wenn nicht angegeben oder 0, wählt Neptune ML die Größe des Festplatten-Volumes anhand der im Datenverarbeitungsschritt generierten Empfehlung aus. Siehe [Auswahl einer Instance für Modelltraining und Modelltransformation](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`subnets`**— (*Optional*) Die Subnetze in IDs der Neptune VPC.
*Typ*: Auflistung von Zeichenfolgen. *Standardwert*: *keiner*.
+ **`securityGroupIds`**— (*Optional*) Die VPC-Sicherheitsgruppe IDs.
*Typ*: Auflistung von Zeichenfolgen. *Standardwert*: *keiner*.
+ **`volumeEncryptionKMSKey`**— (*Optional*) Der Schlüssel AWS Key Management Service (AWS KMS), den SageMaker KI verwendet, um Daten auf dem Speichervolume zu verschlüsseln, das den ML-Compute-Instances zugeordnet ist, die den Transformationsjob ausführen.
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
+ **`enableInterContainerTrafficEncryption`** – (*Optional*) Aktiviert oder deaktiviert die Verschlüsselung des Datenverkehrs zwischen Containern bei Trainings- oder Hyperparameter-Optimierungsaufträgen.
*Typ*: boolescher Wert. *Standardwert*: *True*.
**Anmerkung**
Der Parameter `enableInterContainerTrafficEncryption` ist nur in [Engine-Version 1.2.0.2.R3](engine-releases-1.2.0.2.R3.md) verfügbar.
+ **`s3OutputEncryptionKMSKey`**— (*Optional*) Der Schlüssel AWS Key Management Service (AWS KMS), den SageMaker AI verwendet, um die Ausgabe des Verarbeitungsjobs zu verschlüsseln.
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
## Abrufen des Status eines Modelltransformationsauftrags mit dem Neptune-ML-Befehl `modeltransform`
Dies ist ein Beispiel für den Neptune-ML-Befehl `modeltransform` für den Abruf des Status eines Auftrags:
```
curl -s \
"https://(your Neptune endpoint)/ml/modeltransform/(the job ID)" \
| python -m json.tool
```
**Parameter für den Abruf des Status des `modeltransform`-Auftrags**
+ **`id`** – (*Erforderlich*) Die eindeutige ID des Modelltransformationsauftrags.
*Typ:* Zeichenfolge.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
## Stoppen eines Modelltransformationsauftrags mit dem Neptune-ML-Befehl `modeltransform`
Dies ist ein Beispiel für den Neptune-ML-Befehl `modeltransform` für das Stoppen eines Auftrags:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)"
```
Oder:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)?clean=true"
```
**Parameter für das Stoppen eines `modeltransform`-Auftrags**
+ **`id`** – (*Erforderlich*) Die eindeutige ID des Modelltransformationsauftrags.
*Typ:* Zeichenfolge.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`clean`** – (*Optional*) Dieses Flag gibt an, dass alle Amazon-S3-Artefakte gelöscht werden sollen, wenn der Auftrag gestoppt wird.
*Typ*: boolescher Wert. *Standardwert*: `FALSE`.
## Auflisten aktiver Modelltransformationsaufträge mit dem Neptune-ML-Befehl `modeltransform`
Dies ist ein Beispiel für den Neptune-ML-Befehl `modeltransform` für das Auflisten aktiver Aufträge:
```
curl -s "https://(your Neptune endpoint)/ml/modeltransform" | python -m json.tool
```
Oder:
```
curl -s "https://(your Neptune endpoint)/ml/modeltransform?maxItems=3" | python -m json.tool
```
**Parameter für das Auflisten von `modeltransform`-Aufträgen**
+ **`maxItems`** – (*Optional*) Die maximale Anzahl der Elemente, die zurückgegeben werden sollen.
*Typ*: Ganzzahl. *Standardwert*: `10`. *Maximal zulässiger Wert*: `1024`.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
# Verwalten von Inferenzendpunkten mit dem Befehl `endpoints`
Mit dem Neptune-ML-Befehl `endpoints` können Sie einen Inferenzendpunkt erstellen, seinen Status überprüfen, ihn löschen oder vorhandene Inferenzendpunkte auflisten.
## Erstellen eines Inferenzendpunkts mit dem Neptune ML-Befehl `endpoints`
Ein Neptune-ML-Befehl `endpoints` zum Erstellen eines Inferenzendpunkts aus einem Modell, das durch einen Trainingsauftrag erstellt wurde, sieht wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"mlModelTrainingJobId": "(the model-training job-id of a completed job)"
}'
```
Ein Neptune-ML-Befehl `endpoints` zum Aktualisieren eines Inferenzendpunkts aus einem Modell, das durch einen Trainingsauftrag erstellt wurde, sieht wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"update" : "true",
"mlModelTrainingJobId": "(the model-training job-id of a completed job)"
}'
```
Ein Neptune-ML-Befehl `endpoints` zum Erstellen eines Inferenzendpunkts aus einem Modell, das durch einen Modelltransformationsauftrag erstellt wurde, sieht wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"mlModelTransformJobId": "(the model-training job-id of a completed job)"
}'
```
Ein Neptune-ML-Befehl `endpoints` zum Aktualisieren eines Inferenzendpunkts aus einem Modell, das durch einen Modelltransformationsauftrag erstellt wurde, sieht wie folgt aus:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"update" : "true",
"mlModelTransformJobId": "(the model-training job-id of a completed job)"
}'
```
**Parameter für die Erstellung von Inferenzendpunkten mit `endpoints`**
+ **`id`** – (*Optional*) Eine eindeutige ID für den neuen Inferenzendpunkt.
*Typ:* Zeichenfolge. *Standard*: Ein automatisch generierter Name mit Zeitstempel.
+ **`mlModelTrainingJobId`** – Die Auftrags-ID des abgeschlossenen Modelltrainingsauftrags, der das Modell erstellt hat, auf das der Inferenzendpunkt verweisen wird.
*Typ:* Zeichenfolge.
*Hinweis*: Sie müssen entweder die `mlModelTrainingJobId` oder die `mlModelTransformJobId` angeben.
+ **`mlModelTransformJobId`** – Die Auftrags-ID eines abgeschlossenen Modelltransformationsauftrags.
*Typ:* Zeichenfolge.
*Hinweis*: Sie müssen entweder die `mlModelTrainingJobId` oder die `mlModelTransformJobId` angeben.
+ **`update`** – (*Optional*) Wenn vorhanden, gibt dieser Parameter an, dass es sich um eine Aktualisierungsanforderung handelt.
*Typ*: boolesch. *Standardwert*: `false`
*Hinweis*: Sie müssen entweder die `mlModelTrainingJobId` oder die `mlModelTransformJobId` angeben.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`modelName`** – (*Optional*) Modelltyp für das Training. Standardmäßig basiert das ML-Modell automatisch auf dem `modelType`, der in der Datenverarbeitung verwendet wird. Sie können hier jedoch einen anderen Modelltyp angeben.
*Typ:* Zeichenfolge. *Standardwert*: `rgcn` für heterogene Diagramme und `kge` für Wissensdiagramme. *Gültige Werte*: für heterogene Diagramme: `rgcn`. Für Wissensdiagramme: `kge`, `transe`, `distmult` oder `rotate`.
+ **`instanceType`** – (*Optional*) Der Typ der ML-Instance, die für die Online-Bereitstellung verwendet wird.
*Typ:* Zeichenfolge. *Standardwert*: `ml.m5.xlarge`.
*Hinweis*: Die Auswahl der ML-Instance für einen Inferenzendpunkt ist von Aufgabentyp, Diagrammgröße und Budget abhängig. Siehe [Auswahl einer Instance für einen Inferenzendpunkt](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-inference-endpoint-instance-size).
+ **`instanceCount`** – (*Optional*) Die Mindestanzahl von Amazon-EC2-Instances, die auf einem Endpunkt bereitgestellt werden sollen, um Vorhersagen zu erstellen.
*Typ*: Ganzzahl. *Standardwert*: `1`.
+ **`volumeEncryptionKMSKey`**— (*Optional*) Der Schlüssel AWS Key Management Service (AWS KMS), den SageMaker KI verwendet, um Daten auf dem Speichervolume zu verschlüsseln, das an die ML-Compute-Instance (en) angehängt ist, auf denen die Endgeräte ausgeführt werden.
*Typ:* Zeichenfolge. *Standardwert*: *keiner*.
## Abrufen des Status eines Inferenzendpunkts mit dem Neptune-ML-Befehl `endpoints`
Dies ist ein Beispiel für den Neptune-ML-Befehl `endpoints` für den Abruf des Status eines Instance-Endpunkts:
```
curl -s \
"https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)" \
| python -m json.tool
```
**Parameter für den Abruf des Instance-Endpunktstatus mit `endpoints`**
+ **`id`** – (*Erforderlich*) Die eindeutige ID des Inferenzendpunkts.
*Typ:* Zeichenfolge.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
## Löschen eines Instance-Endpunkts mit dem Neptune-ML-Befehl `endpoints`
Dies ist ein Beispiel für den Neptune-ML-Befehl `endpoints` für das Löschen des Status eines Instance-Endpunkts:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)"
```
Oder:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)?clean=true"
```
**Parameter zum Löschen eines Inferenzendpunkts mit `endpoints`**
+ **`id`** – (*Erforderlich*) Die eindeutige ID des Inferenzendpunkts.
*Typ:* Zeichenfolge.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
+ **`clean`** – (*Optional*) Gibt an, dass alle Artefakte, die sich auf diesen Endpunkt beziehen, ebenfalls gelöscht werden sollen.
*Typ*: boolescher Wert. *Standardwert*: `FALSE`.
## Auflisten von Inferenzendpunkten mit dem Neptune ML-Befehl `endpoints`
Dies ist ein Neptune-ML-Befehl `endpoints` zum Auflisten von Inferenzendpunkten:
```
curl -s "https://(your Neptune endpoint)/ml/endpoints" \
| python -m json.tool
```
Oder:
```
curl -s "https://(your Neptune endpoint)/ml/endpoints?maxItems=3" \
| python -m json.tool
```
**Parameter zum Auflisten von Inferenzendpunkten mit `dataprocessing`**
+ **`maxItems`** – (*Optional*) Die maximale Anzahl der Elemente, die zurückgegeben werden sollen.
*Typ*: Ganzzahl. *Standardwert*: `10`. *Maximal zulässiger Wert*: `1024`.
+ **`neptuneIamRoleArn`**— (*Optional*) Der ARN einer IAM-Rolle, die Neptune Zugriff auf SageMaker KI- und Amazon S3 S3-Ressourcen bietet.
*Typ:* Zeichenfolge. *Hinweis*: Er muss in der DB-Cluster-Parametergruppe aufgelistet werden, andernfalls tritt ein Fehler auf.
# Neptune-ML-Management-API – Fehler und Ausnahmen
Alle Neptune-ML-Management-API-Ausnahmen geben einen HTTP-400-Code zurück. Nach Auslösung einer dieser Ausnahmen sollte der Befehl, der die Ausnahme generiert hat, nicht erneut ausgeführt werden.
****
+ **`MissingParameterException`** – Fehlermeldung
`Required credentials are missing. Please add IAM role to the cluster or pass as a parameter to this request.`
+ **`InvalidParameterException`** – Fehlermeldungen:
+ `Invalid ML instance type.`
+ `Invalid ID provided. ID can be 1-48 alphanumeric characters.`
+ `Invalid ID provided. Must contain only letters, digits, or hyphens.`
+ `Invalid ID provided. Please check whether a resource with the given ID exists.`
+ `Another resource with same ID already exists. Please use a new ID.`
+ `Failed to stop the job because it has already completed or failed.`
+ **`BadRequestException`** – Fehlermeldungen:
+ `Invalid S3 URL or incorrect S3 permissions. Please check your S3 configuration.`
+ `Provided ModelTraining job has not completed.`
+ `Provided SageMaker AI Training job has not completed.`
+ `Provided MLDataProcessing job is not completed.`
+ `Provided MLModelTraining job doesn't exist.`
+ `Provided ModelTransformJob doesn't exist.`
+ `Unable to find SageMaker AI resource. Please check your input.`
# Neptune-ML-Einschränkungen
+ Die zurzeit unterstützten Inferenztypen sind Knotenklassifikation, Knotenregression, Kantenklassifizierung, Kantenregression und Linkvorhersage (siehe [Neptune-ML-Fähigkeiten](machine-learning.md#machine-learning-capabilities)).
+ Die maximale Diagrammgröße, die Neptune ML unterstützen kann, ist von der Menge an Arbeitsspeicher und Speicherplatz abhängig, die für [Datenvorbereitung](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-processing-instance-size), [Modelltraining](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size) und [Inferenz](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-inference-endpoint-instance-size) benötigt werden.
+ Die maximale Speichergröße einer SageMaker KI-Datenverarbeitungsinstanz beträgt 768 GB. Daher schlägt die Datenverarbeitungsphase fehl, wenn sie mehr als 768 GB Arbeitsspeicher benötigt.
+ Die maximale Speichergröße einer SageMaker KI-Trainingsinstanz beträgt 732 GB. Daher schlägt die Trainingsphase fehl, wenn sie mehr als 732 GB Arbeitsspeicher benötigt.
+ Die maximale Größe einer Inferenz-Payload für einen SageMaker KI-Endpunkt beträgt 6 MiB. Daher schlägt eine induktive Inferenz fehl, wenn die Nutzlast des Unterdiagramms diese Größe überschreitet.
+ Neptune ML ist derzeit nur in Regionen verfügbar, in denen Neptune und die anderen Dienste, von denen es abhängig ist (wie Amazon API Gateway und Amazon SageMaker AI) AWS Lambda, alle unterstützt werden.
Es gibt Unterschiede in China (Peking) und China (Ningxia) im Zusammenhang mit der standardmäßigen Verwendung der IAM-Authentifizierung, wie [hier](https://docs.amazonaws.cn/en_us/aws/latest/userguide/api-gateway.html#feature-diff) beschrieben, zusammen mit anderen Unterschieden.
+ Die von Neptune ML gestarteten Linkvorhersage-Inferenzendpunkte können derzeit nur mögliche Links mit Knoten vorhersagen, die während des Trainings im Diagramm vorhanden waren.
Betrachten Sie beispielsweise ein Diagramm mit den Eckpunkten `User` und `Movie` sowie der Kante `Rated`. Mit einem entsprechenden Neptune-ML-Linkvorhersage-Empfehlungsmodell können Sie einen neuen Benutzer zum Diagramm hinzufügen und das Modell Filme für diesen vorhersagen lassen. Das Modell kann jedoch nur Filme empfehlen, die während des Modelltrainings vorhanden waren. Auch wenn die `User`-Knoteneinbettung in Echtzeit anhand des lokalen Unterdiagramms und des GNN-Modells berechnet wird und sich daher mit der Zeit ändern kann, wenn Benutzer Filme bewerten, wird sie für die endgültige Empfehlung mit den statischen, vorberechneten Filmeinbettungen verglichen.
+ Die von Neptune ML unterstützten KGE-Modelle funktionieren nur für Linkvorhersageaufgaben und die Darstellungen sind für die Eckpunkte und Kantentypen spezifisch, die während des Trainings im Diagramm vorhanden sind. Daher müssen alle Eckpunkte und Kantentypen, auf die in einer Inferenzabfrage verwiesen wird, während des Trainings im Diagramm vorhanden gewesen sein. Es können keine Vorhersagen für neue Kantentypen oder Eckpunkte erstellt werden, ohne das Modell erneut zu trainieren.
## SageMaker Einschränkungen der KI-Ressourcen
Abhängig von Ihren Aktivitäten und der Ressourcennutzung im Laufe der Zeit können Ihnen Fehlermeldungen angezeigt werden, die besagen, dass [Sie Ihr Kontingent überschritten haben](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html) ([ResourceLimitExceeded](https://repost.aws/knowledge-center/sagemaker-resource-limit-exceeded-error)). Und Sie müssen Ihre SageMaker KI-Ressourcen skalieren. Folgen Sie den Schritten im Verfahren [Beantragen einer Erhöhung des Servicekontingents für SageMaker Ressourcen](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure) auf dieser Seite, um eine Kontingenterhöhung beim AWS Support zu beantragen.
SageMaker Die Namen der KI-Ressourcen entsprechen den Neptune ML-Stufen wie folgt:
+ Die SageMaker KI `ProcessingJob` wird bei Neptun-Datenverarbeitungs-, Modelltrainings- und Modelltransformationsjobs verwendet.
+ Die SageMaker KI `HyperParameterTuningJob` wird bei Trainingsjobs mit Neptun-Modellen verwendet.
+ Die SageMaker KI `TrainingJob` wird bei Trainingsjobs mit Neptun-Modellen verwendet.
+ Die SageMaker KI `Endpoint` wird von Neptun-Inferenzendpunkten verwendet.