View a markdown version of this page

Modelltraining mit dem Befehl modeltraining - Amazon Neptune
Erstellen eines ModelltrainingsauftragsAbrufen des AuftragsstatusStoppen eines AuftragsAuflisten von Aufträgen

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.

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:

AWS CLI
aws neptunedata start-ml-model-training-job \
  --endpoint-url https://your-neptune-endpoint:port \
  --id "(a unique model-training job ID)" \
  --data-processing-job-id "(the data-processing job-id of a completed job)" \
  --train-model-s3-location "s3://(your S3 bucket)/neptune-model-graph-autotrainer"

Weitere Informationen finden Sie unter start-ml-model-training-job in der AWS CLI Befehlsreferenz.

SDK
import boto3
from botocore.config import Config

client = boto3.client(
    'neptunedata',
    endpoint_url='https://your-neptune-endpoint:port',
    config=Config(read_timeout=None, retries={'total_max_attempts': 1})
)

response = client.start_ml_model_training_job(
    id='(a unique model-training job ID)',
    dataProcessingJobId='(the data-processing job-id of a completed job)',
    trainModelS3Location='s3://(your S3 bucket)/neptune-model-graph-autotrainer'
)

print(response)
awscurl
awscurl https://your-neptune-endpoint:port/ml/modeltraining \
  --region us-east-1 \
  --service neptune-db \
  -X POST \
  -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 S3 bucket)/neptune-model-graph-autotrainer"
      }'
Anmerkung

In diesem Beispiel wird davon ausgegangen, dass Ihre AWS Anmeldeinformationen in Ihrer Umgebung konfiguriert sind. Ersetze es us-east-1 durch die Region deines Neptun-Clusters.

curl
curl \
  -X POST https://your-neptune-endpoint:port/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 S3 bucket)/neptune-model-graph-autotrainer"
      }'

Ein Neptune-ML-Befehl modeltraining zum Erstellen eines Aktualisierungsauftrags für das inkrementelle Modelltraining sieht wie folgt aus:

AWS CLI
aws neptunedata start-ml-model-training-job \
  --endpoint-url https://your-neptune-endpoint:port \
  --id "(a unique model-training job ID)" \
  --data-processing-job-id "(the data-processing job-id of a completed job)" \
  --train-model-s3-location "s3://(your S3 bucket)/neptune-model-graph-autotrainer" \
  --previous-model-training-job-id "(the job ID of a completed model-training job to update)"

Weitere Informationen finden Sie unter start-ml-model-training-job in der AWS CLI Befehlsreferenz.

SDK
import boto3
from botocore.config import Config

client = boto3.client(
    'neptunedata',
    endpoint_url='https://your-neptune-endpoint:port',
    config=Config(read_timeout=None, retries={'total_max_attempts': 1})
)

response = client.start_ml_model_training_job(
    id='(a unique model-training job ID)',
    dataProcessingJobId='(the data-processing job-id of a completed job)',
    trainModelS3Location='s3://(your S3 bucket)/neptune-model-graph-autotrainer',
    previousModelTrainingJobId='(the job ID of a completed model-training job to update)'
)

print(response)
awscurl
awscurl https://your-neptune-endpoint:port/ml/modeltraining \
  --region us-east-1 \
  --service neptune-db \
  -X POST \
  -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 S3 bucket)/neptune-model-graph-autotrainer",
        "previousModelTrainingJobId" : "(the job ID of a completed model-training job to update)"
      }'
Anmerkung

In diesem Beispiel wird davon ausgegangen, dass Ihre AWS Anmeldeinformationen in Ihrer Umgebung konfiguriert sind. Ersetze es us-east-1 durch die Region deines Neptun-Clusters.

curl
curl \
  -X POST https://your-neptune-endpoint:port/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 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:

AWS CLI
aws neptunedata start-ml-model-training-job \
  --endpoint-url https://your-neptune-endpoint:port \
  --id "(a unique model-training job ID)" \
  --data-processing-job-id "(the data-processing job-id of a completed job)" \
  --train-model-s3-location "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" \
  --model-name "custom" \
  --custom-model-training-parameters '{
    "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 finden Sie unter start-ml-model-training-job in der AWS CLI Befehlsreferenz.

SDK
import boto3
from botocore.config import Config

client = boto3.client(
    'neptunedata',
    endpoint_url='https://your-neptune-endpoint:port',
    config=Config(read_timeout=None, retries={'total_max_attempts': 1})
)

response = client.start_ml_model_training_job(
    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)'
    }
)

print(response)
awscurl
awscurl https://your-neptune-endpoint:port/ml/modeltraining \
  --region us-east-1 \
  --service neptune-db \
  -X POST \
  -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)"
        }
      }'
Anmerkung

