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.
# Überwachen Sie die Auslastung von AWS Rechenressourcen in Amazon SageMaker Studio Classic
Verwenden Sie die von Amazon SageMaker Debugger angebotenen Überwachungstools, um die Ressourcenauslastung Ihres Trainingsauftrages zu verfolgen.
Für jeden Trainingsjob, den Sie in SageMaker AI mit dem SageMaker Python SDK ausführen, erfasst der Debugger alle 500 Millisekunden grundlegende Kennzahlen zur Ressourcenauslastung, wie CPU-Auslastung, GPU-Auslastung, GPU-Speicherauslastung, Netzwerk und I/O-Wartezeit. Um das Dashboard mit den Kennzahlen zur Ressourcenauslastung Ihres Trainingsauftrages zu sehen, verwenden Sie einfach die [SageMaker Debugger-Benutzeroberfläche in SageMaker Studio Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html).
Deep-Learning-Operationen und -Schritte können in Intervallen von Millisekunden ausgeführt werden. Im Vergleich zu Amazon CloudWatch-Metriken, die Metriken in Intervallen von 1 Sekunde erfassen, bietet Debugger eine feinere Granularität der Metriken zur Ressourcenauslastung in Intervallen von bis zu 100 Millisekunden (0,1 Sekunden), sodass Sie die Metriken auf der Ebene eines Vorgangs oder Schritts eingehend untersuchen können.
Wenn Sie das Zeitintervall für die Metrikerfassung ändern möchten, können Sie Ihrem Trainingsauftrag Launcher einen Parameter für die Profilkonfiguration hinzufügen. Wenn Sie beispielsweise das Python-SDK von SageMaker AI verwenden, müssen Sie den `profiler_config` Parameter übergeben, wenn Sie ein Schätzerobjekt erstellen. Informationen zur Anpassung des Erfassungsintervalls der Metriken zur Ressourcenauslastung finden Sie unter [Codevorlage für die Konfiguration eines SageMaker AI-Estimator-Objekts mit den SageMaker Debugger-Python-Modulen im SageMaker AI Python SDK](debugger-configuration-for-profiling.md#debugger-configuration-structure-profiler) und dann [Konfigurieren Sie Einstellungen für die grundlegende Profilerstellung der Systemressourcenauslastung](debugger-configure-system-monitoring.md).
Darüber hinaus können Sie Tools zur Problemerkennung hinzufügen, die als *integrierte Profilerstellungsregeln* bezeichnet werden und von SageMaker Debugger bereitgestellt werden. Die integrierten Profilerstellungsregeln führen Analysen anhand der Kennzahlen zur Ressourcenauslastung durch und erkennen Probleme mit der Rechenleistung. Weitere Informationen finden Sie unter [Verwenden Sie integrierte Profiler-Regeln, die von Amazon SageMaker Debugger verwaltet werden](use-debugger-built-in-profiler-rules.md). Sie können die Ergebnisse der Regelanalyse über die [SageMaker Debugger-Benutzeroberfläche in SageMaker Studio Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html) oder den [SageMaker Debugger Profiling Report](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html) abrufen. Sie können mit dem SageMaker Python SDK auch benutzerdefinierte Profilerstellungsregeln erstellen.
Weitere Informationen zu den von SageMaker Debugger bereitgestellten Überwachungsfunktionen finden Sie in den folgenden Themen.
**Topics**
+ [Estimator-Konfiguration mit Parametern für die grundlegende Profilerstellung mithilfe der Python-Module von Amazon SageMaker Debugger](debugger-configuration-for-profiling.md)
+ [Verwenden Sie integrierte Profiler-Regeln, die von Amazon SageMaker Debugger verwaltet werden](use-debugger-built-in-profiler-rules.md)
+ [Liste der im Debugger integrierten Profiler-Regeln](debugger-built-in-profiler-rules.md)
+ [Amazon SageMaker Debugger-Benutzeroberfläche in Amazon SageMaker Studio Classic Experiments](debugger-on-studio.md)
+ [SageMaker Interaktiver Debugger-Bericht](debugger-profiling-report.md)
+ [Analysieren Sie Daten mit der Debugger-Python-Clientbibliothek](debugger-analyze-data.md)
# Estimator-Konfiguration mit Parametern für die grundlegende Profilerstellung mithilfe der Python-Module von Amazon SageMaker Debugger
Standardmäßig ist die SageMaker Debugger-Basisprofilerstellung standardmäßig aktiviert und überwacht die Metriken zur Ressourcennutzung, wie CPU-Auslastung, GPU-Auslastung, GPU-Speicherauslastung, Netzwerk und I/O-Wartezeit, aller SageMaker Trainingsjobs, die mit dem [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) SDK eingereicht wurden. SageMaker Der Debugger erfasst diese Kennzahlen zur Ressourcennutzung alle 500 Millisekunden. Sie müssen keine zusätzlichen Änderungen an Ihrem Code, Trainingsskript oder dem Job Launcher vornehmen, um die grundlegende Ressourcenauslastung zu verfolgen. Wenn Sie das Intervall zur Erfassung von Metriken für die grundlegende Profilerstellung ändern möchten, können Sie Debugger-spezifische Parameter angeben, während Sie einen SageMaker Trainingsjob-Launcher mit dem SageMaker Python-SDK, AWS SDK für Python (Boto3), oder AWS Command Line Interface (CLI) erstellen. In diesem Handbuch konzentrieren wir uns darauf, wie Sie die Profilerstellungsoptionen mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) ändern können. Diese Seite enthält Referenzvorlagen für die Konfiguration dieses Schätzobjekts.
Wenn Sie in SageMaker Studio auf das Dashboard mit den Kennzahlen zur Ressourcennutzung Ihres Ausbildungsjobs zugreifen möchten, können Sie auf das [Amazon SageMaker Debugger-Benutzeroberfläche in Amazon SageMaker Studio Classic Experiments](debugger-on-studio.md) zugreifen.
Wenn Sie die Regeln aktivieren möchten, die Probleme mit der Systemressourcenauslastung automatisch erkennen, können Sie den `rules` Parameter zum Aktivieren der Regeln im Estimator-Objekt hinzufügen.
**Wichtig**
Um die neuesten SageMaker Debugger-Funktionen verwenden zu können, müssen Sie das SageMaker Python-SDK und die `SMDebug` Client-Bibliothek aktualisieren. Führen Sie in Ihrem IPython-Kernel, Jupyter Notebook oder Ihrer JupyterLab Umgebung den folgenden Code aus, um die neuesten Versionen der Bibliotheken zu installieren und den Kernel neu zu starten.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Codevorlage für die Konfiguration eines SageMaker AI-Estimator-Objekts mit den SageMaker Debugger-Python-Modulen im SageMaker AI Python SDK
Um die grundlegende Profilerstellungskonfiguration anzupassen (`profiler_config`) oder die Profiler-Regeln hinzuzufügen (`rules`), wählen Sie eine der Registerkarten aus, um die Vorlage für die Einrichtung eines AI-Schätzers abzurufen. SageMaker Auf den nachfolgenden Seiten finden Sie mehr Informationen darüber, wie Sie die beiden Parameter konfigurieren.
**Anmerkung**
Die folgenden Codebeispiele sind nicht direkt ausführbar. Fahren Sie mit den nächsten Abschnitten fort, um zu erfahren, wie Sie die einzelnen Parameter konfigurieren.
------
#### [ PyTorch ]
```
# An example of constructing a SageMaker AI PyTorch estimator
import boto3
import sagemaker
from sagemaker.pytorch import PyTorch
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=PyTorch(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.12.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ TensorFlow ]
```
# An example of constructing a SageMaker AI TensorFlow estimator
import boto3
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=TensorFlow(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.8.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ MXNet ]
```
# An example of constructing a SageMaker AI MXNet estimator
import sagemaker
from sagemaker.mxnet import MXNet
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=MXNet(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.7.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**Anmerkung**
Denn MXNet bei der Konfiguration des `profiler_config` Parameters können Sie nur die Systemüberwachung konfigurieren. Profiling-Framework-Metriken werden nicht unterstützt für MXNet.
------
#### [ XGBoost ]
```
# An example of constructing a SageMaker AI XGBoost estimator
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=XGBoost(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.5-1",
# Debugger-specific parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**Anmerkung**
Denn XGBoost wenn Sie den `profiler_config` Parameter konfigurieren, können Sie ihn nur für die Systemüberwachung konfigurieren. Profiling-Framework-Metriken werden nicht unterstützt für XGBoost.
------
#### [ Generic estimator ]
```
# An example of constructing a SageMaker AI generic estimator using the XGBoost algorithm base image
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import ProfilerConfig, DebuggerHookConfig, Rule, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
region=boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.5-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Debugger-specific parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
Im Folgenden finden Sie eine kurze Beschreibung der Parameter.
+ `profiler_config` – Konfigurieren Sie den Debugger so, dass er System- und Framework-Metriken aus Ihrem Trainingsauftrag sammelt und in Ihrem gesicherten S3-Bucket-URI oder auf Ihrem lokalen Computer speichert. Sie können festlegen, wie oft oder wie oft die Systemmetriken erfasst werden. Informationen zur Konfiguration des `profiler_config` Parameters finden Sie unter [Konfigurieren Sie Einstellungen für die grundlegende Profilerstellung der Systemressourcenauslastung](debugger-configure-system-monitoring.md) und [Schätzerkonfiguration für Framework-Profiling](debugger-configure-framework-profiling.md).
+ `rules`— Konfigurieren Sie diesen Parameter, um die integrierten SageMaker Debuger-Regeln zu aktivieren, die Sie parallel ausführen möchten. Stellen Sie sicher, dass Ihr Trainingsjob Zugriff auf diesen S3-Bucket hat. Die Regeln laufen auf Verarbeitungscontainern und analysieren automatisch Ihren Trainingsauftrag, um Probleme bei der Berechnung und der betrieblichen Leistung zu erkennen. Die [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) Regel ist die am besten integrierte Regel, die alle integrierten Profilerstellungsregeln ausführt und die Ergebnisse der Profilerstellung als Bericht in Ihrem gesicherten S3-Bucket speichert. Wie Sie den `rules` Parameter konfigurieren können, erfahren Sie unter [Verwenden Sie integrierte Profiler-Regeln, die von Amazon SageMaker Debugger verwaltet werden](use-debugger-built-in-profiler-rules.md).
**Anmerkung**
Der Debugger speichert Ausgabedaten sicher in Unterordnern Ihres Standard-S3-Buckets. Das Format des Standard-S3-Bucket-URI ist zum Beispiel `s3://sagemaker--<12digit_account_id>///`. Es gibt drei Unterordner, die von Debugger erstellt wurden: `debug-output`, `profiler-output` und `rule-output`. Sie können den Standard-S3-Bucket auch URIs mithilfe der [SageMaker AI-Estimator-Klassenmethoden](debugger-estimator-classmethods.md) abrufen.
In den folgenden Themen erfahren Sie, wie Sie die Debugger-spezifischen Parameter im Detail konfigurieren.
**Topics**
+ [Codevorlage für die Konfiguration eines SageMaker AI-Estimator-Objekts mit den SageMaker Debugger-Python-Modulen im SageMaker AI Python SDK](#debugger-configuration-structure-profiler)
+ [Konfigurieren Sie Einstellungen für die grundlegende Profilerstellung der Systemressourcenauslastung](debugger-configure-system-monitoring.md)
+ [Schätzerkonfiguration für Framework-Profiling](debugger-configure-framework-profiling.md)
+ [Aktualisierung der Debugger-Systemüberwachungs- und Framework-Profiling-Konfiguration, während ein Trainingsauftrag läuft.](debugger-update-monitoring-profiling.md)
+ [Deaktivieren Sie den Debugger](debugger-turn-off-profiling.md)
# Konfigurieren Sie Einstellungen für die grundlegende Profilerstellung der Systemressourcenauslastung
Um das Zeitintervall für die Erfassung der Nutzungsmetriken anzupassen, verwenden Sie die `ProfilerConfig` API-Operation, um ein Parameterobjekt zu erstellen und dabei je nach Wunsch ein SageMaker KI-Framework oder einen generischen Schätzer zu erstellen.
**Anmerkung**
Standardmäßig erfasst Debugger für alle SageMaker Trainingsjobs alle 500 Millisekunden Kennzahlen zur Ressourcennutzung von Amazon EC2 EC2-Instances für die Systemüberwachung, ohne dass Debugger-spezifische Parameter in AI-Schätzern angegeben sind. SageMaker
Der Debugger speichert die Systemmetriken im Standard-S3-Bucket. Das Format der standardmäßigen S3-Bucket-URI ist `s3://sagemaker--<12digit_account_id>//profiler-output/`.
Im folgenden Codebeispiel wird gezeigt, wie Sie den `profiler_config` Parameter mit einem Zeitintervall für die Systemüberwachung von 1000 Millisekunden einrichten.
```
from sagemaker.debugger import ProfilerConfig
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000
)
```
+ `system_monitor_interval_millis` (int) – Geben Sie die Überwachungsintervalle in Millisekunden an, um Systemmetriken aufzuzeichnen. Verfügbare Werte sind 100, 200, 500, 1000 (1 Sekunde), 5000 (5 Sekunden) und 60000 (1 Minute) Millisekunden. Der Standardwert ist 500 Millisekunden.
Informationen zum Fortschritt der Systemüberwachung finden Sie unter [Öffnen Sie das Amazon SageMaker Debugger Insights-Dashboard](debugger-on-studio-insights.md).
# Schätzerkonfiguration für Framework-Profiling
**Warnung**
Der SageMaker AI Debugger lehnt die [ SageMaker Framework-Profilerstellungsfunktion ab Version 2.11 und 2.0 zugunsten von Amazon Profiler](train-use-sagemaker-profiler.md) ab. TensorFlow PyTorch Sie können die Funktion weiterhin in den vorherigen Versionen der Frameworks und wie folgt verwenden. SDKs
SageMaker Python-SDK <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.11
Siehe auch [16. März 2023](debugger-release-notes.md#debugger-release-notes-20230315).
Um die Debugger-Framework-Profilerstellung zu aktivieren, konfigurieren Sie den `framework_profile_params` Parameter, wenn Sie einen Schätzer erstellen. Das Debugger-Framework-Profiling sammelt Framework-Metriken, wie z. B. Daten aus der Initialisierungsphase, Datenladeprozesse, Python-Operatoren von Deep-Learning-Frameworks und Trainingsskripten, detailliertes Profiling innerhalb und zwischen den Schritten, mit den Optionen cProfile oder Pyinstrument. Mithilfe der `FrameworkProfile` Klasse können Sie benutzerdefinierte Framework-Profiling-Optionen konfigurieren.
**Anmerkung**
Bevor Sie mit der Debugger-Framework-Profilerstellung beginnen, stellen Sie sicher, dass das Framework, das zur Erstellung Ihres Modells verwendet wurde, von Debugger für die Framework-Profilerstellung unterstützt wird. Weitere Informationen finden Sie unter [Unterstützte Frameworks und Algorithmen](debugger-supported-frameworks.md).
Der Debugger speichert die Framework-Metriken in einem Standard-S3-Bucket. Das Format der standardmäßigen S3-Bucket-URI ist `s3://sagemaker--<12digit_account_id>//profiler-output/`.
**Topics**
+ [Standard-Framework-Profiling](debugger-configure-framework-profiling-basic.md)
+ [Standardsystemüberwachung und benutzerdefinierte Framework-Profilerstellung für Zielschritte oder einen Zielzeitraum](debugger-configure-framework-profiling-range.md)
+ [Standardsystemüberwachung und benutzerdefinierte Framework-Profilerstellung mit verschiedenen Profilerstellungsoptionen](debugger-configure-framework-profiling-options.md)
# Standard-Framework-Profiling
Die standardmäßige Profilerstellung des Debugger-Frameworks umfasst die folgenden Optionen: detaillierte Profilerstellung, Profilerstellung für den Datenlader und Python-Profilierung. Der folgende Beispielcode ist die einfachste `profiler_config` Parametereinstellung, um die Standardsystemüberwachung und die Standard-Framework-Profilerstellung zu starten. Die `FrameworkProfile` Klasse im folgenden Beispielcode initiiert die standardmäßige Framework-Profilerstellung, wenn ein Trainingsauftrag gestartet wird.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile()
)
```
Mit dieser `profiler_config` Parameterkonfiguration ruft Debugger die Standardeinstellungen für Überwachung und Profilerstellung auf. Der Debugger überwacht Systemmetriken alle 500 Millisekunden, erstellt Profile für den fünften Schritt mit der Option für die detaillierte Profilerstellung, für den siebten Schritt mit der Option für die Profilerstellung des Dataloaders und für den neunten, zehnten und elften Schritt mit der Python-Profilerstellungsoption.
Verfügbare Konfigurationsoptionen für die Profilerstellung, die Standardparametereinstellungen und Beispiele für deren Konfiguration finden Sie unter [Standardsystemüberwachung und benutzerdefinierte Framework-Profilerstellung mit verschiedenen Profilerstellungsoptionen](debugger-configure-framework-profiling-options.md) und [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
Wenn Sie das Systemüberwachungsintervall ändern und die standardmäßige Framework-Profilerstellung aktivieren möchten, können Sie den `system_monitor_interval_millis` Parameter explizit mit dem `framework_profile_params` Parameter angeben. Um beispielsweise alle 1000 Millisekunden zu überwachen und das Standard-Framework-Profiling zu aktivieren, verwenden Sie den folgenden Beispielcode.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile()
)
```
Weitere Informationen zur `FrameworkProfile` Klasse finden Sie unter [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
# Standardsystemüberwachung und benutzerdefinierte Framework-Profilerstellung für Zielschritte oder einen Zielzeitraum
Wenn Sie Zielschritte oder Zielzeitintervalle angeben möchten, um ein Profil für Ihren Trainingsauftrag zu erstellen, müssen Sie Parameter für die `FrameworkProfile` Klasse angeben. In den folgenden Codebeispielen wird gezeigt, wie Sie die Zielbereiche für die Profilerstellung zusammen mit der Systemüberwachung angeben.
+ **Für einen Zielschrittbereich**
Bei der folgenden Beispielkonfiguration überwacht der Debugger den gesamten Trainingsauftrag alle 500 Millisekunden (Standardüberwachung) und erstellt Profile für einen Zielschrittbereich von Schritt 5 bis Schritt 15 (für 10 Schritte).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
Mit der folgenden Beispielkonfiguration überwacht Debugger den gesamten Trainingsauftrag alle 1000 Millisekunden und erstellt Profile für einen Zielschrittbereich von Schritt 5 bis Schritt 15 (für 10 Schritte).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
+ **Für einen Zielzeitraum**
Bei der folgenden Beispielkonfiguration überwacht Debugger den gesamten Trainingsauftrag alle 500 Millisekunden (Standardüberwachung) und erstellt ein Profil für einen Zielzeitraum von der aktuellen Unix-Zeit für 600 Sekunden.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
Mit der folgenden Beispielkonfiguration überwacht Debugger den gesamten Trainingsauftrag alle 1000 Millisekunden und erstellt ein Profil für einen Zielzeitraum von der aktuellen Unix-Zeit für 600 Sekunden.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
Die Framework-Profilerstellung wird für alle Profilerstellungsoptionen im Zielschritt oder Zeitraum durchgeführt.
Weitere Informationen zu verfügbaren Profilerstellungsoptionen finden Sie unter [SageMaker Debugger APIs — FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
Im nächsten Abschnitt erfahren Sie, wie Sie die verfügbaren Profiling-Optionen per Skript erstellen.
# Standardsystemüberwachung und benutzerdefinierte Framework-Profilerstellung mit verschiedenen Profilerstellungsoptionen
Dieser Abschnitt enthält Informationen zu den unterstützten Konfigurationsklassen für das Profiling sowie eine Beispielkonfiguration. Sie können die folgenden Profilkonfigurationsklassen verwenden, um die Framework-Profilerstellungsoptionen zu verwalten:
+ [DetailedProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig)— Geben Sie einen Zielschritt oder einen Zeitraum an, um Framework-Operationen mithilfe der nativen Framework-Profiler (Profiler und TensorFlow Profiler) zu profilieren. PyTorch Wenn Sie beispielsweise die Debugger-Hooks verwenden TensorFlow, ermöglichen sie es dem TensorFlow Profiler, spezifische Framework-Metriken zu sammeln. TensorFlow Mit der detaillierten Profilerstellung können Sie alle Framework-Operatoren in einem Vorschritt (vor dem ersten Schritt), innerhalb von Schritten und zwischen den Schritten eines Trainingsauftrages profilieren.
**Anmerkung**
Eine detaillierte Profilerstellung kann den GPU-Speicherverbrauch erheblich erhöhen. Es wird nicht empfohlen, die detaillierte Profilerstellung für mehr als ein paar Schritte zu aktivieren.
+ [DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)— Geben Sie einen Zielschritt oder einen Zeitraum für die Profilierung von Deep-Learning-Framework-Dataloader-Prozessen an. Der Debugger erfasst jedes Dataloader-Ereignis der Frameworks.
**Anmerkung**
Die Profilerstellung von Dataloadern kann das Trainingsleistung beim Sammeln von Informationen von Datenladeprogrammen beeinträchtigen. Wir empfehlen, die Profilerstellung für Data Loader nicht länger als ein paar Schritte zu aktivieren.
Der Debugger ist so vorkonfiguriert, dass er Dataloader-Prozesse nur für die AWS Deep-Learning-Container annotiert. Der Debugger kann keine Profile für Dataloader-Prozesse aus anderen benutzerdefinierten oder externen Trainingscontainern erstellen.
+ [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)— Geben Sie einen Zielschritt oder einen Zeitbereich an, um Python-Funktionen zu profilieren. Sie können auch zwischen zwei Python-Profilern wählen: CProfile und Pyinstrument.
+ *cProfile* – Der Standard-Python-Profiler. cProfile sammelt Informationen für jeden Python-Operator, der während des Trainings aufgerufen wird. Mit CProfile spart Debugger kumulative Zeit und Anmerkungen für jeden Funktionsaufruf und liefert vollständige Details zu Python-Funktionen. Beim Deep Learning könnten die am häufigsten aufgerufenen Funktionen beispielsweise die Faltungsfilter und Backward-Pass-Operatoren sein, und CProfile erstellt für jede einzelne Funktion ein Profil. Für die Option CProfile können Sie außerdem eine Timer-Option auswählen: Gesamtzeit, CPU-Zeit und CPU-freie Zeit. Sie können zwar jeden Funktionsaufruf, der auf Prozessoren (sowohl CPU als auch GPU) ausgeführt wird, in CPU-Zeit profilieren. Mit der Option „Zeit außerhalb der CPU“ können Sie aber auch Engpässe im Netzwerk identifizieren I/O . Die Standardeinstellung ist die Gesamtzeit, und der Debugger berechnet sowohl die CPU-Zeit als auch die Zeit außerhalb der CPU. Mit CProfile können Sie bei der Analyse der Profildaten auf alle Funktionen zugreifen.
+ *Pyinstrument* – Pyinstrument ist ein Python-Profiler mit geringem Overhead, der auf Sampling basiert. Mit der Option Pyinstrument tastet der Debugger jede Millisekunde Profiling-Ereignisse ab. Da Pyinstrument die verstrichene Wanduhrzeit anstelle der CPU-Zeit misst, kann die Pyinstrument-Option eine bessere Wahl als die cProfile-Option sein, um das Profiling-Rauschen zu reduzieren (indem irrelevante Funktionsaufrufe herausgefiltert werden, die kumulativ schnell sind) und Operatoren zu erfassen, die tatsächlich rechenintensiv (kumulativ langsam) für das Training Ihres Modells sind. Mit Pyinstrument können Sie sich einen Baum von Funktionsaufrufen anzeigen lassen und so die Struktur und die Ursache der Langsamkeit besser verstehen.
**Anmerkung**
Die Aktivierung der Python-Profilerstellung kann die gesamte Trainingszeit verlangsamen. cProfile erstellt bei jedem Aufruf ein Profil der am häufigsten aufgerufenen Python-Operatoren, sodass die Verarbeitungszeit bei der Profilerstellung mit der Anzahl der Aufrufe zunimmt. Bei Pyinstrument nimmt die kumulative Zeit für die Profilerstellung aufgrund des Sampling-Mechanismus mit der Zeit zu.
Die folgende Beispielkonfiguration zeigt die vollständige Struktur, wenn Sie die verschiedenen Profilerstellungsoptionen mit angegebenen Werten verwenden.
```
import time
from sagemaker.debugger import (ProfilerConfig,
FrameworkProfile,
DetailedProfilingConfig,
DataloaderProfilingConfig,
PythonProfilingConfig,
PythonProfiler, cProfileTimer)
profiler_config=ProfilerConfig(
system_monitor_interval_millis=500,
framework_profile_params=FrameworkProfile(
detailed_profiling_config=DetailedProfilingConfig(
start_step=5,
num_steps=1
),
dataloader_profiling_config=DataloaderProfilingConfig(
start_step=7,
num_steps=1
),
python_profiling_config=PythonProfilingConfig(
start_step=9,
num_steps=1,
python_profiler=PythonProfiler.CPROFILE,
cprofile_timer=cProfileTimer.TOTAL_TIME
)
)
)
```
Weitere Informationen zu den verfügbaren Profilerstellungsoptionen finden Sie unter [DetailedProfilingConfig[DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig), und [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
# Aktualisierung der Debugger-Systemüberwachungs- und Framework-Profiling-Konfiguration, während ein Trainingsauftrag läuft.
Wenn Sie die Debugger-Überwachungskonfiguration für einen Trainingsjob aktivieren oder aktualisieren möchten, der gerade ausgeführt wird, verwenden Sie die folgenden Methoden der SageMaker AI Estimator-Erweiterung:
+ Gehen Sie wie folgt vor, um die Debugger-Systemüberwachung für einen laufenden Trainingsauftrages zu aktivieren und einen Debugger-Profilerstellungsbericht zu erhalten:
```
estimator.enable_default_profiling()
```
Wenn Sie diese `enable_default_profiling` Methode verwenden, initiiert der Debugger die Standardsystemüberwachung und die `ProfileReport` integrierte Regel, die am Ende des Trainingsauftrages einen umfassenden Profilerstellungsbericht generiert. Diese Methode kann nur aufgerufen werden, wenn der aktuelle Trainingsauftrag ohne Debugger-Überwachung und Profilerstellung ausgeführt wird.
[Weitere Informationen finden Sie unter [estimator.enable\$1default\$1profiling](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.enable_default_profiling) im Amazon Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Verwenden Sie Folgendes, um die Konfiguration der Systemüberwachung zu aktualisieren:
```
estimator.update_profiler(
system_monitor_interval_millis=500
)
```
[Weitere Informationen finden Sie unter [estimator.update\$1profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler) im Amazon Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# Deaktivieren Sie den Debugger
Wenn Sie den Debugger vollständig deaktivieren möchten, führen Sie einen der folgenden Schritte aus:
+ Führen Sie die folgenden Schritte aus, bevor Sie mit einem Trainingsauftrag beginnen:
Um die Profilerstellung zu deaktivieren, fügen Sie den `disable_profiler` Parameter Ihrem Schätzer hinzu und setzen Sie ihn auf `True`.
**Warnung**
Wenn Sie ihn deaktivieren, können Sie das umfassende Studio Debugger Insights-Dashboard und den automatisch generierten Profilerstellungsbericht nicht anzeigen.
Um das Debuggen zu deaktivieren, setzen Sie den Parameter `debugger_hook_config` auf `False`.
**Warnung**
Wenn Sie es deaktivieren, können Sie keine Ausgabetensoren sammeln und Ihre Modellparameter nicht debuggen.
```
estimator=Estimator(
...
disable_profiler=True
debugger_hook_config=False
)
```
Weitere Informationen zu den Debugger-spezifischen Parametern finden Sie unter [SageMaker AI Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) im [Amazon SageMaker ](https://sagemaker.readthedocs.io/en/stable) Python SDK.
+ Führen Sie die folgenden Schritte aus, wenn ein Trainingsauftrag ausgeführt wird:
Um sowohl die Überwachung als auch die Profilerstellung zu deaktivieren, während Ihr Trainingsauftrag ausgeführt wird, verwenden Sie die folgende Schätzer-Klassenmethode:
```
estimator.disable_profiling()
```
Verwenden Sie die folgende `update_profiler` Methode, um nur die Framework-Profilerstellung zu deaktivieren und die Systemüberwachung aufrechtzuerhalten:
```
estimator.update_profiler(disable_framework_metrics=true)
```
[Weitere Informationen zu den Estimator-Erweiterungsmethoden finden Sie in den Klassenmethoden [estimator.disable\$1profiling und [estimator.update\$1profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler)](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.disable_profiling) in der Amazon Python SDK-Dokumentation. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# Verwenden Sie integrierte Profiler-Regeln, die von Amazon SageMaker Debugger verwaltet werden
Die in Amazon SageMaker Debugger integrierten Profiler-Regeln analysieren Systemmetriken und Framework-Operationen, die während des Trainings eines Modells erfasst wurden. Debugger bietet eine `ProfilerRule` API-Operation, mit deren Hilfe die Regeln konfiguriert werden können, um Trainingsressourcen und Rechenoperationen zu überwachen und Anomalien zu erkennen. Mithilfe der Profilerstellungsregeln können Sie beispielsweise erkennen, ob Rechenprobleme wie CPU-Engpässe, übermäßige I/O Wartezeiten, ungleichmäßige Arbeitslast zwischen GPU-Workern und unzureichende Auslastung der Rechenressourcen vorliegen. Eine vollständige Liste der verfügbaren integrierten Profilerstellungsregeln finden Sie unter [Liste der im Debugger integrierten Profiler-Regeln](debugger-built-in-profiler-rules.md). Im Folgenden erfahren Sie, wie Sie die integrierten Debugger-Regeln mit Standardparametereinstellungen und benutzerdefinierten Parameterwerten verwenden.
**Anmerkung**
Die integrierten Regeln werden über SageMaker Amazon-Verarbeitungscontainer bereitgestellt und vollständig von SageMaker Debugger ohne zusätzliche Kosten verwaltet. Weitere Informationen zur Abrechnung finden Sie auf der Seite mit den [ SageMaker Amazon-Preisen](https://aws.amazon.com/sagemaker/pricing/).
**Topics**
+ [Verwenden Sie die in SageMaker Debugger integrierten Profiler-Regeln mit ihren Standardparametereinstellungen](#debugger-built-in-profiler-rules-configuration)
+ [Verwenden Sie die in Debugger integrierten Profiler-Regeln mit benutzerdefinierten Parameterwerten](#debugger-built-in-profiler-rules-configuration-param-change)
## Verwenden Sie die in SageMaker Debugger integrierten Profiler-Regeln mit ihren Standardparametereinstellungen
Um Ihrem Estimator integrierte SageMaker Debugger-Regeln hinzuzufügen, müssen Sie ein Listenobjekt konfigurieren. `rules` Der folgende Beispielcode zeigt die grundlegende Struktur der Auflistung der integrierten SageMaker Debugger-Regeln.
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_n()),
... # You can also append more debugging rules in the Rule.sagemaker(rule_configs.*()) format.
]
estimator=Estimator(
...
rules=rules
)
```
Eine vollständige Liste der verfügbaren integrierten Regeln finden Sie unter [Liste der im Debugger integrierten Profiler-Regeln](debugger-built-in-profiler-rules.md).
Um die Profilerstellungsregeln zu verwenden und die Rechenleistung und den Fortschritt Ihrer Trainingsaufgabe zu überprüfen, fügen Sie die [https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report)Regel Debugger hinzu. SageMaker [Diese Regel aktiviert alle integrierten Regeln der Debugger-Familie. ProfilerRule](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#debugger-built-in-profiler-rules-ProfilerRule) `ProfilerRule` Darüber hinaus generiert diese Regel einen aggregierten Profilerstellungsbericht. Weitere Informationen finden Sie unter [Mit SageMaker dem Debugger generierter Profilerstellungsbericht](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Sie können den folgenden Code verwenden, um die Regel für den Profilerstellungsbericht zu Ihrem Trainingsschätzer hinzuzufügen.
```
from sagemaker.debugger import Rule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.ProfilerReport())
]
```
Wenn Sie den Trainingsauftrag mit der `ProfilerReport` Regel starten, erfasst der Debugger alle 500 Millisekunden Daten zur Ressourcennutzung. Der Debugger analysiert die Ressourcennutzung, um festzustellen, ob Ihr Modell Engpassprobleme aufweist. Wenn die Regeln Trainingsanomalien erkennen, ändert sich der Status der Regelauswertung in `IssueFound`. Mit Amazon CloudWatch Events und können Sie automatisierte Aktionen einrichten, z. B. das Melden von Schulungsproblemen und das Beenden von Schulungsaufträgen. AWS Lambda Weitere Informationen finden Sie unter [Aktion im Zusammenhang mit Amazon SageMaker Debugger-Regeln](debugger-action-on-rules.md).
## Verwenden Sie die in Debugger integrierten Profiler-Regeln mit benutzerdefinierten Parameterwerten
Wenn Sie die Werte der integrierten Regelparameter anpassen und die Regex für die Tensorsammlung anpassen möchten, konfigurieren Sie die `base_config` und `rule_parameters` Parameter für die `ProfilerRule.sagemaker` und `Rule.sagemaker` Klassenmethoden. Bei den `Rule.sagemaker` Klassenmethoden können Sie die Tensorsammlungen auch über den `collections_to_save` Parameter anpassen. Anweisungen zur Verwendung der `CollectionConfig` Klasse, finden Sie unter [Tensor-Sammlungen mithilfe der `CollectionConfig` API konfigurieren](debugger-configure-tensor-collections.md).
Verwenden Sie die folgende Konfigurationsvorlage für integrierte Regeln, um Parameterwerte anzupassen. Indem Sie die Regelparameter nach Ihren Wünschen ändern, können Sie die Sensitivität der Regeln, die initiiert werden sollen, anpassen.
+ Das `base_config`-Argument ist der Ort, an dem Sie die integrierten Regelmethoden aufrufen.
+ Das `rule_parameters`-Argument besteht darin, die Standardschlüsselwerte der unter [Liste der im Debugger integrierten Profiler-Regeln](debugger-built-in-profiler-rules.md) aufgeführten integrierten Regeln anzupassen.
Weitere Informationen über die Debugger-Regelklasse, Methoden und Parameter finden Sie unter [SageMaker AI Debugger Rule class](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs, CollectionConfig
rules=[
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInProfilerRuleName(),
rule_parameters={
"key": "value"
}
)
]
```
Die Parameterbeschreibungen und Beispiele für die Anpassung von Werten finden Sie für jede Regel unter [Liste der im Debugger integrierten Profiler-Regeln](debugger-built-in-profiler-rules.md).
Eine einfache JSON-Konfiguration der integrierten Debuger-Regeln mithilfe der `CreateTrainingJob` API finden Sie unter [Debugger mithilfe SageMaker der API konfigurieren](debugger-createtrainingjob-api.md).
# Liste der im Debugger integrierten Profiler-Regeln
Verwenden Sie die integrierten Debuger-Profiler-Regeln, die von Amazon SageMaker Debugger bereitgestellt werden, und analysieren Sie die beim Training Ihrer Modelle gesammelten Metriken. Die in den Debugger integrierten Regeln überwachen verschiedene allgemeine Bedingungen, die für die erfolgreiche Durchführung eines performanten Trainingsauftrags entscheidend sind. Sie können die integrierten Profiler-Regeln mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) oder der SageMaker Low-Level-API-Operationen aufrufen. Für die Nutzung der integrierten Regeln fallen keine zusätzlichen Kosten an. Weitere Informationen zur Abrechnung finden Sie auf der Seite mit den [ SageMaker Amazon-Preisen](https://aws.amazon.com/sagemaker/pricing/).
**Anmerkung**
Die maximale Anzahl integrierter Profiler-Regeln, die Sie einem Schulungsjob zuordnen können, beträgt 20. SageMaker Der Debugger verwaltet die integrierten Regeln vollständig und analysiert Ihren Trainingsjob synchron.
**Wichtig**
Um die neuen Debugger-Funktionen verwenden zu können, müssen Sie das SageMaker Python-SDK und die SMDebug Client-Bibliothek aktualisieren. Führen Sie in Ihrem IPython-Kernel, Jupyter-Notebook oder Ihrer JupyterLab Umgebung den folgenden Code aus, um die neuesten Versionen der Bibliotheken zu installieren und den Kernel neu zu starten.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Profiler-Regeln
Die folgenden Regeln sind die integrierten Debuger-Regeln, die mit der `ProfilerRule.sagemaker` Klassenmethode aufgerufen werden können.
Integrierte Debuger-Regel für die Generierung des Profilerstellungsberichts
| Gültigkeitsbereich | Integrierte Regeln |
| --- | --- |
| Bericht zur Profilerstellung für jeden Trainingsjob SageMaker | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
In den Debugger integrierte Regeln für die Erstellung von Profilen der Hardware-Systemressourcennutzung (Systemmetriken)
| Gültigkeitsbereich | Integrierte Regeln |
| --- | --- |
| Generische Regeln zur Systemüberwachung für jeden SageMaker Schulungsjob | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
Integrierte Debugging-Regeln für die Profilerstellung von Framework-Metriken
| Gültigkeitsbereich | Integrierte Regeln |
| --- | --- |
| Regeln zur Profilerstellung für Deep-Learning-Frameworks (TensorFlow und PyTorch) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
**Warnung**
Der SageMaker AI Debugger lehnt die [ SageMaker Framework-Profilerstellungsfunktion ab Version 2.11 und 2.0 zugunsten von Amazon Profiler](train-use-sagemaker-profiler.md) ab. TensorFlow PyTorch Sie können die Funktion weiterhin in den vorherigen Versionen der Frameworks und wie folgt verwenden. SDKs
SageMaker Python-SDK <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.11
Siehe auch [16. März 2023](debugger-release-notes.md#debugger-release-notes-20230315).
**Verwenden Sie das folgende Konfigurationsformat, um die integrierten Regeln mit Standardparameterwerten** zu verwenden:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_n())
]
```
**Um die integrierten Regeln mit individuellen Parameterwerten zu verwenden**, verwenden Sie das folgende Konfigurationsformat:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInRuleName(),
rule_parameters={
"key": "value"
}
)
]
```
Die verfügbaren Schlüssel für den Parameter `rule_parameters` finden Sie in den Tabellen mit den Parameterbeschreibungen.
Unter den Tabellen mit den Parameterbeschreibungen finden Sie für jede integrierte Regel Beispielkonfigurationscodes.
+ Eine vollständige Anleitung und Beispiele für die Verwendung der in den Debugger integrierten Regeln finden Sie unter [Beispielcode für integrierte Debugger-Regeln](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Eine vollständige Anleitung zur Verwendung der integrierten Regeln mit den SageMaker Low-Level-API-Operationen finden Sie unter. [Debugger mithilfe SageMaker der API konfigurieren](debugger-createtrainingjob-api.md)
## ProfilerReport
Die ProfilerReport Regel ruft alle integrierten Regeln für die Überwachung und Profilerstellung auf. Sie erstellt einen Profilerstellungsbericht und aktualisiert, wenn die einzelnen Regeln ausgelöst werden. Sie können einen umfassenden Profilerstellungsbericht herunterladen, während ein Trainingsauftrag ausgeführt wird oder nachdem der Trainingsauftrag abgeschlossen ist. Sie können die Werte der Regelparameter anpassen, um die Sensitivität der integrierten Überwachungs- und Profilerstellungsregeln anzupassen. Der folgende Beispielcode zeigt das grundlegende Format zur Anpassung der integrierten Regelparameter mithilfe der ProfilerReport Regel.
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
_ = value
)
)
]
```
Wenn Sie diese ProfilerReport Regel ohne benutzerdefinierte Parameter auslösen, wie im folgenden Beispielcode gezeigt, löst die ProfilerReport Regel alle integrierten Regeln für die Überwachung und Profilerstellung mit ihren Standardparameterwerten aus.
```
rules=[ProfilerRule.sagemaker(rule_configs.ProfilerReport())]
```
Der folgende Beispielcode zeigt, wie Sie den Parameter der CPUBottleneck Regel und den `cpu_threshold` IOBottleneck Regelparameter angeben und anpassen. `threshold`
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
CPUBottleneck_cpu_threshold = 90,
IOBottleneck_threshold = 90
)
)
]
```
Informationen zum Inhalt des Profiler-Berichts finden Sie unter [SageMaker Debugger-Profiling-Bericht](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Da diese Regel alle Profilerstellungsregeln aktiviert, können Sie den Status der Regelanalyse auch mithilfe der [SageMaker Debugger-Benutzeroberfläche](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html) in Studio Experiments überprüfen. SageMaker
Parameterbeschreibungen für die Regel OverallSystemUsage
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| \$1 | Anpassbarer Parameter zur Anpassung der Schwellenwerte anderer integrierter Überwachungs- und Profilerstellungsregeln. **Optional** Standardwert: `None` |
## BatchSize
Die BatchSize Regel hilft zu erkennen, ob die GPU aufgrund einer geringen Batchgröße nicht ausgelastet ist. Um dieses Problem zu erkennen, überwacht diese Regel die durchschnittliche CPU-Auslastung, GPU-Auslastung und GPU-Speicherauslastung. Wenn die Auslastung von CPU-, GPU- und GPU-Speicher im Durchschnitt gering ist, kann dies darauf hindeuten, dass der Trainingsauftrag entweder auf einem kleineren Instance-Typ oder mit einer größeren Batchgröße ausgeführt werden kann. Diese Analyse funktioniert nicht für Frameworks, die Speicherplatz stark überlasten. Eine Erhöhung der Batchgröße kann jedoch zu Engpässen bei der Verarbeitung oder beim Laden von Daten führen, da bei jeder Iteration mehr Zeit für die Datenvorverarbeitung erforderlich ist.
Parameterbeschreibungen für die Regel BatchSize
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| cpu\$1threshold\$1p95 | Definiert den Schwellenwert für das 95. Quantil der CPU-Auslastung in Prozent. **Optional** Gültige Werte: Ganzzahl Standardwert: `70` (in Prozent) |
| gpu\$1threshold\$1p95 | Definiert den Schwellenwert für das 95. Quantil der GPU-Auslastung in Prozent. **Optional** Gültige Werte: Ganzzahl Standardwert: `70` (in Prozent) |
| gpu\$1memory\$1threshold\$1p95 | Definiert den Schwellenwert für das 95. Quantil der GPU-Speicherauslastung in Prozent. **Optional** Gültige Werte: Ganzzahl Standardwerte: `70` (in Prozent) |
| patience | Definiert die Anzahl der Datenpunkte, mit denen übersprungen werden soll, bis die Regel mit der Auswertung beginnt. In den ersten Schritten von Trainingsauftrages ist in der Regel ein hohes Volumen an Datenprozessen zu verzeichnen. Halten Sie die Regel also geduldig und verhindern Sie, dass sie mit einer bestimmten Anzahl von Profilerstellungsdaten, die Sie mit diesem Parameter angeben, zu früh aufgerufen wird. **Optional** Gültige Werte: Ganzzahl Standardwerte: `100` |
| window | Fenstergröße für die Berechnung von Quantilen. **Optional** Gültige Werte: Ganzzahl Standardwerte: `500` |
| scan\$1interval\$1us | Zeitintervall, in dem Timeline-Dateien gescannt werden. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
## CPUBottleneck
Die CPUBottleneck Regel hilft zu erkennen, ob die GPU aufgrund von CPU-Engpässen nicht ausreichend ausgelastet ist. Die Regel gibt True zurück, wenn die Anzahl der CPU-Engpässe einen vordefinierten Schwellenwert überschreitet.
Parameterbeschreibungen für die Regel CPUBottleneck
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold | Definiert den Schwellenwert für das Verhältnis der Engpasszeit zur gesamten Trainingszeit. Wenn der Anteil den für den Schwellenwertparameter angegebenen Prozentsatz übersteigt, setzt die Regel den Status der Regel auf True. **Optional** Gültige Werte: Ganzzahl Standardwert: `50` (in Prozent) |
| gpu\$1threshold | Ein Schwellenwert, der eine geringe GPU-Auslastung definiert. **Optional** Gültige Werte: Ganzzahl Standardwert: `10` (in Prozent) |
| cpu\$1threshold | Ein Schwellenwert, der eine hohe CPU-Auslastung definiert. **Optional** Gültige Werte: Ganzzahl Standardwerte: `90` (in Prozent) |
| patience | Definiert die Anzahl der Datenpunkte, mit denen übersprungen werden soll, bis die Regel mit der Auswertung beginnt. In den ersten Schritten von Trainingsauftrages ist in der Regel ein hohes Volumen an Datenprozessen zu verzeichnen. Halten Sie die Regel also geduldig und verhindern Sie, dass sie mit einer bestimmten Anzahl von Profilerstellungsdaten, die Sie mit diesem Parameter angeben, zu früh aufgerufen wird. **Optional** Gültige Werte: Ganzzahl Standardwerte: `100` |
| scan\$1interval\$1us | Zeitintervall, in dem Timeline-Dateien gescannt werden. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
## GPUMemoryErhöhen
Die Regel „ GPUMemoryErhöhen“ hilft dabei, einen starken Anstieg der Speichernutzung am zu erkennen GPUs.
Parameterbeschreibungen für die Regel „ GPUMemoryErhöhen“
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| increase | Definiert den Schwellenwert für die absolute Speicherzunahme. **Optional** Gültige Werte: Ganzzahl Standardwert: `10` (in Prozent) |
| patience | Definiert die Anzahl der Datenpunkte, mit denen übersprungen werden soll, bis die Regel mit der Auswertung beginnt. In den ersten Schritten von Trainingsauftrages ist in der Regel ein hohes Volumen an Datenprozessen zu verzeichnen. Halten Sie die Regel also geduldig und verhindern Sie, dass sie mit einer bestimmten Anzahl von Profilerstellungsdaten, die Sie mit diesem Parameter angeben, zu früh aufgerufen wird. **Optional** Gültige Werte: Ganzzahl Standardwerte: `100` |
| window | Fenstergröße für die Berechnung von Quantilen. **Optional** Gültige Werte: Ganzzahl Standardwerte: `500` |
| scan\$1interval\$1us | Zeitintervall, in dem Timeline-Dateien gescannt werden. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
## IOBottleneck
Diese Regel hilft zu erkennen, ob die GPU aufgrund von Daten-IO-Engpässen nicht ausreichend ausgelastet ist. Die Regel gibt True zurück, wenn die Anzahl der IO-Engpässe einen vordefinierten Schwellenwert überschreitet.
Parameterbeschreibungen für die Regel IOBottleneck
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold | Definiert den Schwellenwert, ab dem Rule True zurückgibt.**Optional**Gültige Werte: GanzzahlStandardwert: `50` (in Prozent) |
| gpu\$1threshold | Ein Schwellenwert, der definiert, wann die GPU als nicht ausgelastet gilt. **Optional** Gültige Werte: Ganzzahl Standardwert: `70` (in Prozent) |
| io\$1threshold | Ein Schwellenwert, der eine hohe IO-Wartezeit definiert.**Optional**Gültige Werte: GanzzahlStandardwerte: `50` (in Prozent) |
| patience | Definiert die Anzahl der Datenpunkte, mit denen übersprungen werden soll, bis die Regel mit der Auswertung beginnt. In den ersten Schritten von Trainingsauftrages ist in der Regel ein hohes Volumen an Datenprozessen zu verzeichnen. Halten Sie die Regel also geduldig und verhindern Sie, dass sie mit einer bestimmten Anzahl von Profilerstellungsdaten, die Sie mit diesem Parameter angeben, zu früh aufgerufen wird.**Optional**Gültige Werte: GanzzahlStandardwerte: `1000` |
| scan\$1interval\$1us | Zeitintervall, in dem Timeline-Dateien gescannt werden. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
## LoadBalancing
Die LoadBalancing Regel hilft dabei, Probleme beim Workload-Balancing zwischen mehreren GPUs zu erkennen.
Parameterbeschreibungen für die LoadBalancing Regel
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold | Definiert den Prozentsatz der Arbeitslast. **Optional** Gültige Werte: Ganzzahl Standardwert: `0.5` (Anteil ohne Einheit) |
| patience | Definiert die Anzahl der Datenpunkte, mit denen übersprungen werden soll, bis die Regel mit der Auswertung beginnt. In den ersten Schritten von Trainingsauftrages ist in der Regel ein hohes Volumen an Datenprozessen zu verzeichnen. Halten Sie die Regel also geduldig und verhindern Sie, dass sie mit einer bestimmten Anzahl von Profilerstellungsdaten, die Sie mit diesem Parameter angeben, zu früh aufgerufen wird. **Optional** Gültige Werte: Ganzzahl Standardwerte: `10` |
| scan\$1interval\$1us | Zeitintervall, in dem Timeline-Dateien gescannt werden. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
## Niedrig GPUUtilization
Die GPUUtilization Niedrig-Regel hilft zu erkennen, ob die GPU-Auslastung gering ist oder Schwankungen unterliegt. Dies wird für jede GPU auf jedem Worker überprüft. Die Regel gibt True zurück, wenn das 95. Quantil unter threshold\$1p95 liegt, was auf eine Unterauslastung hinweist. Die Regel gibt true zurück, wenn das 95. Quantil über Threshold\$1p95 und das 5. Quantil unter Threshold\$1p5 liegt, was auf Schwankungen hinweist.
Parameterbeschreibungen für die GPUUtilization Low-Regel
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold\$1p95 | Ein Schwellenwert für das 95. Quantil, bei dessen Unterschreitung die GPU als nicht ausgelastet gilt. **Optional** Gültige Werte: Ganzzahl Standardwert: `70` (in Prozent) |
| threshold\$1p5 | Ein Schwellenwert für das 5. Quantil. Der Standardwert ist 10 Prozent.**Optional**Gültige Werte: GanzzahlStandardwerte: `10` (in Prozent) |
| patience | Definiert die Anzahl der Datenpunkte, mit denen übersprungen werden soll, bis die Regel mit der Auswertung beginnt. In den ersten Schritten von Trainingsauftrages ist in der Regel ein hohes Volumen an Datenprozessen zu verzeichnen. Halten Sie die Regel also geduldig und verhindern Sie, dass sie mit einer bestimmten Anzahl von Profilerstellungsdaten, die Sie mit diesem Parameter angeben, zu früh aufgerufen wird. **Optional** Gültige Werte: Ganzzahl Standardwerte: `1000` |
| window | Fenstergröße für die Berechnung von Quantilen. **Optional** Gültige Werte: Ganzzahl Standardwerte: `500` |
| scan\$1interval\$1us | Zeitintervall, in dem Timeline-Dateien gescannt werden. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
## OverallSystemUsage
Die OverallSystemUsage Regel misst die Gesamtsystemnutzung pro Worker-Knoten. Die Regel aggregiert derzeit nur Werte pro Knoten und berechnet deren Perzentile.
Parameterbeschreibungen für die OverallSystemUsage Regel
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| scan\$1interval\$1us | Zeitintervall zum Scannen von Timeline-Dateien. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
## MaxInitializationTime
Die MaxInitializationTime Regel hilft zu erkennen, ob die Trainingsinitialisierung zu viel Zeit in Anspruch nimmt. Die Regel wartet, bis der erste Schritt verfügbar ist.
Parameterbeschreibungen für die Regel MaxInitializationTime
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold | Definiert den Schwellenwert in Minuten, bis der erste Schritt verfügbar ist. **Optional** Gültige Werte: Ganzzahl Standardwert: `20` (in Minuten) |
| scan\$1interval\$1us | Zeitintervall, mit dem Timeline-Dateien gescannt werden. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
## OverallFrameworkMetrics
Die OverallFrameworkMetrics Regel fasst die Zeit zusammen, die für Framework-Metriken wie Vorwärts- und Rückwärtsdurchläufe und das Laden von Daten aufgewendet wurde.
Parameterbeschreibungen für die Regel OverallFrameworkMetrics
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| scan\$1interval\$1us | Zeitintervall zum Scannen von Timeline-Dateien. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
## StepOutlier
Die StepOutlier Regel hilft dabei, Ausreißer bei der Schrittdauer zu erkennen. Diese Regel gibt zurück `True` wenn es Ausreißer gibt, deren Schrittdauer größer als `stddev` Sigmas der gesamten Schrittdauer in einem Zeitraum ist.
Parameterbeschreibungen für die Regel StepOutlier
| Name des Parameters | Description |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird von Amazon SageMaker Debugger automatisch auf den aktuellen Trainingsjob gesetzt. **Erforderlich** Zulässige Werte: String |
| stddev | Definiert einen Faktor, mit dem die Standardabweichung multipliziert werden soll. Die Regel wird beispielsweise standardmäßig aufgerufen, wenn eine Schrittdauer größer oder kleiner als das Fünffache der Standardabweichung ist. **Optional** Gültige Werte: Ganzzahl Standardwert: `5` (in Minuten) |
| mode | Modus, in dem die Schritte gespeichert wurden und in dem die Regel ausgeführt werden soll. Standardmäßig wird die Regel für Schritte aus der EVAL- und TRAIN-Phase ausgeführt**Optional**Gültige Werte: GanzzahlStandardwert: `5` (in Minuten) |
| n\$1outliers | Wie viele Ausreißer müssen ignoriert werden, bevor die Regel True zurückgibt**Optional**Gültige Werte: GanzzahlStandardwert: `10` |
| scan\$1interval\$1us | Zeitintervall, in dem Timeline-Dateien gescannt werden. **Optional** Gültige Werte: Ganzzahl Standardwerte: `60000000` (in Mikrosekunden) |
# Amazon SageMaker Debugger-Benutzeroberfläche in Amazon SageMaker Studio Classic Experiments
Verwenden Sie das Amazon SageMaker Debugger Insights-Dashboard in Amazon SageMaker Studio Classic Experiments, um Ihre Modellleistung und Systemengpässe zu analysieren, während Sie Trainingsjobs auf Amazon Elastic Compute Cloud (Amazon EC2) -Instances ausführen. Gewinnen Sie mit den Debugger-Dashboards Einblicke in Ihre Trainingsaufträge und verbessern Sie die Trainingsleistung und Genauigkeit Ihres Modells. Standardmäßig überwacht der Debugger Systemmetriken (CPU, GPU, GPU-Speicher, Netzwerk und Daten-I/O) alle 500 Millisekunden und grundlegende Ausgabetensoren (Verlust und Genauigkeit) bei Trainingsaufgaben alle 500 Iterationen. Sie können auch die Debugger-Konfigurationsparameterwerte weiter anpassen und die Speicherintervalle über die Studio Classic-Benutzeroberfläche oder mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) anpassen.
**Wichtig**
Wenn Sie eine bestehende Studio-App verwenden, löschen Sie die App und starten Sie sie neu, um die neuesten Studio-Classic-Funktionen nutzen zu können. Anweisungen zum Neustarten und Aktualisieren Ihrer Studio Classic-Umgebung finden Sie unter [Amazon SageMaker AI Studio Classic aktualisieren](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks-update.html).
**Topics**
+ [Öffnen Sie das Amazon SageMaker Debugger Insights-Dashboard](debugger-on-studio-insights.md)
+ [Dashboard-Controller von Amazon SageMaker Debugger Insights](debugger-on-studio-insights-controllers.md)
+ [Erkunden Sie das Amazon SageMaker Debugger Insights-Dashboard](debugger-on-studio-insights-walkthrough.md)
+ [Fahren Sie die Amazon SageMaker Debugger Insights-Instanz herunter](debugger-on-studio-insights-close.md)
# Öffnen Sie das Amazon SageMaker Debugger Insights-Dashboard
Im SageMaker Debugger Insights-Dashboard in Studio Classic können Sie die Rechenressourcenauslastung, die Ressourcennutzung und die Systemengpässe Ihres Trainingsjobs, der auf Amazon EC2 EC2-Instances ausgeführt wird, in Echtzeit und nach Schulungen einsehen.
**Anmerkung**
Das SageMaker Debugger Insights-Dashboard führt eine Studio Classic-Anwendung auf einer `ml.m5.4xlarge` Instance aus, um die Visualisierungen zu verarbeiten und zu rendern. Auf jeder Registerkarte SageMaker Debugger Insights wird eine Studio Classic-Kernelsitzung ausgeführt. Auf einer einzigen Instanz werden mehrere Kernel-Sitzungen für mehrere SageMaker Debugger Insights-Tabs ausgeführt. Wenn Sie einen SageMaker Debugger Insights-Tab schließen, wird auch die entsprechende Kernel-Sitzung geschlossen. Die Studio-Classic-Anwendung bleibt aktiv und es fallen Gebühren für die Nutzung der `ml.m5.4xlarge`-Instance an. Informationen zu den Preisen finden Sie auf der Seite mit den [ SageMaker Amazon-Preisen](https://aws.amazon.com/sagemaker/pricing/).
**Wichtig**
Wenn Sie das SageMaker Debugger Insights-Dashboard nicht mehr verwenden, müssen Sie die `ml.m5.4xlarge` Instance herunterfahren, um Gebühren zu vermeiden. Anweisungen zum Herunterfahren der Instance finden Sie unter [Fahren Sie die Amazon SageMaker Debugger Insights-Instanz herunter](debugger-on-studio-insights-close.md).
**Um das Debugger Insights-Dashboard SageMaker zu öffnen**
1. Wählen Sie auf der Studio-Classic-**Startseite** im linken Navigationsbereich **Experimente** aus.
1. Suchen Sie auf der Seite **Experimente** nach Ihrem Trainingsauftrag. Wenn dein Trainingsjob mit einem Testlauf eingerichtet ist, sollte der Job auf dem Tab **Experimente** angezeigt werden. Wenn Sie keinen Testlauf eingerichtet haben, sollte der Job auf dem Tab **Nicht zugewiesene Läufe** angezeigt werden.
1. Wählen (klicken) Sie auf den Link mit dem Trainingsauftragsname, um die Aufgabendetails zu sehen.
1. Wählen Sie im Menü **ÜBERSICHT** die Option **Debugger** aus. Daraufhin sollten die folgenden beiden Abschnitte angezeigt werden.
+ Im Abschnitt **Debugger-Regeln** können Sie den Status der integrierten Debugger-Regeln einsehen, die mit dem Trainingsauftrag verknüpft sind.
+ Im Abschnitt **Debugger Insights** finden Sie Links zum Öffnen von SageMaker Debugger Insights auf dem Dashboard.
1. Wählen Sie im Abschnitt **SageMaker Debugger Insights** den Link mit dem Namen des Trainingsjobs, um das SageMaker Debugger Insights-Dashboard zu öffnen. Dadurch wird ein **Debug [] your-training-job-name -Fenster** geöffnet. In diesem Fenster bietet Debugger einen Überblick über die Rechenleistung Ihres Trainingsjobs auf Amazon-EC2-Instances und hilft Ihnen, Probleme bei der Rechenressourcenauslastung zu identifizieren.
Sie können auch einen aggregierten Profilerstellungsbericht herunterladen, indem Sie die integrierte [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)Debuger-Regel hinzufügen. SageMaker Weitere Informationen finden [Sie unter Integrierte Profiler-Regeln konfigurieren und mit dem Debugger generierter](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html) [Profilerstellungsbericht. SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html)
# Dashboard-Controller von Amazon SageMaker Debugger Insights
Es gibt verschiedene Komponenten des Debugger-Controllers für die Überwachung und Profilerstellung. In diesem Handbuch erfahren Sie mehr über die Debugger-Kontrollkomponenten.
**Anmerkung**
Das SageMaker Debugger Insights-Dashboard führt eine Studio Classic-App auf einer `ml.m5.4xlarge` Instance aus, um die Visualisierungen zu verarbeiten und zu rendern. Auf jeder Registerkarte SageMaker Debugger Insights wird eine Studio Classic-Kernelsitzung ausgeführt. Auf einer einzigen Instanz werden mehrere Kernel-Sitzungen für mehrere SageMaker Debugger Insights-Tabs ausgeführt. Wenn Sie einen SageMaker Debugger Insights-Tab schließen, wird auch die entsprechende Kernel-Sitzung geschlossen. Die Studio-Classic-App bleibt aktiv und es fallen Gebühren für die `ml.m5.4xlarge` Instance-Nutzung an. Informationen zu den Preisen finden Sie auf der Seite mit den [ SageMaker Amazon-Preisen](https://aws.amazon.com/sagemaker/pricing/).
**Wichtig**
Wenn Sie das SageMaker Debugger Insights-Dashboard nicht mehr verwenden, fahren Sie die `ml.m5.4xlarge` Instance herunter, um Gebühren zu vermeiden. Anweisungen zum Herunterfahren der Instance finden Sie unter [Fahren Sie die Amazon SageMaker Debugger Insights-Instanz herunter](debugger-on-studio-insights-close.md).
## SageMaker Benutzeroberfläche des Debugger Insights-Controllers
Mithilfe des Debugger-Controllers in der oberen linken Ecke des Insights-Dashboards können Sie das Dashboard aktualisieren, Debugger-Einstellungen für die Überwachung von Systemmetriken konfigurieren oder aktualisieren, einen Trainingsauftrag beenden und einen Debugger-Profilbericht herunterladen.
![\[SageMaker Debugger Insights-Dashboard-Controller\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-studio-insights-refresh.png)
+ Wenn Sie das Dashboard manuell aktualisieren möchten, wählen Sie die Schaltfläche "Aktualisieren" (der runde Pfeil in der oberen linken Ecke), wie im vorherigen Screenshot gezeigt.
+ Die Umschaltfläche **Überwachung** ist standardmäßig für jeden SageMaker Trainingsjob aktiviert, der mit dem SageMaker Python-SDK initiiert wurde. Wenn nicht aktiviert, können Sie die Umschalttaste verwenden, um die Überwachung zu starten. Während der Überwachung erfasst der Debugger nur Messwerte zur Ressourcenauslastung, um Rechenprobleme wie CPU-Engpässe und GPU-Unterauslastung zu erkennen. Eine vollständige Liste der Ressourcenauslastungsprobleme, die Debugger überwacht, finden Sie unter [Debugger integrierte Regeln für das Profiling der Hardware-Systemressourcenauslastung (Systemmetriken)](debugger-built-in-profiler-rules.md#built-in-rules-monitoring).
+ Mit der Schaltfläche **Überwachung konfigurieren** wird ein Popup-Fenster geöffnet, in dem Sie die Häufigkeit der Datenerfassung und den S3-Pfad zum Speichern der Daten festlegen oder aktualisieren können.
![\[Das Popup-Fenster zur Konfiguration der Debugger-Überwachungseinstellungen\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-studio-enable-profiling-2.png)
Sie können Werte für die folgenden Felder angeben.
+ **S3-Bucket-URI**: Geben Sie den Basis-S3-Bucket-URI an.
+ **Alle Überwachungsdaten sammeln**: Wählen Sie ein Zeitintervall für die Erfassung von Systemmetriken aus. Sie können eines der Überwachungsintervalle aus der Drop-down-Liste auswählen. Verfügbare Intervalle sind 100 Millisekunden, 200 Millisekunden, 500 Millisekunden (Standard), 1 Sekunde, 5 Sekunden und 1 Minute.
**Anmerkung**
Wenn Sie sich für eines der kürzeren Zeitintervalle entscheiden, erhöhen Sie die Granularität der Kennzahlen zur Ressourcenauslastung, sodass Sie Spitzen und Anomalien mit einer höheren Zeitauflösung erfassen können. Je höher die Auflösung, desto größer jedoch der Umfang der zu verarbeitenden Systemmetriken. Dies kann zu zusätzlichem Aufwand führen und sich auf die gesamte Trainings- und Verarbeitungszeit auswirken.
+ Mit der Schaltfläche **Training beenden** können Sie den Trainingsjob beenden, wenn Sie Anomalien bei der Ressourcenauslastung feststellen.
+ Mithilfe der Schaltfläche **Bericht herunterladen** können Sie mithilfe der integrierten [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)Debuger-Regel einen aggregierten Profilerstellungsbericht herunterladen. SageMaker Die Schaltfläche wird aktiviert, wenn Sie die integrierte [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)Regel zum Schätzer hinzufügen. Weitere Informationen finden [Sie unter Integrierte Profiler-Regeln konfigurieren](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html) und mit dem Debugger [generierter Profilerstellungsbericht](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). SageMaker
# Erkunden Sie das Amazon SageMaker Debugger Insights-Dashboard
Wenn Sie einen SageMaker Trainingsjob initiieren, beginnt SageMaker Debugger standardmäßig mit der Überwachung der Ressourcennutzung der Amazon EC2 EC2-Instances. Sie können die Systemauslastungsraten, die Statistikübersicht und die integrierte Regelanalyse über das Insights-Dashboard verfolgen. **Diese Anleitung führt Sie durch den Inhalt des SageMaker Debugger Insights-Dashboards auf den folgenden Registerkarten: **Systemmetriken** und Regeln.**
**Anmerkung**
Das SageMaker Debugger Insights-Dashboard führt eine Studio Classic-Anwendung auf einer `ml.m5.4xlarge` Instanz aus, um die Visualisierungen zu verarbeiten und zu rendern. Auf jeder Registerkarte SageMaker Debugger Insights wird eine Studio Classic-Kernelsitzung ausgeführt. Auf einer einzigen Instanz werden mehrere Kernel-Sitzungen für mehrere SageMaker Debugger Insights-Tabs ausgeführt. Wenn Sie einen SageMaker Debugger Insights-Tab schließen, wird auch die entsprechende Kernel-Sitzung geschlossen. Die Studio-Classic-Anwendung bleibt aktiv und es fallen Gebühren für die Nutzung der `ml.m5.4xlarge`-Instance an. Informationen zu den Preisen finden Sie auf der Seite mit den [ SageMaker Amazon-Preisen](https://aws.amazon.com/sagemaker/pricing/).
**Wichtig**
Wenn Sie das SageMaker Debugger Insights-Dashboard nicht mehr verwenden, fahren Sie die `ml.m5.4xlarge` Instance herunter, um Gebühren zu vermeiden. Anweisungen zum Herunterfahren der Instance finden Sie unter [Fahren Sie die Amazon SageMaker Debugger Insights-Instanz herunter](debugger-on-studio-insights-close.md).
**Wichtig**
Die Berichte, Diagramme und Empfehlungen dienen zu Informationszwecken und sind nicht endgültig. Sie übernehmen die Verantwortung dafür, die Informationen eigenständig zu bewerten.
**Topics**
+ [Systemmetriken](#debugger-insights-system-metrics-tab)
+ [Regeln](#debugger-on-studio-insights-rules)
## Systemmetriken
Auf der Registerkarte **Systemmetriken** können Sie die Übersichtstabelle und die Zeitreihendiagramme verwenden, um die Ressourcenauslastung zu verstehen.
### Zusammenfassung der Ressourcenauslastung
Diese Übersichtstabelle zeigt die Statistiken der Metriken zur Compute-Ressourcenauslastung aller Knoten (als Algo-*n* bezeichnet). Die Kennzahlen zur Ressourcennutzung umfassen die gesamte CPU-Auslastung, die gesamte GPU-Auslastung, die gesamte CPU-Speicherauslastung, die gesamte GPU-Speicherauslastung, die gesamte I/O Wartezeit und das gesamte Netzwerk in Byte. Die Tabelle zeigt die Minimal- und Maximalwerte sowie die Perzentile p99, p90 und p50.
![\[Eine Übersichtstabelle der Ressourcenauslastung\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-studio-insights-resource-util-summary.png)
### Zeitreihendiagramme zur Ressourcenauslastung
Verwenden Sie die Zeitreihendiagramme, um weitere Details zur Ressourcenauslastung zu erhalten und zu ermitteln, in welchem Zeitintervall jede Instance eine unerwünschte Auslastung aufweist, z. B. eine geringe GPU-Auslastung und CPU-Engpässe, die zu einer Verschwendung der teuren Instance führen können.
**Die Benutzeroberfläche des Zeitreihendiagramm-Controllers**
Im folgenden Screenshot sehen Sie den UI-Controller zum Anpassen der Zeitreihendiagramme.
![\[\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-insights-graph-controller.png)
+ **algo-1**: Verwenden Sie dieses Dropdown-Menü, um den Knoten auszuwählen, den Sie untersuchen möchten.
+ **Hineinzoomen**: Verwenden Sie diese Schaltfläche, um die Zeitreihendiagramme zu vergrößern und kürzere Zeitintervalle anzuzeigen.
+ **Herauszoomen**: Verwenden Sie diese Schaltfläche, um die Zeitreihendiagramme zu verkleinern und größere Zeitintervalle anzuzeigen.
+ Nach **links schwenken**: Verschiebt die Zeitreihendiagramme in ein früheres Zeitintervall.
+ Nach **rechts schwenken**: Verschiebt die Zeitreihendiagramme in ein späteres Zeitintervall.
+ **Zeitrahmen korrigieren**: Verwenden Sie dieses Kontrollkästchen, um die Zeitreihendiagramme zu korrigieren oder wiederherzustellen, sodass die gesamte Ansicht vom ersten Datenpunkt bis zum letzten Datenpunkt angezeigt wird.
**CPU-Auslastung und I/O Wartezeit**
Die ersten beiden Grafiken zeigen die CPU-Auslastung und die I/O Wartezeit im Zeitverlauf. Standardmäßig zeigen die Diagramme die durchschnittliche CPU-Auslastung und die für die CPU-Kerne aufgewendete I/O Wartezeit. Sie können einen oder mehrere CPU-Kerne auswählen, indem Sie die Beschriftungen auswählen, um sie in einem einzigen Diagramm grafisch darzustellen und die Auslastung zwischen den Kernen zu vergleichen. Sie können die Ansicht durch Ziehen und Verkleinern vergrößern und verkleinern, um sich spezifische Zeitintervalle genauer anzusehen.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-insights-node-cpu.png)
**GPU-Auslastung und GPU-Speicherauslastung**
Die folgenden Diagramme zeigen die GPU-Auslastung und die GPU-Speicherauslastung im Zeitverlauf. Standardmäßig zeigen die Diagramme die durchschnittliche Nutzungsrate im Zeitverlauf. Sie können die GPU-Kernbezeichnungen auswählen, um die Auslastungsrate der einzelnen Kerne zu sehen. Nimmt man den Mittelwert der Nutzungsrate über die Gesamtzahl der GPU-Kerne, ergibt sich die durchschnittliche Auslastung der gesamten Hardwaresystemressource. Anhand der durchschnittlichen Nutzungsrate können Sie die Gesamtauslastung der Systemressourcen einer Amazon-EC2-Instance überprüfen. Die folgende Abbildung zeigt ein Beispiel für einen Trainingsauftrag auf einer `ml.p3.16xlarge` Instance mit 8 GPU-Kernen. Sie können überwachen, ob der Trainingsjob gut verteilt ist und alle Aufgaben voll ausgeschöpft GPUs werden.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-gpu.gif)
**Gesamtauslastung des Systems im Laufe der Zeit**
Die folgende Heatmap zeigt ein Beispiel für die gesamte Systemauslastung einer `ml.p3.16xlarge` Instance im Zeitverlauf, projiziert auf das zweidimensionale Diagramm. Jeder CPU- und GPU-Kern ist auf der vertikalen Achse aufgeführt, und die Auslastung wird im Zeitverlauf anhand eines Farbschemas aufgezeichnet, wobei die hellen Farben für eine geringe Auslastung und die dunkleren Farben für eine hohe Auslastung stehen. Anhand der beschrifteten Farbleiste auf der rechten Seite des Diagramms können Sie herausfinden, welche Farbstufe welcher Auslastungsrate entspricht.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-heatmap.png)
## Regeln
Auf der Registerkarte **Regeln** finden Sie eine Zusammenfassung der Analyse der Profiling-Regeln für Ihren Trainingsauftrag. Wenn die Profilerstellungsregel zusammen mit dem Trainingsjob aktiviert wird, wird der Text durchgehend weiß hervorgehoben. Inaktive Regeln sind grau abgeblendet. Folgen Sie den Anweisungen unter, um diese Regeln zu [Verwenden Sie integrierte Profiler-Regeln, die von Amazon SageMaker Debugger verwaltet werden](use-debugger-built-in-profiler-rules.md) aktivieren.
![\[Die Registerkarte „Regeln“ im SageMaker Debugger Insights-Dashboard\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-insights-rules.png)
# Fahren Sie die Amazon SageMaker Debugger Insights-Instanz herunter
Wenn Sie das SageMaker Debugger Insights-Dashboard nicht verwenden, sollten Sie die App-Instanz herunterfahren, um zusätzliche Gebühren zu vermeiden.
**Um die SageMaker Debugger Insights-App-Instanz in Studio Classic herunterzufahren**
![\[Ein animierter Screenshot, der zeigt, wie eine SageMaker Debugger Insights-Dashboard-Instanz heruntergefahren wird.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-studio-insights-shut-down.png)
1. Wählen Sie in Studio Classic das Symbol **Ausführen von Instances und Kernels** (![\[Square icon with a white outline of a cloud on a dark blue background.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/icons/Running_squid.png)) aus.
1. Suchen Sie in der Liste **LAUFENDE APPS** nach der App **sagemaker-debugger-1.0**. Wählen Sie das Shutdown-Symbol (![\[Power button icon with a circular shape and vertical line symbol.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/icons/Shutdown_light.png)) neben der App aus. Die SageMaker Debugger Insights-Dashboards werden auf einer Instanz ausgeführt. `ml.m5.4xlarge` Diese Instance verschwindet auch aus den **AUSGEFÜHRTE INSTANCES**, wenn Sie die App **sagemaker-debugger-1.0** herunterfahren.
# SageMaker Interaktiver Debugger-Bericht
Erhalten Sie vom Debugger automatisch generierte Profiling-Berichte. Der Debugger-Bericht bietet Einblicke in Ihre Trainingsaufträge und gibt Empfehlungen zur Verbesserung der Modellleistung. Der folgende Screenshot zeigt eine Collage des Debugger-Profilerstellungsberichts. Weitere Informationen hierzu finden Sie unter [SageMaker Interaktiver Debugger-Bericht](#debugger-profiling-report).
**Anmerkung**
Sie können Debugger-Berichte herunterladen, während Ihr Trainingsauftrag läuft oder nachdem der Job abgeschlossen ist. während des Trainings aktualisiert der Debugger gleichzeitig den Bericht, der den Auswertungsstatus der aktuellen Regeln wiedergibt. Sie können einen vollständigen Debugger-Bericht erst herunterladen, wenn der Trainingsauftrag abgeschlossen ist.
**Wichtig**
Die Berichte, Diagramme und Empfehlungen dienen zu Informationszwecken und sind nicht endgültig. Sie übernehmen die Verantwortung dafür, die Informationen unabhängig zu bewerten.
![\[Ein Beispiel für einen zusammenfassenden Bericht zum Debugger-Trainingsauftrag\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profile-report.jpg)
Für alle SageMaker Trainingsaufgaben ruft die SageMaker [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) Debugger-Regel alle [Überwachungs- und Profilerstellungsregeln auf und](debugger-built-in-profiler-rules.md#built-in-rules-monitoring) fasst die Regelanalyse in einem umfassenden Bericht zusammen. Folgen Sie dieser Anleitung, laden Sie den Bericht mit dem [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) oder der S3-Konsole herunter und erfahren Sie, was Sie aus den Profilerstellungsergebnissen interpretieren können.
**Wichtig**
Der Bericht enthält Diagramme und Empfehlungen zu Informationszwecken und sind nicht endgültig. Es liegt in Ihrer Verantwortung, die Informationen eigenständig zu bewerten.
# Laden Sie den SageMaker Debugger-Profiling-Bericht herunter
Laden Sie den SageMaker Debugger-Profiling-Bericht herunter, während Ihr Trainingsjob läuft oder nachdem der Job mit dem [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) und AWS Command Line Interface (CLI) abgeschlossen wurde.
**Anmerkung**
Um den vom Debugger generierten Profilerstellungsbericht zu erhalten, müssen Sie die vom SageMaker Debugger angebotene integrierte [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)Regel verwenden. SageMaker Informationen zur Aktivierung der Regel bei Ihrem Trainingsauftrag finden Sie unter [Integrierte Profiler-Regeln konfigurieren](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html).
**Tipp**
Sie können den Bericht auch mit einem einzigen Klick im SageMaker Studio Debugger Insights-Dashboard herunterladen. Dies erfordert kein zusätzliches Scripting, um den Bericht herunterzuladen. Informationen zum Herunterladen des Berichts aus Studio finden Sie unter [Öffnen Sie das Amazon SageMaker Debugger Insights-Dashboard](debugger-on-studio-insights.md).
------
#### [ Download using SageMaker Python SDK and AWS CLI ]
1. Überprüfen Sie den standardmäßigen S3-Ausgabe-Basis-URI des aktuellen Jobs.
```
estimator.output_path
```
1. Überprüfen Sie den aktuellen Namen des Auftrags.
```
estimator.latest_training_job.job_name
```
1. Der Debugger-Profilerstellungsbericht ist gespeichert unter `//rule-output`. Konfigurieren Sie den Regelausgabepfad wie folgt:
```
rule_output_path = estimator.output_path + estimator.latest_training_job.job_name + "/rule-output"
```
1. Um zu überprüfen, ob der Bericht erstellt wird, listen Sie Verzeichnisse und Dateien rekursiv unter der `rule_output_path` mit `aws s3 ls` und der Option `--recursive` auf.
```
! aws s3 ls {rule_output_path} --recursive
```
Dadurch sollte eine vollständige Liste der Dateien in einem automatisch generierten Ordner mit dem Namen `ProfilerReport-1234567890` zurückgegeben werden. Der Ordnername ist eine Kombination aus Zeichenfolgen `ProfilerReport` und einem eindeutigen 10-stelligen Tag, der auf dem Unix-Zeitstempel basiert, zu dem die ProfilerReport Regel initiiert wurde.
![\[Ein Beispiel für die Regelausgabe\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-rule-output-ls-example.png)
Das `profiler-report.html` ist ein automatisch generierter Profilerstellungsbericht von Debugger. Bei den verbleibenden Dateien handelt es sich um die integrierten Regelanalysekomponenten, die in JSON und einem Jupyter Notebook gespeichert sind und verwendet werden, um sie im Bericht zusammenzufassen.
1. Laden Sie die Dateien rekursiv herunter mit `aws s3 cp`. Mit dem folgenden Befehl werden alle Regelausgabedateien in dem `ProfilerReport-1234567890` Ordner unter dem aktuellen Arbeitsverzeichnis gespeichert.
```
! aws s3 cp {rule_output_path} ./ --recursive
```
**Tipp**
Wenn Sie einen Jupyter-Notebook-Server verwenden, führen Sie den Befehl `!pwd` aus, um das aktuelle Arbeitsverzeichnis zu überprüfen.
1. Öffnen Sie unter dem `/ProfilerReport-1234567890/profiler-output` Verzeichnis `profiler-report.html`. Wenn Sie dies verwenden JupyterLab, wählen Sie **Trust HTML**, um den automatisch generierten Debugger-Profiling-Bericht zu sehen.
![\[Ein Beispiel für die Regelausgabe\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-rule-output-open-html.png)
1. Öffnen Sie die `profiler-report.ipynb` Datei, um zu erfahren, wie der Bericht generiert wird. Sie können den Profilerstellungsbericht auch mithilfe der Jupyter-Notebook-Datei anpassen und erweitern.
------
#### [ Download using Amazon S3 Console ]
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Suchen Sie nach dem S3-Bucket. Wenn Sie beispielsweise keinen Basisauftragsnamen angegeben haben, sollte der Basis-S3-Bucket-Name das folgende Format haben: `sagemaker--111122223333`. Suchen Sie im Feld Bucket nach *Namen suchen nach dem Basis-S3-Bucket*.
![\[Ein Beispiel für die Regelausgabe des S3-Bucket-URI\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-0.png)
1. Suchen Sie im Basis-S3-Bucket nach dem Trainingsauftragsnamen, indem Sie Ihr Jobnamen-Präfix in das Eingabefeld *Objekte nach Präfix suchen* eingeben. Wählen Sie den Trainingsauftragsnamen.
![\[Ein Beispiel für die S3-Bucket-URI der Regelausgabe\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-1.png)
1. Im S3-Bucket des Trainingsauftrags müssen drei Unterordner für die vom Debugger gesammelten Trainingsdaten vorhanden sein: **debug-output/**, **profiler-output/** und **rule-output/**. Wählen Sie **rule-output/**.
![\[Ein Beispiel für die S3-Bucket-URI der Regelausgabe\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-2.png)
1. **Wählen Sie im Ordner **rule-output/** die Option **ProfilerReport-1234567890** und dann den Ordner profiler-output/.** Der Ordner **profiler-output/** enthält **profiler-report.html** (den automatisch generierten Profilerstellungsbericht in HTML), **profiler-report.ipynb** (ein Jupyter Notebook mit Skripten, die zum Generieren des Berichts verwendet werden) und einen Ordner **profiler-report/** (enthält JSON-Dateien zur Regelanalyse, die als Komponenten des Berichts verwendet werden).
1. Wählen Sie die Datei **profiler-report.html** aus, klicken Sie auf **Aktionen** und dann auf **Herunterladen**.
![\[Ein Beispiel für die Regelausgabe des S3-Bucket-URI\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-3.png)
1. Öffnen Sie die heruntergeladene Datei **profiler-report.html** in einem Web-Browser.
------
**Anmerkung**
Wenn Sie Ihren Trainingsauftrag gestartet haben, ohne die Debugger-spezifischen Parameter zu konfigurieren, generiert Debugger den Bericht nur auf der Grundlage der Systemüberwachungsregeln, da die Debugger-Parameter nicht zum Speichern von Framework-Metriken konfiguriert sind. Um die Profilerstellung von Framework-Metriken zu aktivieren und einen erweiterten Debugger-Profilerstellungsbericht zu erhalten, konfigurieren Sie den Parameter bei der Erstellung oder Aktualisierung von KI-Schätzern. `profiler_config` SageMaker
Informationen zur Konfiguration des `profiler_config` Parameters vor Beginn eines Trainingsauftrags finden Sie unter [Schätzerkonfiguration für Framework-Profiling](debugger-configure-framework-profiling.md).
Informationen zum Aktualisieren des aktuellen Trainingsauftrags und zum Aktivieren der Profilerstellung für Framework-Metriken finden Sie unter [Aktualisieren der Konfiguration der Debugger-Framework-Profilkonfiguration](debugger-update-monitoring-profiling.md).
# Exemplarische Vorgehensweise für den Bericht zur Debugger-Profilerstellung
In diesem Abschnitt wird der Debugger-Profilerstellungsbericht beschrieben. Der Profilerstellungsbericht wird auf der Grundlage der integrierten Regeln für Überwachung und Profilerstellung generiert. Der Bericht zeigt nur Ergebnisdiagramme für die Regeln, bei denen Probleme festgestellt wurden.
**Wichtig**
In dem Bericht werden die Diagramme und Empfehlungen zu Informationszwecken bereitgestellt und sind nicht endgültig. Sie übernehmen die Verantwortung dafür, die Informationen unabhängig zu bewerten.
**Topics**
+ [Zusammenfassung der Ausbildungsberufe](#debugger-profiling-report-walkthrough-summary)
+ [Statistiken der Systemnutzung](#debugger-profiling-report-walkthrough-system-usage)
+ [Übersicht der Framework-Metriken](#debugger-profiling-report-walkthrough-framework-metrics)
+ [Übersicht der Regeln](#debugger-profiling-report-walkthrough-rules-summary)
+ [Analyse der Trainingsschleife – Schrittdauer](#debugger-profiling-report-walkthrough-step-durations)
+ [Analyse der GPU-Auslastung](#debugger-profiling-report-walkthrough-gpu-utilization)
+ [Batch-Größe](#debugger-profiling-report-walkthrough-batch-size)
+ [CPU-Engpässe](#debugger-profiling-report-walkthrough-cpu-bottlenecks)
+ [E/A-Engpässe](#debugger-profiling-report-walkthrough-io-bottlenecks)
+ [Load Balancer bei der Multi-GPU-Training](#debugger-profiling-report-walkthrough-workload-balancing)
+ [GPU-Speicheranalyse](#debugger-profiling-report-walkthrough-gpu-memory)
## Zusammenfassung der Ausbildungsberufe
Zu Beginn des Berichts bietet Debugger eine Zusammenfassung Ihres Trainingsauftrags. In diesem Abschnitt können Sie sich einen Überblick über die Dauer und die Zeitstempel der verschiedenen Trainingsphasen verschaffen.
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-summary.gif)
Die Übersichtstabelle enthält die folgenden Informationen:
+ **start\$1time** – Die genaue Uhrzeit, zu der der Trainingsauftrag gestartet wurde.
+ **end\$1time** – Die genaue Uhrzeit, zu der der Trainingsauftrag beendet wurde.
+ **job\$1duration\$1in\$1seconds** – ****Die gesamte Trainingszeit von der start\$1time** bis zur end\$1time**.
+ **training\$1loop\$1start** – Der genaue Zeitpunkt, zu dem der erste Schritt der ersten Epoche begonnen hat.
+ **training\$1loop\$1end** – Der genaue Zeitpunkt, zu dem der letzte Schritt der letzten Epoche abgeschlossen ist.
+ **training\$1loop\$1duration\$1in\$1seconds** – Die Gesamtzeit zwischen der Startzeit der Trainingsschleife und der Endzeit der Trainingsschleife.
+ **initialization\$1in\$1seconds** – Zeit, die für die Initialisierung des Trainingsauftrags aufgewendet wurde. Die Initialisierungsphase umfasst den Zeitraum von der **start\$1time** bis zur **training\$1loop\$1start**. Die Initialisierungszeit wird für das Kompilieren des Trainingsskripts, das Starten des Trainingsskripts, das Erstellen und Initialisieren des Modells, das Initiieren von EC2-Instances und das Herunterladen von Trainingsdaten aufgewendet.
+ **finalization\$1in\$1seconds** – Zeit, die für den Abschluss des Trainingsauftrags aufgewendet wird, z. B. für den Abschluss des Modelltrainings, die Aktualisierung der Modellartefakte und das Schließen der EC2-Instances. Die Finalisierungsphase umfasst den Zeitraum von der Zeit **training\$1loop\$1end** bis **end\$1time**.
+ **initialization (%)** – Der Prozentsatz der für die **Initialisierung** aufgewendeten Zeit über die gesamte Dauer von **job\$1duration\$1in\$1seconds**.
+ **Trainingsschleife (%)** – ****Der Prozentsatz der für training loop** aufgewendeten Zeit über die gesamte Dauer von job\$1duration\$1in\$1seconds**.
+ **Abschluss (%)** – Der Prozentsatz der für die **Finalisierung** aufgewendeten Zeit an der gesamten Dauer von **job\$1duration\$1in\$1seconds**.
## Statistiken der Systemnutzung
In diesem Abschnitt finden Sie einen Überblick über die Statistiken zur Systemauslastung.
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-system-usage.png)
Der Debugger-Profiling-Bericht enthält die folgenden Informationen:
+ **node** – Listet die Namen der Knoten auf. Wenn Sie verteiltes Training auf mehreren Knoten (mehrere EC2-Instances) verwenden, haben die Knotennamen das Format von `algo-n`.
+ **Metrik** – Die vom Debugger gesammelten Systemmetriken: CPU, GPU, CPU-Speicher, GPU-Speicher, I/O und Netzwerkmetriken.
+ **unit** – Die Einheit der Systemmetrik.
+ **max** – Der Maximalwert jeder Systemmetrik.
+ **p99** – Das 99. Perzentil jeder Systemauslastung.
+ **p95 – Das 95. Perzentil** jeder Systemauslastung.
+ **p50** – Das 50. Perzentil (Median) jeder Systemauslastung.
+ **min** – Der Mindestwert jeder Systemmetrik.
## Übersicht der Framework-Metriken
In diesem Abschnitt zeigen die folgenden Kreisdiagramme die Aufschlüsselung der Framework-Operationen für und. CPUs GPUs
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-metrics-summary.gif)
In jedem der Kreisdiagramme werden die gesammelten Framework-Metriken unter verschiedenen Aspekten wie folgt analysiert:
+ **Verhältnis zwischen TRAIN/EVAL Phasen und anderen** — Zeigt das Verhältnis zwischen den Zeitdauern, die für verschiedene Trainingsphasen aufgewendet wurden.
+ **Verhältnis zwischen Vorwärts- und Rückwärtsdurchgang** – Zeigt das Verhältnis zwischen der Zeit, die in der Trainingsschleife für das Vorwärts- und Rückwärtsspiel aufgewendet wurde.
+ **Verhältnis zwischen CPU/GPU Operatoren** — Zeigt das Verhältnis zwischen der Zeit an, die für Operatoren aufgewendet wurde, die auf einer CPU oder GPU laufen, z. B. Faltungsoperatoren.
+ **Im Framework aufgezeichnete allgemeine Metriken** – Zeigt das Verhältnis zwischen der Zeit an, die für wichtige Framework-Metriken wie das Laden von Daten, Vorwärts- und Rückwärtsdurchlauf aufgewendet wurde.
### Überblick: CPU-Operatoren
Dieser Abschnitt enthält detaillierte Informationen zu den CPU-Operatoren. Die Tabelle zeigt den Prozentsatz der Zeit und die absolute Gesamtzeit, die für die am häufigsten aufgerufenen CPU-Operatoren aufgewendet wurde.
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-cpu-operators.gif)
### Überblick: GPU-Operatoren
Dieser Abschnitt enthält detaillierte Informationen zu den GPU-Operatoren. Die Tabelle zeigt den Prozentsatz der Zeit und die absolute Gesamtzeit, die für die am häufigsten aufgerufenen GPU-Operatoren aufgewendet wurde.
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-gpu-operators.gif)
## Übersicht der Regeln
In diesem Abschnitt fasst der Debugger alle Ergebnisse, Analysen, Regelbeschreibungen und Vorschläge der Regelauswertung zusammen.
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-rules-summary.png)
## Analyse der Trainingsschleife – Schrittdauer
In diesem Abschnitt finden Sie eine detaillierte Statistik der Schrittdauer auf jedem GPU-Kern jedes Knotens. Der Debugger wertet Mittel-, Maximal-, P99-, P95-, P50- und Mindestwert der Schrittdauer aus und wertet Schrittausreißer aus. Das folgende Histogramm zeigt die Schrittdauer, die auf verschiedenen Worker-Knoten und erfasst wurde. GPUs Sie können das Histogramm jedes Workers aktivieren oder deaktivieren, indem Sie die Legenden auf der rechten Seite auswählen. Sie können überprüfen, ob es eine bestimmte GPU gibt, die Ausreißer bei der Schrittdauer verursacht.
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-step-duration.gif)
## Analyse der GPU-Auslastung
Dieser Abschnitt enthält detaillierte Statistiken zur GPU-Kernauslastung auf der Grundlage der GPUUtilization Niedrigen Regel. Außerdem werden die Statistiken zur GPU-Auslastung (Mittelwert, P95 und P5) zusammengefasst, um festzustellen, ob der Trainingsjob zu wenig ausgelastet ist. GPUs
## Batch-Größe
In diesem Abschnitt werden detaillierte Statistiken zur gesamten CPU-Auslastung, zur individuellen GPU-Auslastung und zur GPU-Speicherbelegung angezeigt. Die BatchSize Regel legt fest, ob Sie die Batchgröße ändern müssen, um die besser nutzen zu können. GPUs Sie können überprüfen, ob die Batch-Größe zu klein ist, was zu einer Unterauslastung führt, oder ob sie zu groß ist, was zu Überauslastung und Speichermangel führt. Im Diagramm zeigen die Felder die Perzentilbereiche p25 und p75 (jeweils dunkelviolett bzw. hellgelb gefüllt) vom Median (p50), und die Fehlerbalken zeigen das 5. Perzentil für die untere Grenze und das 95. Perzentil für die obere Grenze.
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-batch-size.png)
## CPU-Engpässe
In diesem Abschnitt können Sie sich detailliert mit den CPU-Engpässen befassen, die die CPUBottleneck Regel bei Ihrem Trainingsjob festgestellt hat. Die Regel prüft, ob die CPU-Auslastung über `cpu_threshold` (standardmäßig 90%) und ob die GPU-Auslastung unter `gpu_threshold` liegt (standardmäßig 10%).
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-cpu-bottlenecks.png)
Die Kreisdiagramme enthalten die folgenden Informationen:
+ **Niedrige GPU-Auslastung aufgrund von CPU-Engpässen** – Zeigt das Verhältnis der Datenpunkte zwischen den Datenpunkten mit einer GPU-Auslastung über und unter dem Schwellenwert und denen, die den CPU-Engpasskriterien entsprechen.
+ **Verhältnis zwischen TRAIN/EVAL Phasen und anderen** — Zeigt das Verhältnis zwischen den Zeitdauern, die für verschiedene Trainingsphasen aufgewendet wurden.
+ **Verhältnis zwischen Vorwärts- und Rückwärtsdurchgang** – Zeigt das Verhältnis zwischen der Zeit, die in der Trainingsschleife für das Vorwärts- und Rückwärtsspiel aufgewendet wurde.
+ **Verhältnis zwischen CPU/GPU Operatoren** — Zeigt das Verhältnis zwischen der Zeitdauer an, die für GPUs und CPUs von Python-Operatoren aufgewendet wurde, z. B. für Dataloader-Prozesse und Vorwärts- und Rückwärts-Pass-Operatoren.
+ **Im Framework aufgezeichnete allgemeine Metriken** – Zeigt die wichtigsten Framework-Metriken und das Verhältnis zwischen der für die Metriken aufgewendeten Zeitdauer an.
## E/A-Engpässe
In diesem Abschnitt finden Sie eine Zusammenfassung der I/O Engpässe. Die Regel bewertet die I/O Wartezeit und die GPU-Auslastung und überwacht, ob die Zeit für I/O requests exceeds a threshold percent of the total training time. It might indicate I/O Engpässe aufgewendet wird, bei denen GPUs auf das Eintreffen von Daten aus dem Speicher gewartet wird.
## Load Balancer bei der Multi-GPU-Training
In diesem Abschnitt können Sie Probleme mit dem Workload-Balancing in allen Bereichen identifizieren. GPUs
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-workload-balancing.gif)
## GPU-Speicheranalyse
In diesem Abschnitt können Sie die GPU-Speicherauslastung analysieren, die mit der Regel „ GPUMemoryErhöhen“ erfasst wurde. Im Diagramm zeigen die Felder die Perzentilbereiche p25 und p75 (jeweils dunkelviolett bzw. hellgelb gefüllt) vom Median (p50), und die Fehlerbalken zeigen das 5. Perzentil für die untere Grenze und das 95. Perzentil für die obere Grenze.
![\[Ein Beispiel für einen Debugger-Profiling-Bericht\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-profiling-report-gpu-memory-utilization.png)
# Deaktivieren Sie die Erfassung von Amazon SageMaker Debugger-Nutzungsstatistiken
Für alle SageMaker Trainingsjobs führt Amazon SageMaker Debugger die [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) Regel aus und generiert automatisch eine. [SageMaker Interaktiver Debugger-Bericht](debugger-profiling-report.md) Die `ProfilerReport` Regel stellt eine Jupyter-Notebook-Datei (`profiler-report.ipynb`) bereit, die eine entsprechende HTML-Datei (`profiler-report.html`) generiert.
Der Debugger sammelt Nutzungsstatistiken für Profilerstellungsberichte, indem er Code in das Jupyter Notebook einfügt, der den ARN des Verarbeitungsauftrags der eindeutigen `ProfilerReport` Regel erfasst, wenn der Benutzer die endgültige `profiler-report.html` Datei öffnet.
Der Debugger sammelt nur Informationen darüber, ob ein Benutzer den endgültigen HTML-Bericht öffnet. Es sammelt **KEINE** Informationen aus Trainingsaufträgen, Trainingsdaten, Trainingsskripten, Verarbeitungsaufträgen, Protokollen oder dem Inhalt des Profilerstellungsberichts selbst.
Sie können die Erfassung von Nutzungsstatistiken deaktivieren, indem Sie eine der folgenden Optionen verwenden.
## (Empfohlen) Option 1: Deaktivieren, bevor Sie einen Trainingsjob ausführen
Um sich abzumelden, müssen Sie Ihrer Trainingsaufträge-Anfrage die folgende `ProfilerReport` Debugger-Regelkonfiguration hinzufügen.
------
#### [ SageMaker Python SDK ]
```
estimator=sagemaker.estimator.Estimator(
...
rules=ProfilerRule.sagemaker(
base_config=rule_configs.ProfilerReport()
rule_parameters={"opt_out_telemetry": "True"}
)
)
```
------
#### [ AWS CLI ]
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport-1234567890",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"opt_out_telemetry": "True"
}
}
]
```
------
#### [ AWS SDK für Python (Boto3) ]
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport-1234567890',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'opt_out_telemetry': 'True'
}
}
]
```
------
## Option 2: Nach Abschluss eines Trainingsjobs deaktivieren
Um sich nach Abschluss des Trainings abzumelden, müssen Sie die `profiler-report.ipynb` Datei ändern.
**Anmerkung**
Automatisch generierte HTML-Berichte, bei denen **Option 1** nicht bereits zu Ihrer Trainingsanfrage hinzugefügt wurde, enthalten weiterhin Nutzungsstatistiken, auch wenn Sie sich mit **Option 2** abmelden.
1. Folgen Sie den Anweisungen zum Herunterladen der Debugger-Profilerstellungsberichtsdateien auf der [Laden Sie den SageMaker Debugger-Profiling-Bericht herunter](debugger-profiling-report-download.md) Seite.
1. Öffnen Sie im `/ProfilerReport-1234567890/profiler-output` Verzeichnis `profiler-report.ipynb`.
1. Fügen **opt\$1out=True** Sie der `setup_profiler_report()` Funktion in der fünften Codezelle etwas hinzu, wie im folgenden Beispielcode gezeigt:
```
setup_profiler_report(processing_job_arn, opt_out=True)
```
1. Führen Sie die Codezelle aus, um das Abmelden abzuschließen.
# Analysieren Sie Daten mit der Debugger-Python-Clientbibliothek
Während Ihr Trainingsjob läuft oder nachdem er abgeschlossen ist, können Sie mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) und der [SMDebug Client-Bibliothek](https://github.com/awslabs/sagemaker-debugger/) auf die vom Debugger gesammelten Trainingsdaten zugreifen. Die Debugger-Python-Client-Bibliothek bietet Analyse- und Visualisierungstools, mit denen Sie die Daten Ihrer Trainingsaufträge detailliert untersuchen können.
**Um die Bibliothek zu installieren und ihre Analysetools zu verwenden (in einem JupyterLab Notebook oder einem IPython-Kernel)**
```
! pip install -U smdebug
```
Die folgenden Themen führen Sie durch die Verwendung der Debugger-Python-Werkzeuge zur Visualisierung und Analyse der von Debugger erfassten Trainingsdaten.
**Analysieren Sie System- und Framework-Metriken**
+ [Greifen Sie auf die Profildaten zu](debugger-analyze-data-profiling.md)
+ [Stellen Sie die Daten der System- und Framework-Metriken grafisch dar](debugger-access-data-profiling-default-plot.md)
+ [Zugriff auf die Profilerstellungsdaten mit dem Pandas Data Parsing Tool](debugger-access-data-profiling-pandas-frame.md)
+ [Greifen Sie auf die Python-Profiling-Statistikdaten zu](debugger-access-data-python-profiling.md)
+ [Führen Sie die Zeitachsen mehrerer Profil-Trace-Dateien zusammen](debugger-merge-timeline.md)
+ [Profilierung von Datenladern](debugger-data-loading-time.md)
# Greifen Sie auf die Profildaten zu
Die SMDebug `TrainingJob` Klasse liest Daten aus dem S3-Bucket, in dem die System- und Framework-Metriken gespeichert sind.
**So richten Sie ein `TrainingJob` Objekt ein und rufen die Profilergebnisdateien eines Trainingsauftrags ab**
```
from smdebug.profiler.analysis.notebook_utils.training_job import TrainingJob
tj = TrainingJob(training_job_name, region)
```
**Tipp**
Sie müssen die `training_job_name` and `region` Parameter angeben, um einen Trainingsauftrag protokollieren zu können. Es gibt zwei Möglichkeiten, die Informationen zum Trainingsuftrag anzugeben:
Verwenden Sie das SageMaker Python-SDK, solange der Estimator noch an den Trainingsjob angehängt ist.
```
import sagemaker
training_job_name=estimator.latest_training_job.job_name
region=sagemaker.Session().boto_region_name
```
Übergeben Sie Strings direkt.
```
training_job_name="your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
region="us-west-2"
```
**Anmerkung**
Standardmäßig erfasst der SageMaker Debugger Systemmetriken, um die Auslastung der Hardwareressourcen und Systemengpässe zu überwachen. Wenn Sie die folgenden Funktionen ausführen, erhalten Sie möglicherweise Fehlermeldungen über die Nichtverfügbarkeit von Rahmenmetriken. Um Framework-Profiling-Daten abzurufen und Einblicke in die Framework-Operationen zu erhalten, müssen Sie das Framework-Profiling aktivieren.
Wenn Sie das SageMaker Python-SDK verwenden, um Ihre Trainingsjob-Anfrage `framework_profile_params` zu bearbeiten, übergeben Sie das an das `profiler_config` Argument Ihres Schätzers. Weitere Informationen finden Sie unter [Configure SageMaker Debugger Framework Profiling](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-framework-profiling.html).
Wenn Sie Studio Classic verwenden, aktivieren Sie die Profilerstellung über die Schaltfläche **Profiling** im Dashboard Debugger insights. Weitere Informationen finden Sie unter [SageMaker Debugger Insights Dashboard Controller](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio-insights-controllers.html).
**So rufen Sie eine Beschreibung des Trainingsauftrags und den URI des S3-Buckets ab, in dem die metrischen Daten gespeichert sind**
```
tj.describe_training_job()
tj.get_config_and_profiler_s3_output_path()
```
**So prüfen Sie, ob die System- und Rahmenmetriken über den S3-URI verfügbar sind**
```
tj.wait_for_sys_profiling_data_to_be_available()
tj.wait_for_framework_profiling_data_to_be_available()
```
**Erstellung von System- und Rahmenleseobjekten, nachdem die metrischen Daten verfügbar sind**
```
system_metrics_reader = tj.get_systems_metrics_reader()
framework_metrics_reader = tj.get_framework_metrics_reader()
```
**So aktualisieren und rufen Sie die neuesten Trainingsereignisdateien ab**
Die Reader-Objekte verfügen über eine erweiterte Methode, `refresh_event_file_list()`, um die neuesten Trainingsereignisdateien abzurufen.
```
system_metrics_reader.refresh_event_file_list()
framework_metrics_reader.refresh_event_file_list()
```
# Stellen Sie die Daten der System- und Framework-Metriken grafisch dar
Sie können die System- und Algorithmusmetrikobjekte für die folgenden Visualisierungsklassen verwenden, um Zeitliniendiagramme und Histogramme zu erstellen.
**Anmerkung**
Geben Sie die Parameter `select_dimensions` und `select_events` an, um die Daten mit eingegrenzten Metriken in den folgenden Methoden zur Darstellung von Visualisierungsobjekten zu visualisieren. Wenn Sie beispielsweise angeben `select_dimensions=["GPU"]`, filtern die Plotmethoden die Metriken, die das Schlüsselwort „GPU“ enthalten. Wenn Sie angeben `select_events=["total"]`, filtern die Darstellungsmethoden die Metriken, die die Ereignis-Tags "total" am Ende der Metriknamen enthalten. Wenn Sie diese Parameter aktivieren und die Schlüsselwörter angeben, geben die Visualisierungsklassen die Diagramme mit gefilterten Metriken zurück.
+ Die `MetricsHistogram` Klasse
```
from smdebug.profiler.analysis.notebook_utils.metrics_histogram import MetricsHistogram
metrics_histogram = MetricsHistogram(system_metrics_reader)
metrics_histogram.plot(
starttime=0,
endtime=system_metrics_reader.get_timestamp_of_latest_available_file(),
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"] # optional
)
```
+ Die `StepTimelineChart` Klasse
```
from smdebug.profiler.analysis.notebook_utils.step_timeline_chart import StepTimelineChart
view_step_timeline_chart = StepTimelineChart(framework_metrics_reader)
```
+ Die `StepHistogram` Klasse
```
from smdebug.profiler.analysis.notebook_utils.step_histogram import StepHistogram
step_histogram = StepHistogram(framework_metrics_reader)
step_histogram.plot(
starttime=step_histogram.last_timestamp - 5 * 1000 * 1000,
endtime=step_histogram.last_timestamp,
show_workers=True
)
```
+ Die `TimelineCharts` Klasse
```
from smdebug.profiler.analysis.notebook_utils.timeline_charts import TimelineCharts
view_timeline_charts = TimelineCharts(
system_metrics_reader,
framework_metrics_reader,
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"] # optional
)
view_timeline_charts.plot_detailed_profiler_data([700,710])
```
+ Die `Heatmap` Klasse
```
from smdebug.profiler.analysis.notebook_utils.heatmap import Heatmap
view_heatmap = Heatmap(
system_metrics_reader,
framework_metrics_reader,
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"], # optional
plot_height=450
)
```
# Zugriff auf die Profilerstellungsdaten mit dem Pandas Data Parsing Tool
Die folgende `PandasFrame` Klasse bietet Tools zum Konvertieren der gesammelten Profilerstellungsdaten in den Pandas-Datenrahmen.
```
from smdebug.profiler.analysis.utils.profiler_data_to_pandas import PandasFrame
```
Die `PandasFrame` Klasse verwendet den S3-Bucket-Ausgabepfad des `tj` Objekts, und ihre Methoden `get_all_system_metrics()` `get_all_framework_metrics()` geben Systemmetriken und Framework-Metriken im Pandas-Datenformat zurück.
```
pf = PandasFrame(tj.profiler_s3_output_path)
system_metrics_df = pf.get_all_system_metrics()
framework_metrics_df = pf.get_all_framework_metrics(
selected_framework_metrics=[
'Step:ModeKeys.TRAIN',
'Step:ModeKeys.GLOBAL'
]
)
```
# Greifen Sie auf die Python-Profiling-Statistikdaten zu
Das Python-Profiling bietet Framework-Metriken zu Python-Funktionen und -Operatoren in Ihren Trainingsskripten und den SageMaker KI-Dep-Learning-Frameworks.
**Trainingsmodi und Phasen für die Python-Profilerstellung**
Um bestimmte Intervalle während des Trainings zu profilieren und die Statistiken für jedes dieser Intervalle aufzuteilen, bietet der Debugger Werkzeuge zur Einstellung von Modi und Phasen.
Verwenden Sie `PythonProfileModes` Folgendes für die Modelltraining:
```
from smdebug.profiler.python_profile_utils import PythonProfileModes
```
Diese Klasse bietet die folgenden Optionen:
+ `PythonProfileModes.TRAIN` – Verwenden Sie diese Option, wenn Sie ein Profil der Zielschritte in der Trainingsphase erstellen möchten. Diese Modusoption ist nur verfügbar für TensorFlow.
+ `PythonProfileModes.EVAL` – Verwenden Sie diese Option, wenn Sie ein Profil der Zielschritte in der Evaluierungsphase erstellen möchten. Diese Modusoption ist nur verfügbar für TensorFlow.
+ `PythonProfileModes.PREDICT` – Verwenden Sie diese Option, wenn Sie ein Profil der Zielschritte in der Vorhersagephase erstellen möchten. Diese Modusoption ist nur verfügbar für TensorFlow.
+ `PythonProfileModes.GLOBAL` – Verwenden Sie diese Option, wenn Sie ein Profil der Zielschritte in der globalen Phase erstellen möchten, die die vorherigen drei Phasen umfasst. Diese Modusoption ist nur verfügbar für PyTorch.
+ `PythonProfileModes.PRE_STEP_ZERO` – Verwenden Sie diese Option, wenn Sie ein Profil der Zielschritte in der Initialisierungsphase erstellen möchten, bevor der erste Trainingsschritt der ersten Epoche beginnt. Diese Phase umfasst die erste Einreichung des Auftrags, das Hochladen der Trainingsskripte auf EC2-Instances, das Vorbereiten der EC2-Instances und das Herunterladen der Eingabedaten. Diese Modusoption ist sowohl für als TensorFlow auch verfügbar PyTorch.
+ `PythonProfileModes.POST_HOOK_CLOSE` – Verwenden Sie diese Option, wenn Sie ein Profil der Zielschritte in der Finalisierungsphase erstellen möchten, nachdem der Trainingsauftrag abgeschlossen und der Debugger-Hook geschlossen wurde. Diese Phase umfasst die Erstellung von Profildaten, während die Trainingsaufträge fertiggestellt und abgeschlossen werden. Diese Modusoption ist sowohl für als TensorFlow auch verfügbar PyTorch.
Verwenden Sie für Trainingsphasen die folgende `StepPhase` Klasse:
```
from smdebug.profiler.analysis.utils.python_profile_analysis_utils import StepPhase
```
Diese Klasse bietet folgende Optionen:
+ `StepPhase.START` – Wird verwendet, um den Startpunkt der Initialisierungsphase anzugeben.
+ `StepPhase.STEP_START` – Wird verwendet, um den Startschritt der Trainingsphase anzugeben.
+ `StepPhase.FORWARD_PASS_END` – Hiermit können Sie die Schritte angeben, an denen der Vorwärtspass endet. Diese Option ist nur für verfügbar PyTorch.
+ `StepPhase.STEP_END` – Dient zur Angabe der Endschritte in der Trainingsphase. Diese Option ist nur für verfügbar TensorFlow.
+ `StepPhase.END`— Dient zur Angabe des Endpunkts der Finalisierungsphase (post-hook-close). Wenn der Callback-Hook nicht geschlossen wird, findet keine Profilierung in der Abschlussphase statt.
**Analysetools zur Python-Profilerstellung**
Debugger unterstützt die Python-Profilerstellung mit zwei Profiling-Tools:
+ cProfile – Der Standard-Python-Profiler. cProfile sammelt Framework-Metriken zur CPU-Zeit für jede Funktion, die aufgerufen wurde, als die Profilerstellung aktiviert war.
+ Pyinstrument – Dies ist ein Python-Profiler mit geringem Overhead, der alle Millisekunden Profilereignisse abtastet.
Weitere Informationen zu den Python-Profilerstellungsoptionen und den gesammelten Informationen finden Sie unter [Standardsystemüberwachung und benutzerdefinierte Framework-Profilerstellung mit verschiedenen Profilerstellungsoptionen](debugger-configure-framework-profiling-options.md).
Die folgenden Methoden der `PythonProfileAnalysis`, `cProfileAnalysis`, `PyinstrumentAnalysis` Klassen werden bereitgestellt, um die Python-Profilerstellungsdaten abzurufen und zu analysieren. Jede Funktion lädt die neuesten Daten aus dem Standard-S3-URI.
```
from smdebug.profiler.analysis.python_profile_analysis import PythonProfileAnalysis, cProfileAnalysis, PyinstrumentAnalysis
```
Verwenden Sie die PyinstrumentAnalysis Klassen cProfileAnalysis oder, wie im folgenden Beispielcode gezeigt, um Python-Profilerstellungsobjekte für die Analyse festzulegen. Es zeigt, wie ein `cProfileAnalysis` Objekt gesetzt wird, und wenn Sie es verwenden `PyinstrumentAnalysis` möchten, ersetzen Sie den Klassennamen.
```
python_analysis = cProfileAnalysis(
local_profile_dir=tf_python_stats_dir,
s3_path=tj.profiler_s3_output_path
)
```
Die folgenden Methoden sind für die `cProfileAnalysis` und `PyinstrumentAnalysis` Klassen verfügbar, um die Python-Profiling-Statistikdaten abzurufen:
+ `python_analysis.fetch_python_profile_stats_by_time(start_time_since_epoch_in_secs, end_time_since_epoch_in_secs)` – Nimmt eine Start- und eine Endzeit an und gibt die Funktionsstatistiken aller Schrittstatistiken zurück, deren Start- oder Endzeit sich mit dem angegebenen Intervall überschneidet.
+ `python_analysis.fetch_python_profile_stats_by_step(start_step, end_step, mode, start_phase, end_phase)` – Nimmt einen Startschritt und einen Endschritt auf und gibt die Funktionsstatistiken aller Schrittstatistiken zurück, deren Profilwert `step` den Anforderungen entspricht`start_step <= step < end_step`.
+ `start_step` und `end_step` (str) – Geben Sie den Startschritt und den Endschritt an, um die Python-Profilierungsstatistikdaten zu holen.
+ `mode` (str) – Geben Sie den Modus des Trainingsauftrages mithilfe der `PythonProfileModes` Enumerator-Klasse an. Der Standardwert ist `PythonProfileModes.TRAIN`. Verfügbare Optionen finden Sie im Abschnitt [Trainingsmodi und Phasen für die Python-Profilerstellung](#debugger-access-data-python-profiling-modes).
+ `start_phase` (str) – Geben Sie die Startphase in den Zielschritten mithilfe der `StepPhase` Enumerator-Klasse an. Dieser Parameter ermöglicht die Profilerstellung zwischen verschiedenen Trainingsphasen. Der Standardwert ist `StepPhase.STEP_START`. Verfügbare Optionen finden Sie im Abschnitt [Trainingsmodi und Phasen für die Python-Profilerstellung](#debugger-access-data-python-profiling-phases).
+ `end_phase` (str) – Geben Sie die Endphase in den Zielschritten mithilfe der `StepPhase` Enumerator-Klasse an. Dieser Parameter legt die Endphase des Trainings fest. Die verfügbaren Optionen sind dieselben wie für den `start_phase` Parameter. Der Standardwert ist `StepPhase.STEP_END`. Verfügbare Optionen finden Sie im Abschnitt [Trainingsmodi und Phasen für die Python-Profilerstellung](#debugger-access-data-python-profiling-phases).
+ `python_analysis.fetch_profile_stats_between_modes(start_mode, end_mode)` – Holt Statistiken aus dem Python-Profiling zwischen dem Start- und Endmodus.
+ `python_analysis.fetch_pre_step_zero_profile_stats()` – Holt die Statistiken aus der Python-Profilierung bis Schritt 0.
+ `python_analysis.fetch_post_hook_close_profile_stats()` – Holt Statistiken aus dem Python-Profiling, nachdem der Hook geschlossen wurde.
+ `python_analysis.list_profile_stats()`— Gibt eine DataFrame der Python-Profiling-Statistiken zurück. Jede Zeile enthält die Metadaten für jede Instance der Profilerstellung und die entsprechende Statistikdatei (eine pro Schritt).
+ `python_analysis.list_available_node_ids()`— Gibt eine Liste der verfügbaren Knoten IDs für die Python-Profiling-Statistiken zurück.
Die `cProfileAnalysis` klassenspezifischen Methoden:
+ `fetch_profile_stats_by_training_phase()` – Holt und aggregiert die Python-Profiling-Statistiken für jede mögliche Kombination von Start- und Endmodi. Wenn beispielsweise eine Trainings- und Validierungsphase durchgeführt wird, während die detaillierte Profilerstellung aktiviert ist, lauten die Kombinationen `(PRE_STEP_ZERO, TRAIN)`, `(TRAIN, TRAIN)`, `(TRAIN, EVAL)`, `(EVAL, EVAL)` und `(EVAL, POST_HOOK_CLOSE)`. Alle Statistikdateien in jeder dieser Kombinationen werden aggregiert.
+ `fetch_profile_stats_by_job_phase()` – Holt und aggregiert die Python-Profiling-Statistiken nach Auftragsphasen. Die Auftragsphasen sind `initialization` (Profilerstellung bis Schritt 0), `training_loop` (Training und Validierung) und `finalization` (Profilerstellung nach dem Schließen des Hooks).
# Führen Sie die Zeitachsen mehrerer Profil-Trace-Dateien zusammen
Die SMDebug Client-Bibliothek bietet Tools zur Profilerstellung, Analyse und Visualisierung zum Zusammenführen von Zeitlinien von Systemmetriken, Framework-Metriken und Python-Profilerstellungsdaten, die vom Debugger gesammelt wurden.
**Tipp**
Bevor Sie fortfahren, müssen Sie ein TrainingJob Objekt festlegen, das in den Beispielen auf dieser Seite verwendet wird. Weitere Informationen zum Einrichten eines TrainingJob Objekts finden Sie unter[Greifen Sie auf die Profildaten zu](debugger-analyze-data-profiling.md).
Die `MergedTimeline` Klasse bietet Tools zum Integrieren und Korrelieren verschiedener Profiling-Informationen in einer einzigen Zeitleiste. Nachdem Debugger Profilerfassungsdaten und Anmerkungen aus verschiedenen Phasen eines Trainingsauftrags erfasst hat, werden JSON-Dateien mit Trace-Ereignissen in einem `tracefolder` Standardverzeichnis gespeichert.
+ Für Anmerkungen in den Python-Layern werden die Trace-Dateien in `*pythontimeline.json` gespeichert.
+ Bei Anmerkungen in den TensorFlow C\$1\$1-Ebenen werden die Trace-Dateien in `*model_timeline.json` gespeichert.
+ Der Tensorflow Profiler speichert Ereignisse in einer `*trace.json.gz` Datei.
**Tipp**
Wenn Sie alle JSON-Trace-Dateien auflisten möchten, verwenden Sie den folgenden AWS CLI Befehl:
```
! aws s3 ls {tj.profiler_s3_output_path} --recursive | grep '\.json$'
```
Wie in der folgenden animierten Abbildung zu sehen ist, kann die Zusammenstellung und Ausrichtung der aus den verschiedenen Profiling-Quellen erfassten Trace-Ereignisse in einem einzigen Diagramm einen Überblick über die gesamten Ereignisse in den verschiedenen Phasen des Trainingsauftrags geben.
![\[Ein Beispiel für eine zusammengeführte Zeitleiste\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-merged-timeline.gif)
**Tipp**
Zur Interaktion mit der zusammengeführten Zeitleiste in der Traicing-App mit einer Tastatur verwenden Sie die `W` Taste zum Vergrößern, die `A` Taste zum Verschieben nach links, die `S` Taste zum Verkleinern und die `D` Taste zum Verschieben nach rechts.
Die JSON-Dateien mit mehreren Ereignisverfolgungen können mit der folgenden `MergedTimeline` API-Operation und Klassenmethode des `smdebug.profiler.analysis.utils.merge_timelines` Moduls zu einer JSON-Datei mit Ereignisverfolgungen zusammengeführt werden.
```
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
combined_timeline = MergedTimeline(path, file_suffix_filter, output_directory)
combined_timeline.merge_timeline(start, end, unit)
```
Die `MergedTimeline` API-Operation übergibt die folgenden Parameter:
+ `path` (str) – Geben Sie einen Stammordner (`/profiler-output`) an, der Trace-Dateien für die System- und Framework-Profilerstellung enthält. Sie können das `profiler-output` mithilfe der SageMaker AI-Estimator-Klassenmethode oder des Objekts lokalisieren. TrainingJob Beispiel, `estimator.latest_job_profiler_artifacts_path()` oder `tj.profiler_s3_output_path`.
+ `file_suffix_filter` (Liste) – Geben Sie eine Liste von Dateisuffixfiltern an, um Zeitleisten zusammenzuführen. Verfügbare Suffiexfilter sind: `["model_timeline.json", "pythontimeline.json", "trace.json.gz"].` Wenn dieser Parameter nicht manuell angegeben wird, werden standardmäßig alle Trace-Dateien zusammengeführt.
+ `output_directory` (str) – Geben Sie einen Pfad zum Speichern der zusammengeführten Timeline-JSON-Datei an. Die Standardeinstellung ist das für den `path` Parameter angegebene Verzeichnis.
Die `merge_timeline()` Klassenmethode übergibt die folgenden Parameter, um den Zusammenführungsprozess auszuführen:
+ `start` (int) – Geben Sie die Startzeit (in Mikrosekunden und im Unix-Zeitformat) oder den Startschritt für das Zusammenführen von Zeitlinien an.
+ `end` (int) – Geben Sie die Endzeit (in Mikrosekunden und im Unix-Zeitformat) oder den Endschritt an, um Zeitlinien zusammenzuführen.
+ `unit` (str) – Wählen Sie zwischen `"time"` und `"step"`. Der Standardwert ist `"time"`.
Führen Sie die `merge_timeline()` Methode anhand der folgenden Beispielcodes aus und laden Sie die zusammengeführte JSON-Datei herunter.
+ Zeitleiste mit der `"time"` Option Einheit zusammenführen. Der folgende Beispielcode führt alle verfügbaren Trace-Dateien zwischen der Unix-Startzeit (der absoluten Unix-Nullzeit) und der aktuellen Unix-Zeit zusammen, d. h. Sie können die Zeitleisten für die gesamte Ausbildungsdauer zusammenführen.
```
import time
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
from smdebug.profiler.profiler_constants import CONVERT_TO_MICROSECS
combined_timeline = MergedTimeline(tj.profiler_s3_output_path, output_directory="./")
combined_timeline.merge_timeline(0, int(time.time() * CONVERT_TO_MICROSECS))
```
+ Zeitleiste mit der `"step"` Option Einheit zusammenführen. Der folgende Beispielcode führt alle verfügbaren Zeitleisten zwischen Schritt 3 und Schritt 9 zusammen.
```
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
combined_timeline = MergedTimeline(tj.profiler_s3_output_path, output_directory="./")
combined_timeline.merge_timeline(3, 9, unit="step")
```
Öffnen Sie die Chrome-Tracing-App unter `chrome://tracing` in einem Chrome-Browser und öffnen Sie die JSON-Datei. Sie können die Ausgabe untersuchen, um die zusammengeführte Zeitleiste darzustellen.
# Profilierung von Datenladern
In PyTorch werden Datenlader-Iteratoren wie `SingleProcessingDataLoaderIter` und `MultiProcessingDataLoaderIter` zu Beginn jeder Iteration über einen Datensatz initiiert. PyTorch Schaltet während der Initialisierungsphase Worker-Prozesse in Abhängigkeit von der konfigurierten Anzahl von Workern ein und richtet eine Datenwarteschlange zum Abrufen von Daten und Threads ein. `pin_memory`
Um das Analysetool zur Profilerstellung von PyTorch Data Loadern zu verwenden, importieren Sie die folgende Klasse: `PT_dataloader_analysis`
```
from smdebug.profiler.analysis.utils.pytorch_dataloader_analysis import PT_dataloader_analysis
```
Übergeben Sie die Profilerstellungsdaten, die als Pandas-Rahmendatenobjekt im [Zugriff auf die Profilerstellungsdaten mit dem Pandas Data Parsing Tool](debugger-access-data-profiling-pandas-frame.md) Abschnitt abgerufen wurden:
```
pt_analysis = PT_dataloader_analysis(pf)
```
Die folgenden Funktionen sind für das `pt_analysis` Objekt verfügbar:
Die SMDebug `S3SystemMetricsReader` Klasse liest die Systemmetriken aus dem für den `s3_trial_path` Parameter angegebenen S3-Bucket.
+ `pt_analysis.analyze_dataloaderIter_initialization()`
Die Analyse gibt den Median und die maximale Dauer für diese Initialisierungen aus. Wenn es Ausreißer gibt (d. h. die Dauer ist größer als 2 \$1 Median), gibt die Funktion die Start- und Endzeiten für diese Dauern aus. Diese können verwendet werden, um die Systemmetriken während dieser Zeitintervalle zu überprüfen.
Die folgende Liste zeigt, welche Analysen mit dieser Klassenmethode möglich sind:
+ Welcher Typ von Datenlader-Iteratoren initialisiert wurde.
+ Die Anzahl der Arbeitnehmer pro Iterator.
+ Überprüfen Sie, ob der Iterator mit oder ohne pin\$1memory initialisiert wurde.
+ Anzahl der Iteratoren, die während des Trainings initialisiert wurden.
+ `pt_analysis.analyze_dataloaderWorkers()`
Die folgende Liste zeigt, welche Analysen mit dieser Klassenmethode möglich sind:
+ Die Anzahl der Arbeitsprozesse, die während der gesamten Training abgespalten wurden.
+ Mittlere und maximale Dauer für die Arbeitsprozesse.
+ Start- und Endzeit für die Arbeitsprozesse, die Ausreißer sind.
+ `pt_analysis.analyze_dataloader_getnext()`
Die folgende Liste zeigt, welche Analysen mit dieser Klassenmethode möglich sind:
+ Anzahl der während des Trainings getätigten GetNext Anrufe.
+ Median- und Höchstdauer in Mikrosekunden für GetNext Anrufe.
+ Startzeit, Endzeit, Dauer und Mitarbeiter-ID für die Dauer des GetNext Ausreißeranrufs.
+ `pt_analysis.analyze_batchtime(start_timestamp, end_timestamp, select_events=[".*"], select_dimensions=[".*"])`
Der Debugger erfasst die Start- und Endzeiten aller Anrufe. GetNext Sie können die Zeit ermitteln, die das Trainingsskript für einen Datenstapel benötigt. Innerhalb des angegebenen Zeitfensters können Sie die Anrufe identifizieren, die nicht direkt zur Ausbildung beitragen. Bei diesen Aufrufen kann es sich um folgende Operationen handeln: Berechnung der Genauigkeit, Addition der Verluste zu Debugging- oder Protokollierungszwecken und Ausdruck der Debugging-Informationen. Solche Vorgänge können rechenintensiv oder zeitaufwendig sein. Wir können solche Operationen identifizieren, indem wir den Python-Profiler, die Systemmetriken und die Framework-Metriken miteinander in Beziehung setzen.
Die folgende Liste zeigt, welche Analysen mit dieser Klassenmethode möglich sind:
+ Erstellen Sie ein Profil der für jeden Datenstapel aufgewendeten Zeit`BatchTime_in_seconds`, indem der Unterschied zwischen den Startzeiten aktueller und nachfolgender GetNext Aufrufe ermittelt wird.
+ Ermitteln Sie die Ausreißer in `BatchTime_in_seconds` und die Start- und Endzeit für diese Ausreißer.
+ Ermitteln Sie die System- und Rahmenmetriken während dieser `BatchTime_in_seconds` Zeitspannen. Dies gibt an, wo die Zeit verbracht wurde.
+ `pt_analysis.plot_the_window()`
Zeichnet ein Zeitdiagramm zwischen einem Startzeitpunkt und einem Endzeitpunkt.