Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Führen Sie Ihren lokalen Code als SageMaker Trainingsjob aus
Sie können Ihren lokalen Python-Code für maschinelles Lernen (ML) als großen SageMaker Amazon-Schulungsjob mit einem Knoten oder als mehrere parallel Jobs ausführen. Dies können Sie tun, indem Sie Ihren Code mit einem @remote Decorator kommentieren, wie im folgenden Beispielcode gezeigt. [Verteiltes Training](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-training.html) (über mehrere Instances) wird mit Remote-Funktionen nicht unterstützt.
```
@remote(**settings)
def divide(x, y):
return x / y
```
Das SageMaker Python-SDK übersetzt Ihre bestehende Workspace-Umgebung und alle zugehörigen Datenverarbeitungscodes und Datensätze automatisch in einen SageMaker Trainingsjob, der auf der SageMaker Trainingsplattform ausgeführt wird. Sie können auch ein persistentes Cache-Feature aktivieren, das die Latenz beim Auftragsbeginn weiter reduziert, indem zuvor heruntergeladene Abhängigkeitspakete zwischengespeichert werden. Diese Verringerung der Job-Latenz ist größer als die Verringerung der Latenz, die allein durch die Verwendung von SageMaker KI-verwalteten Warmpools erzielt wird. Weitere Informationen finden Sie unter [Persistenter Cache verwenden](train-warm-pools.md#train-warm-pools-persistent-cache).
**Anmerkung**
Verteilte Trainingsaufträge werden nicht durch Remote-Funktionen unterstützt.
In den folgenden Abschnitten wird gezeigt, wie Sie Ihren lokalen ML-Code mit einem @remote Decorator kommentieren und Ihre Benutzererfahrung an Ihren Anwendungsfall anpassen können. Dazu gehören die Anpassung Ihrer Umgebung und die Integration mit SageMaker Experiments.
**Topics**
+ [So richten Sie Ihre Umgebung ein](#train-remote-decorator-env)
+ [Aufrufen einer Remote-Funktion](train-remote-decorator-invocation.md)
+ [Konfigurationsdatei](train-remote-decorator-config.md)
+ [Passen Sie Ihre Laufzeitumgebung an](train-remote-decorator-customize.md)
+ [Container-Image-Kompatibilität](train-remote-decorator-container.md)
+ [Protokollierung von Parametern und Metriken mit Amazon SageMaker Experiments](train-remote-decorator-experiments.md)
+ [Verwendung von modularem Code mit dem @remote Decorator](train-remote-decorator-modular.md)
+ [Privates Repository für Laufzeitabhängigkeiten](train-remote-decorator-private.md)
+ [Beispiel-Notebooks](train-remote-decorator-examples.md)
## So richten Sie Ihre Umgebung ein
Wählen Sie eine der folgenden drei Optionen aus, um Ihre Umgebung einzurichten.
### Führen Sie Ihren Code von Amazon SageMaker Studio Classic aus
Sie können Ihren lokalen ML-Code in SageMaker Studio Classic kommentieren und ausführen, indem Sie ein SageMaker Notizbuch erstellen und jedes Bild anhängen, das auf dem SageMaker Studio Classic-Image verfügbar ist. Die folgenden Anweisungen helfen Ihnen, ein SageMaker Notebook zu erstellen, das SageMaker Python-SDK zu installieren und Ihren Code mit dem Decorator zu kommentieren.
1. Erstellen Sie ein SageMaker Notizbuch und hängen Sie ein Bild in SageMaker Studio Classic wie folgt an:
1. Folgen Sie den Anweisungen [unter Amazon SageMaker Studio Classic starten](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html) im *Amazon SageMaker AI Developer Guide*.
1. Wählen Sie im linken Navigationsbereich **Studio** aus. Es wird nun ein neues Fenster geöffnet.
1. Wählen Sie im Dialogfeld **Erste Schritte** aus und wählen Sie mit dem Abwärtspfeil ein Benutzerprofil aus. Dies öffnet ein neues Fenster.
1. Wählen Sie **Studio Classic öffnen** aus.
1. Wählen Sie im Hauptarbeitsbereich die Option **Launcher öffnen** aus. Es wird nun eine neue Seite geöffnet.
1. Wählen Sie im Hauptarbeitsbereich die Option **Notebook erstellen** aus.
1. Wählen Sie im Dialogfeld **Umgebung ändern** mit dem Abwärtspfeil neben **Image** die Option **Base Python 3.0** aus.
Der @remote Decorator erkennt automatisch das an das SageMaker Studio Classic-Notizbuch angehängte Bild und verwendet es, um den SageMaker Trainingsjob auszuführen. Wenn `image_uri` entweder als Argument im Decorator oder in der Konfigurationsdatei angegeben wird, wird der in `image_uri` angegebene Wert anstelle des erkannten Image verwendet.
Weitere Informationen zum Erstellen eines Notizbuchs in SageMaker Studio Classic finden Sie im Abschnitt **Ein Notizbuch über das Dateimenü** [erstellen unter Amazon SageMaker Studio Classic-Notizbuch erstellen oder öffnen](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-create-open.html#notebooks-create-file-menu).
Eine Liste der verfügbaren Images finden Sie unter [Unterstützte Docker-Images](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-container.html).
1. Installieren Sie das SageMaker Python-SDK.
Um Ihren Code mit der @remote -Funktion in einem SageMaker Studio Classic Notebook zu annotieren, muss das SageMaker Python-SDK installiert sein. Installieren Sie das SageMaker Python-SDK, wie im folgenden Codebeispiel gezeigt.
```
!pip install sagemaker
```
1. Verwenden Sie @remote decorator, um Funktionen in einem SageMaker Trainingsjob auszuführen.
Um Ihren lokalen ML-Code auszuführen, erstellen Sie zunächst eine Abhängigkeitsdatei, um SageMaker AI mitzuteilen, wo sich Ihr lokaler Code befinden soll. Führen Sie dazu die folgenden Schritte aus:
1. Wählen Sie im Hauptarbeitsbereich von SageMaker Studio Classic Launcher unter **Dienstprogramme und Dateien** die Option **Textdatei** aus. Es wird dann ein neuer Tab mit einer Textdatei namens `untitled.txt.` geöffnet
Weitere Informationen zur Benutzeroberfläche (UI) von SageMaker Studio Classic finden Sie unter [Amazon SageMaker Studio Classic UI Overview](https://docs.aws.amazon.com//sagemaker/latest/dg/studio-ui.html).
1. Benennen Sie `untitled.txt ` um in `requirements.txt`.
1. Fügen Sie alle für den Code erforderlichen Abhängigkeiten zusammen mit der SageMaker AI-Bibliothek hinzu`requirements.txt`.
Ein Beispiel für den minimalen Code `requirements.txt` für die Beispielfunktion `divide` finden Sie im folgenden Abschnitt.
```
sagemaker
```
1. Führen Sie Ihren Code mit dem Remote Decorator aus, indem Sie die Datei mit den Abhängigkeiten übergeben, wie folgt.
```
from sagemaker.remote_function import remote
@remote(instance_type="ml.m5.xlarge", dependencies='./requirements.txt')
def divide(x, y):
return x / y
divide(2, 3.0)
```
Weitere Beispielcodes finden Sie im Beispiel-Notebook [quick\_start.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb).
Wenn Sie bereits ein SageMaker Studio Classic-Notebook ausführen und das Python-SDK wie in **2 beschrieben installieren. Installieren Sie das SageMaker Python-SDK**, Sie müssen Ihren Kernel neu starten. Weitere Informationen finden Sie unter [Verwenden der SageMaker Studio Classic Notebook Toolbar](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-menu.html) im *Amazon SageMaker AI Developer Guide*.
### Führen Sie Ihren Code von einem SageMaker Amazon-Notizbuch aus
Sie können Ihren lokalen ML-Code von einer SageMaker Notebook-Instance aus kommentieren. Die folgenden Anweisungen zeigen, wie Sie eine Notebook-Instanz mit einem benutzerdefinierten Kernel erstellen, das SageMaker Python-SDK installieren und Ihren Code mit dem Decorator annotieren.
1. Erstellen Sie eine Notebook-Instance mit einem benutzerdefinierten `conda` Kernel.
Sie können Ihren lokalen ML-Code mit einem @remote -Decorator annotieren, um ihn innerhalb eines Trainingsjobs zu verwenden. SageMaker Zunächst müssen Sie eine SageMaker Notebook-Instanz erstellen und anpassen, um einen Kernel mit Python-Version 3.7 oder höher, bis zu 3.10.x, zu verwenden. Führen Sie dazu die folgenden Schritte aus:
1. Öffnen Sie die SageMaker AI-Konsole unter. [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)
1. Wählen Sie im linken Navigationsbereich **Notebook** aus, um die dazugehörigen Optionen zu erweitern.
1. Wählen Sie aus den erweiterten Optionen **Notebook-Instances** aus.
1. Wählen Sie die Schaltfläche **Notebook-Instance erstellen** aus. Es wird nun eine neue Seite geöffnet.
1. Geben Sie unter **Name deer Notebook-Instance** einen Namen mit maximal 63 Zeichen ohne Leerzeichen ein. Gültige Zeichen: **A–Z**, **a–z**, **0–9** und **.****:****\+****=****@**** \_****%****-** (Bindestrich).
1. Erweitern Sie im Dialogfeld mit den **Einstellungen für Notebook-Instances** den Pfeil nach rechts neben **Zusätzliche Konfiguration**.
1. Erweitern Sie unter **Lebenszykluskonfiguration – optional** den Abwärtspfeil und wählen Sie **Neue Lebenszykluskonfiguration erstellen** aus. Es öffnet sich ein neues Dialogfeld.
1. Geben Sie unter **Name** einen Namen für Ihre Konfigurationseinstellung ein.
1. Ersetzen Sie im Dialogfeld **Skripte** auf der Registerkarte **Notebook starten** den vorhandenen Inhalt des Textfeldes durch das folgende Skript.
```
#!/bin/bash
set -e
sudo -u ec2-user -i <<'EOF'
unset SUDO_UID
WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda/
source "$WORKING_DIR/miniconda/bin/activate"
for env in $WORKING_DIR/miniconda/envs/*; do
BASENAME=$(basename "$env")
source activate "$BASENAME"
python -m ipykernel install --user --name "$BASENAME" --display-name "Custom ($BASENAME)"
done
EOF
echo "Restarting the Jupyter server.."
# restart command is dependent on current running Amazon Linux and JupyterLab
CURR_VERSION_AL=$(cat /etc/system-release)
CURR_VERSION_JS=$(jupyter --version)
if [[ $CURR_VERSION_JS == *$"jupyter_core : 4.9.1"* ]] && [[ $CURR_VERSION_AL == *$" release 2018"* ]]; then
sudo initctl restart jupyter-server --no-wait
else
sudo systemctl --no-block restart jupyter-server.service
fi
```
1. Ersetzen Sie im Dialogfeld **Skripte** auf der Registerkarte **Notebook erstellen** den vorhandenen Inhalt des Textfeldes durch das folgende Skript.
```
#!/bin/bash
set -e
sudo -u ec2-user -i <<'EOF'
unset SUDO_UID
# Install a separate conda installation via Miniconda
WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
mkdir -p "$WORKING_DIR"
wget https://repo.anaconda.com/miniconda/Miniconda3-4.6.14-Linux-x86_64.sh -O "$WORKING_DIR/miniconda.sh"
bash "$WORKING_DIR/miniconda.sh" -b -u -p "$WORKING_DIR/miniconda"
rm -rf "$WORKING_DIR/miniconda.sh"
# Create a custom conda environment
source "$WORKING_DIR/miniconda/bin/activate"
KERNEL_NAME="custom_python310"
PYTHON="3.10"
conda create --yes --name "$KERNEL_NAME" python="$PYTHON" pip
conda activate "$KERNEL_NAME"
pip install --quiet ipykernel
# Customize these lines as necessary to install the required packages
EOF
```
1. Wählen Sie unten rechts im Fenster die Schaltfläche **Konfiguration erstellen** aus.
1. Wählen Sie unten rechts im Fenster die Schaltfläche **Notebook-Instance erstellen** aus.
1. Warten Sie, bis sich der **Status** der Notebook-Instanz von **Ausstehend** auf ändert **InService**.
1. Erstellen Sie in der Notebook-Instance ein Jupyter Notebook.
Die folgenden Anweisungen zeigen, wie Sie ein Jupyter-Notebook mit Python 3.10 in Ihrer neu erstellten Instanz erstellen. SageMaker
1. Gehen Sie wie folgt vor, nachdem der **Status** der Notebook-Instanz aus dem vorherigen Schritt lautet **InService**:
1. Wählen Sie in der Zeile, die den **Namen** Ihrer neu erstellten Notebook-Instance enthält, unter **Aktionen** die Option **Jupyter öffnen** aus. Es öffnet sich ein neuer Jupyter-Server.
1. Wählen Sie im Jupyter-Server im Menü oben rechts die Option **Neu** aus.
1. Wählen Sie mit dem Abwärtspfeil **conda\_custom\_python310** aus. Es wird nun ein neues Jupyter Notebook erstellt, das einen Python 3.10-Kernel verwendet. Dieses neue Jupyter Notebook kann jetzt ähnlich wie ein lokales Jupyter Notebook verwendet werden.
1. Installieren Sie das SageMaker Python-SDK.
Nachdem Ihre virtuelle Umgebung ausgeführt wurde, installieren Sie das SageMaker Python-SDK mithilfe des folgenden Codebeispiels.
```
!pip install sagemaker
```
1. Verwenden Sie einen @remote -Decorator, um Funktionen in einem SageMaker Trainingsjob auszuführen.
Wenn Sie Ihren lokalen ML-Code mit einem @remote -Decorator im SageMaker Notizbuch annotieren, interpretiert das SageMaker Training automatisch die Funktion Ihres Codes und führt ihn als SageMaker Trainingsjob aus. Gehen Sie wie folgt vor, um Ihr Notebook einzurichten:
1. Wählen Sie den Kernelnamen im Notebook-Menü aus der SageMaker Notebook-Instanz aus, die Sie in Schritt 1, **Eine SageMaker Notebook-Instanz mit einem benutzerdefinierten Kernel erstellen**, erstellt haben.
Weitere Informationen finden Sie unter [Ein Image oder einen Kernel ändern](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-run-and-manage-change-image.html).
1. Wählen Sie mit dem Abwärtspfeil einen benutzerdefinierten `conda` Kernel aus, der Python in der Version 3.7 oder höher verwendet.
Wenn Sie z. B. `conda_custom_python310` auswählen, wird der Kernel für Python 3.10 ausgewählt.
1. Wählen Sie **Select (Auswählen)**.
1. Warten Sie, bis der Status des Kernels als inaktiv angezeigt wird. Dies weist darauf hin, dass der Kernel gestartet wurde.
1. Wählen Sie auf der Startseite des Jupyter-Servers im Menü oben rechts die Option **Neu** aus.
1. Wählen Sie neben dem Abwärtspfeil die Option **Textdatei** aus. Jetzt wird eine neue Textdatei mit dem Namen `untitled.txt.` erstellt
1. Benennen Sie `untitled.txt` in `requirements.txt` um und fügen Sie alle für den Code erforderlichen Abhängigkeiten hinzu, zusammen mit `sagemaker`.
1. Führen Sie Ihren Code mit dem Remote-Decorator aus, indem Sie die Datei mit den Abhängigkeiten wie unten gezeigt übergeben.
```
from sagemaker.remote_function import remote
@remote(instance_type="{{ml.m5.xlarge}}", dependencies='./requirements.txt')
def divide(x, y):
return x / y
divide(2, 3.0)
```
Weiteren Beispielcode finden Sie im Beispiel-Notebook [quick\_start.ipnyb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb).
### Führen Sie Ihren Code in Ihrer lokalen IDE aus
Sie können Ihren lokalen ML-Code mit einem @remote Decorator in Ihrer bevorzugten lokalen IDE kommentieren. Die folgenden Schritte zeigen die notwendigen Voraussetzungen, wie Sie das Python-SDK installieren und wie Sie Ihren Code mit dem @remote Decorator kommentieren können.
1. Installieren Sie die Voraussetzungen, indem Sie AWS Command Line Interface (AWS CLI) einrichten und wie folgt eine Rolle erstellen:
+ Nehmen Sie an einer SageMaker AI-Domain teil, indem Sie den Anweisungen im Abschnitt **AWS CLI Voraussetzungen** unter [Amazon SageMaker AI-Voraussetzungen einrichten](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html#gs-cli-prereq) folgen.
+ Erstellen Sie eine IAM-Rolle, indem **Sie den Anweisungen im Abschnitt Ausführungsrolle erstellen** von [SageMaker AI-Rollen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) folgen.
1. Erstellen Sie eine virtuelle Umgebung, indem Sie entweder PyCharm oder verwenden `conda` und Python Version 3.7 oder höher, bis zu 3.10.x, verwenden.
+ Richten Sie eine virtuelle Umgebung PyCharm wie folgt ein:
1. Wählen Sie im Hauptmenü **Datei** aus.
1. Wählen Sie **New Project (Neues Projekt)** aus.
1. Wählen Sie mit dem Abwärtspfeil unter **Neue Umgebung verwenden** die Option **Conda** aus.
1. Verwenden Sie im Feld für die **Python-Version** den Abwärtspfeil, um eine Version von Python auszuwählen, die 3.7 oder höher ist. Sie können auf der Liste bis 3.10.x gehen.
+ Wenn Sie Anaconda installiert haben, können Sie mit Hilfe von `conda` wie folgt eine virtuelle Umgebung einrichten:
+ Öffnen Sie eine Anaconda-Terminalschnittstelle mit Eingabeaufforderung.
+ Erstellen und aktivieren Sie eine neue `conda` Umgebung mit Python in der Version 3.7 oder höher, bis 3.10x. Der folgende Beispielcode veranschaulicht, wie eine `conda` Umgebung mit Python Version 3.10 erstellt wird.
```
conda create -n {{sagemaker_jobs_quick_start}} python=3.10 pip
conda activate {{sagemaker_jobs_quick_start}}
```
1. Installieren Sie das SageMaker Python-SDK.
Um Ihren Code aus Ihrer bevorzugten IDE zu packen, müssen Sie eine virtuelle Umgebung mit Python 3.7 oder höher, bis 3.10x, eingerichtet haben. Sie benötigen außerdem ein kompatibles Container-Image. Installieren Sie das SageMaker Python-SDK mithilfe des folgenden Codebeispiels.
```
pip install sagemaker
```
1. Fügen Sie Ihren Code in den @remote Decorator ein. Das SageMaker Python-SDK interpretiert die Funktion Ihres Codes automatisch und führt ihn als SageMaker Trainingsjob aus. Die folgenden Codebeispiele zeigen, wie Sie die erforderlichen Bibliotheken importieren, eine SageMaker Sitzung einrichten und eine Funktion mit dem @remote -Dekorator annotieren.
Sie können Ihren Code ausführen, indem Sie entweder die benötigten Abhängigkeiten direkt bereitstellen oder Abhängigkeiten aus der aktiven `conda`Umgebung verwenden.
+ Gehen Sie wie folgt vor, um die Abhängigkeiten direkt bereitzustellen:
+ Erstellen Sie in dem Arbeitsverzeichnis, in dem sich der Code befindet, eine `requirements.txt` Datei.
+ Fügen Sie alle für den Code erforderlichen Abhängigkeiten zusammen mit der SageMaker Bibliothek hinzu. Der folgende Abschnitt enthält minimalen Beispielcode für `requirements.txt` für die `divide` Beispielfunktion.
```
sagemaker
```
+ Führen Sie Ihren Code mit dem @remote Decorator aus, indem Sie die Datei mit den Abhängigkeiten übergeben. Ersetzen Sie im folgenden Codebeispiel `The IAM role name` durch einen AWS Identity and Access Management (IAM-) Rollen-ARN, den Sie SageMaker zur Ausführung Ihres Jobs verwenden möchten.
```
import boto3
import sagemaker
from sagemaker.remote_function import remote
sm_session = sagemaker.Session(boto_session=boto3.session.Session(region_name="{{us-west-2}}"))
settings = dict(
sagemaker_session=sm_session,
role={{}},
instance_type="{{ml.m5.xlarge}}",
dependencies='./requirements.txt'
)
@remote(**settings)
def divide(x, y):
return x / y
if __name__ == "__main__":
print(divide(2, 3.0))
```
+ Um Abhängigkeiten aus der aktiven `conda` Umgebung zu verwenden, verwenden Sie den Wert `auto_capture` für den `dependencies` Parameter, wie im Folgenden gezeigt.
```
import boto3
import sagemaker
from sagemaker.remote_function import remote
sm_session = sagemaker.Session(boto_session=boto3.session.Session(region_name="{{us-west-2}}"))
settings = dict(
sagemaker_session=sm_session,
role={{}},
instance_type="{{ml.m5.xlarge}}",
dependencies="auto_capture"
)
@remote(**settings)
def divide(x, y):
return x / y
if __name__ == "__main__":
print(divide(2, 3.0))
```
**Anmerkung**
Sie können den vorherigen Code auch in einem Jupyter-Notebook implementieren. PyCharm Die Professional Edition unterstützt Jupyter nativ. Weitere Anleitungen finden Sie in der Dokumentation zur Unterstützung von [Jupyter-Notebooks](https://www.jetbrains.com/help/pycharm/ipython-notebook-support.html). PyCharm