In diesem Beispiel wird davon ausgegangen, dass Ihre AWS Anmeldeinformationen in Ihrer Umgebung konfiguriert sind. Ersetze es us-east-1 durch die Region deines Neptun-Clusters.

curl
curl \
  -X POST https://your-neptune-endpoint:port/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.

  • 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.

  • 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.

  • 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 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.

    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:

AWS CLI
aws neptunedata get-ml-model-training-job \
  --endpoint-url https://your-neptune-endpoint:port \
  --id "(the job ID)"

Weitere Informationen finden Sie unter get-ml-model-training-job in der AWS CLI Befehlsreferenz.

SDK
import boto3
from botocore.config import Config

client = boto3.client(
    'neptunedata',
    endpoint_url='https://your-neptune-endpoint:port',
    config=Config(read_timeout=None, retries={'total_max_attempts': 1})
)

response = client.get_ml_model_training_job(
    id='(the job ID)'
)

print(response)
awscurl
awscurl https://your-neptune-endpoint:port/ml/modeltraining/(the job ID) \
  --region us-east-1 \
  --service neptune-db \
  -X GET
Anmerkung

In diesem Beispiel wird davon ausgegangen, dass Ihre AWS Anmeldeinformationen in Ihrer Umgebung konfiguriert sind. Ersetze es us-east-1 durch die Region deines Neptun-Clusters.

curl
curl -s \
  "https://your-neptune-endpoint:port/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:

AWS CLI
aws neptunedata cancel-ml-model-training-job \
  --endpoint-url https://your-neptune-endpoint:port \
  --id "(the job ID)"

Um auch Amazon S3 S3-Artefakte zu bereinigen:

aws neptunedata cancel-ml-model-training-job \
  --endpoint-url https://your-neptune-endpoint:port \
  --id "(the job ID)" \
  --clean

Weitere Informationen finden Sie unter cancel-ml-model-training-job in der AWS CLI Befehlsreferenz.

SDK
import boto3
from botocore.config import Config

client = boto3.client(
    'neptunedata',
    endpoint_url='https://your-neptune-endpoint:port',
    config=Config(read_timeout=None, retries={'total_max_attempts': 1})
)

response = client.cancel_ml_model_training_job(
    id='(the job ID)',
    clean=True
)

print(response)
awscurl
awscurl https://your-neptune-endpoint:port/ml/modeltraining/(the job ID) \
  --region us-east-1 \
  --service neptune-db \
  -X DELETE

Um auch Amazon S3 S3-Artefakte zu bereinigen:

awscurl "https://your-neptune-endpoint:port/ml/modeltraining/(the job ID)?clean=true" \
  --region us-east-1 \
  --service neptune-db \
  -X DELETE
Anmerkung

In diesem Beispiel wird davon ausgegangen, dass Ihre AWS Anmeldeinformationen in Ihrer Umgebung konfiguriert sind. Ersetze es us-east-1 durch die Region deines Neptun-Clusters.

curl
curl -s \
  -X DELETE "https://your-neptune-endpoint:port/ml/modeltraining/(the job ID)"

Oder:

curl -s \
  -X DELETE "https://your-neptune-endpoint:port/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:

AWS CLI
aws neptunedata list-ml-model-training-jobs \
  --endpoint-url https://your-neptune-endpoint:port

Um die Anzahl der Ergebnisse zu begrenzen:

aws neptunedata list-ml-model-training-jobs \
  --endpoint-url https://your-neptune-endpoint:port \
  --max-items 3

Weitere Informationen finden Sie unter list-ml-model-training-jobs in der AWS CLI Befehlsreferenz.

SDK
import boto3
from botocore.config import Config

client = boto3.client(
    'neptunedata',
    endpoint_url='https://your-neptune-endpoint:port',
    config=Config(read_timeout=None, retries={'total_max_attempts': 1})
)

response = client.list_ml_model_training_jobs(
    maxItems=3
)

print(response)
awscurl
awscurl https://your-neptune-endpoint:port/ml/modeltraining \
  --region us-east-1 \
  --service neptune-db \
  -X GET

Um die Anzahl der Ergebnisse zu begrenzen:

awscurl "https://your-neptune-endpoint:port/ml/modeltraining?maxItems=3" \
  --region us-east-1 \
  --service neptune-db \
  -X GET
Anmerkung

In diesem Beispiel wird davon ausgegangen, dass Ihre AWS Anmeldeinformationen in Ihrer Umgebung konfiguriert sind. Ersetze es us-east-1 durch die Region deines Neptun-Clusters.

curl
curl -s "https://your-neptune-endpoint:port/ml/modeltraining" | python -m json.tool

Oder:

curl -s "https://your-neptune-endpoint:port/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.