Optimieren Sie die TensorFlow-Leistung mit dem Profiler

Diese Anleitung zeigt, wie Sie die mit dem TensorFlow Profiler verfügbaren Tools verwenden, um die Leistung Ihrer TensorFlow-Modelle zu verfolgen. Sie erfahren, wie Sie die Leistung Ihres Modells auf dem Host (CPU), dem Gerät (GPU) oder einer Kombination aus Host und Gerät(en) verstehen.

Profiling hilft dabei, den Hardwareressourcenverbrauch (Zeit und Speicher) der verschiedenen TensorFlow-Operationen (Ops) in Ihrem Modell zu verstehen, Leistungsengpässe zu beheben und letztendlich die Modellausführung zu beschleunigen.

Dieser Leitfaden führt Sie durch die Installation des Profilers, die verschiedenen verfügbaren Tools, die verschiedenen Modi, mit denen der Profiler Leistungsdaten erfasst, und einige empfohlene Best Practices zur Optimierung der Modellleistung.

Wenn Sie auf Cloud - TPUs Ihr Modell Leistung profilieren wollen, beziehen sich auf die Führung Wolke TPU .

Installieren Sie die Profiler- und GPU-Voraussetzungen

Installieren Sie das Profiler-Plugin für TensorBoard mit pip. Beachten Sie, dass der Profiler die neuesten Versionen von TensorFlow und TensorBoard (>=2.2) erfordert.

pip install -U tensorboard_plugin_profile

Um ein Profil auf der GPU zu erstellen, müssen Sie:

  1. Treffen Sie die NVIDIA® GPU - Treiber und CUDA® Toolkit aufgeführten Anforderungen auf TensorFlow GPU - Support - Software Anforderungen .
  2. Stellen Sie sicher , dass die NVIDIA® CUDA® Profilieren Tools - Schnittstelle (CUPTI) existiert auf dem Weg:

    /sbin/ldconfig -N -v $(sed 's/:/ /g' <<< $LD_LIBRARY_PATH) | \
    grep libcupti
    

Wenn Sie nicht CUPTI auf dem Weg haben, prepend sein Installationsverzeichnis des $LD_LIBRARY_PATH Umgebungsvariablen durch Ausführen von :

export LD_LIBRARY_PATH=/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH

Führen Sie dann den ldconfig oben Befehl erneut zu überprüfen, ob die CUPTI Bibliothek gefunden wird.

Berechtigungsprobleme lösen

Wenn Sie mit CUDA® Toolkit laufen Profilierung in einer Docker Umgebung oder auf Linux, können Probleme unzureichender CUPTI Privilegien (bezogen begegnen CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ). Gehen Sie zu dem NVIDIA Entwicklern Docs mehr darüber zu erfahren , wie Sie diese Probleme auf Linux auflösen können.

Um Probleme mit CUPTI-Berechtigungen in einer Docker-Umgebung zu beheben, führen Sie

docker run option '--privileged=true'

Profiler-Tools

Besuchen Sie das Profiler aus der Registerkarte Profil in TensorBoard, die nur angezeigt , nachdem Sie einige Modelldaten erfasst haben.

Der Profiler bietet eine Auswahl an Tools, die bei der Leistungsanalyse helfen:

  • Übersichtsseite
  • Eingangs-Pipeline-Analysator
  • TensorFlow-Statistiken
  • Trace-Viewer
  • GPU-Kernel-Statistiken
  • Speicherprofil-Tool
  • Pod-Viewer

Übersichtsseite

Die Übersichtsseite bietet eine Übersicht über die Leistung Ihres Modells während eines Profillaufs. Die Seite zeigt Ihnen eine aggregierte Übersichtsseite für Ihren Host und alle Geräte sowie einige Empfehlungen zur Verbesserung der Trainingsleistung Ihres Modells. Sie können auch einzelne Hosts im Dropdown-Menü Host auswählen.

Die Übersichtsseite zeigt die Daten wie folgt an:

Bild

  • Leistungsübersicht: Zeigt eine High-Level - Zusammenfassung Ihres Modell Leistung. Die Leistungsübersicht besteht aus zwei Teilen:

    1. Aufschlüsselung der Schrittzeit: Unterteilt die durchschnittliche Schrittzeit in mehrere Kategorien, in denen Zeit verbracht wird:

      • Kompilierung: Zeit für das Kompilieren von Kerneln.
      • Eingabe: Zeit für das Lesen von Eingabedaten.
      • Ausgabe: Zeit für das Lesen der Ausgabedaten.
      • Kernel-Start: Zeit, die der Host zum Starten von Kerneln aufwendet
      • Host-Rechenzeit..
      • Kommunikationszeit von Gerät zu Gerät.
      • Rechenzeit auf dem Gerät.
      • Alle anderen, einschließlich Python-Overhead.
    2. Geräterechengenauigkeiten – Gibt den Prozentsatz der Geräterechenzeit an, die 16- und 32-Bit-Berechnungen verwendet.

  • Step-Zeit - Diagramm: Zeigt ein Diagramm der Geräteschrittzeit (in Millisekunden) über alle abgetasteten Schritte. Jeder Schritt ist in mehrere Kategorien (mit unterschiedlichen Farben) unterteilt, in denen Zeit verbracht wird. Der rote Bereich entspricht dem Teil der Schrittzeit, in der die Geräte im Leerlauf auf Eingabedaten vom Host warteten. Der grüne Bereich zeigt an, wie lange das Gerät tatsächlich funktioniert hat.

  • Top 10 TensorFlow Operationen auf dem Gerät (zB GPU): Zeigt die auf dem Gerät ops, die die längste lief.

    Jede Zeile zeigt die Selbstzeit einer Op (als Prozentsatz der von allen Ops benötigten Zeit), die kumulierte Zeit, die Kategorie und den Namen an.

  • Run Umwelt: Zeigt eine High-Level - Zusammenfassung der Modell Laufumgebung , einschließlich:

    • Anzahl der verwendeten Hosts.
    • Gerätetyp (GPU/TPU).
    • Anzahl der Gerätekerne.
  • Empfehlung für den nächsten Schritt: Berichte , wenn ein Modell eingegeben wird gebunden und empfiehlt Werkzeuge , die Sie verwenden können , lokalisieren und Engpässe Modell Leistung lösen.

Input-Pipeline-Analysator

Wenn ein TensorFlow-Programm Daten aus einer Datei liest, beginnt es am Anfang des TensorFlow-Diagramms in einer Pipeline. Der Lesevorgang ist in mehrere hintereinander geschaltete Datenverarbeitungsstufen unterteilt, wobei die Ausgabe einer Stufe die Eingabe der nächsten ist. Dieses System zum Lesen von Daten wird die Eingangsleitung genannt.

Eine typische Pipeline zum Lesen von Datensätzen aus Dateien umfasst die folgenden Phasen:

  1. Lesen von Dateien.
  2. Dateivorverarbeitung (optional).
  3. Dateiübertragung vom Host zum Gerät.

Eine ineffiziente Eingabepipeline kann Ihre Anwendung stark verlangsamen. Eine Anwendung wird als Eingang gebunden , wenn es einen erheblichen Teil der Zeit , in der Eingangsleitung ausgibt. Verwenden Sie die Erkenntnisse des Eingabepipeline-Analyzers, um zu verstehen, wo die Eingabepipeline ineffizient ist.

Der Eingabepipeline-Analyzer sagt Ihnen sofort, ob Ihr Programm eingabegebunden ist, und führt Sie durch die geräte- und hostseitige Analyse, um Leistungsengpässe in jeder Phase der Eingabepipeline zu beheben.

In der Anleitung zur Leistung der Eingabepipeline finden Sie empfohlene Best Practices zur Optimierung Ihrer Dateneingabepipelines.

Eingabepipeline-Dashboard

Um den Eingang Pipeline - Analysator, wählen Sie Profil zu öffnen, wählen Sie dann input_pipeline_analyzer aus dem Tools - Dropdown - Menü.

Bild

Das Dashboard enthält drei Abschnitte:

  1. Zusammenfassung: Fasst die Gesamt - Eingang Pipeline mit Informationen darüber , ob Ihre Anwendung Eingang gebunden , und wenn ja, um wie viel.
  2. Einrichtungsseitigen Analyse: Zeigt detaillierte, einrichtungsseitigen Analyseergebnisse, einschließlich der Geräte Schritt Zeit und dem Bereich der Gerätezeit für die Eingabe von Daten über Kerne in jedem Schritt aufgewendet warten.
  3. Host-seitige Analyse: eine Detailanalyse auf der Host - Seite, einschließlich einem Ausfall der Eingangsverarbeitungszeit auf dem Host.

Zusammenfassung der Eingabepipeline

Die Zusammenfassung berichtet , wenn Sie die Programmeingabe durch die Vorlage der Prozentsatz der Gerätezeit verbrachte auf der Warteliste für die Eingabe vom Host gebunden ist. Wenn Sie eine instrumentierte Standardeingabepipeline verwenden, meldet das Tool, wo die meiste Eingabeverarbeitungszeit aufgewendet wird.

Geräteseitige Analyse

Die geräteseitige Analyse bietet Einblicke in die Zeit, die auf dem Gerät im Vergleich zum Host verbracht wurde, und wie viel Gerätezeit damit verbracht wurde, auf Eingabedaten vom Host zu warten.

  1. Schrittzeit gegen Schrittzahl aufgetragen: Zeigt ein Diagramm der Geräteschrittzeit (in Millisekunden) über alle abgetasteten Schritte. Jeder Schritt ist in mehrere Kategorien (mit unterschiedlichen Farben) unterteilt, in denen Zeit verbracht wird. Der rote Bereich entspricht dem Teil der Schrittzeit, in der die Geräte im Leerlauf auf Eingabedaten vom Host warteten. Der grüne Bereich zeigt an, wie viel Zeit das Gerät tatsächlich in Betrieb war.
  2. Schritt Zeitstatistiken: Meldet den Mittelwert, Standardabweichung und Bereich ([Minimum, Maximum]) des Gerätes Schrittzeit.

Hostseitige Analyse

Die Host-seitige Analyse meldet einen Zusammenbruch der Eingabeverarbeitungszeit (die Zeit verbrachte tf.data API ops) auf dem Host in mehrere Kategorien:

  • Lesen von Daten aus Dateien auf Anfrage: Die Zeit , auf Daten aus Dateien ohne Cache zu lesen, Prefetching und Verschachtelung.
  • Lesen von Daten aus Dateien im Voraus: Zeit - Dateien ausgegeben Lesen, einschließlich Caching, Prefetching und Verschachtelung.
  • Datenvorverarbeitung: Zeitaufwand für die Vorverarbeitung ops, wie Bilddekomprimierung.
  • Einreihen Daten zum Gerät übertragen werden: Die Zeit , Daten in eine Einspeisung Warteschlange setzen , bevor die Daten an das Gerät zu übertragen.

Expand Eingang Op Statistik die Statistik für die einzelnen Eingang ops und ihre Kategorien aufgeschlüsselt nach Ausführungszeit zu untersuchen.

Bild

Eine Quelldatentabelle wird mit jedem Eintrag angezeigt, der die folgenden Informationen enthält:

  1. Input Op: Zeigt die TensorFlow op Namen der Eingabe op.
  2. Graf: Zeigt die Gesamtzahl der Fälle von op Ausführung während der Profilierung Periode.
  3. Gesamtzeit (in ms): Zeigt die kumulative Summe der Zeit auf jedem dieser Fälle ausgegeben.
  4. Gesamtspielzeit%: Zeigt die Gesamtzeit auf einem Operations als einen Bruchteil der Gesamtzeit in Eingabeverarbeitung ausgegeben.
  5. Gesamteigenzeit (in ms): Zeigt die kumulative Summe der Selbst Zeit auf jedem dieser Fälle ausgegeben. Die Selbstzeit misst hier die Zeit, die innerhalb des Funktionsrumpfs verbracht wird, ohne die Zeit, die in der aufgerufenen Funktion verbracht wird.
  6. Insgesamt Eigenzeit%. Zeigt die gesamte Selbstzeit als Bruchteil der Gesamtzeit an, die für die Eingabeverarbeitung aufgewendet wurde.
  7. Kategorie. Zeigt die Verarbeitungskategorie der Eingabeoperation an.

TensorFlow-Statistiken

Das TensorFlow-Stats-Tool zeigt die Leistung jeder TensorFlow-Operation (op) an, die während einer Profiling-Sitzung auf dem Host oder Gerät ausgeführt wird.

Bild

Das Tool zeigt Leistungsinformationen in zwei Bereichen an:

  • Im oberen Bereich werden bis zu vier Tortendiagramme angezeigt:

    1. Die Verteilung der Selbstausführungszeit jeder Operation auf dem Host.
    2. Die Verteilung der Selbstausführungszeit jedes Op-Typs auf dem Host.
    3. Die Verteilung der Selbstausführungszeit jeder Operation auf dem Gerät.
    4. Die Verteilung der Selbstausführungszeit jedes Operationstyps auf dem Gerät.
  • Der untere Bereich zeigt eine Tabelle mit Daten zu TensorFlow-Operationen mit einer Zeile für jede Operation und einer Spalte für jeden Datentyp (sortieren Sie die Spalten, indem Sie auf die Spaltenüberschrift klicken). Klicken Sie auf die Export als CSV - Taste auf der rechten Seite des oberen Bereichs , um die Daten aus dieser Tabelle als CSV - Datei zu exportieren.

    Beachten Sie, dass:

    • Wenn Ops untergeordnete Ops haben:

      • Die gesamte "akkumulierte" Zeit einer Op beinhaltet die Zeit, die in den untergeordneten Ops verbracht wird.

      • Die gesamte "Selbst"-Zeit einer Op beinhaltet nicht die Zeit, die in den untergeordneten Ops verbracht wird.

    • Wenn eine Operation auf dem Host ausgeführt wird:

      • Der Prozentsatz der gesamten Selbstzeit auf dem Gerät, der durch die Operation verursacht wird, beträgt 0.
      • Der kumulative Prozentsatz der gesamten Selbstzeit auf dem Gerät bis einschließlich dieser Operation beträgt 0.
    • Wenn eine Operation auf dem Gerät ausgeführt wird:

      • Der Prozentsatz der gesamten Selbstzeit auf dem Host, der durch diese Operation verursacht wird, beträgt 0.
      • Der kumulative Prozentsatz der gesamten Selbstzeit auf dem Host bis einschließlich dieser Operation beträgt 0.

Sie können die Leerlaufzeit in die Kreisdiagramme und die Tabelle ein- oder ausschließen.

Trace-Viewer

Der Trace-Viewer zeigt eine Zeitleiste an, die Folgendes anzeigt:

  • Dauer der Operationen, die von Ihrem TensorFlow-Modell ausgeführt wurden
  • Welcher Teil des Systems (Host oder Gerät) hat eine Operation ausgeführt. Typischerweise führt der Host Eingabeoperationen aus, verarbeitet Trainingsdaten vor und überträgt sie an das Gerät, während das Gerät das eigentliche Modelltraining ausführt

Mit dem Trace-Viewer können Sie Leistungsprobleme in Ihrem Modell identifizieren und dann Schritte zu deren Behebung ausführen. Auf einer hohen Ebene können Sie beispielsweise feststellen, ob das Eingabe- oder Modelltraining die meiste Zeit in Anspruch nimmt. Wenn Sie einen Drilldown ausführen, können Sie feststellen, welche Operationen am längsten ausgeführt werden. Beachten Sie, dass der Trace-Viewer auf 1 Million Ereignisse pro Gerät beschränkt ist.

Trace-Viewer-Schnittstelle

Wenn Sie den Trace-Viewer öffnen, wird dieser mit Ihrem letzten Lauf angezeigt:

Bild

Dieser Bildschirm enthält die folgenden Hauptelemente:

  1. Timeline - Fenster: Zeigt ops , dass das Gerät und die Host über die Zeit ausgeführt.
  2. Detailbereich: Zeigt zusätzliche Informationen für die im Schnittbereich ausgewählt ops.

Der Zeitleistenbereich enthält die folgenden Elemente:

  1. Top Bar: Enthält verschiedene Hilfssteuerungen.
  2. Zeitachse: relative Shows Zeit bis zum Beginn der Spur.
  3. Abschnitt und Track - Etikett: Jeder Abschnitt enthält mehrere Spuren und hat ein Dreieck auf der linken Seite , dass Sie klicken , um den Abschnitt zu erweitern oder zu reduzieren. Für jedes Verarbeitungselement im System gibt es einen Abschnitt.
  4. Werkzeugauswahl: Enthält verschiedene Werkzeuge für die mit der Spur Betrachter interagieren wie Zoom, Pan, Select und Timing. Verwenden Sie das Timing-Tool, um ein Zeitintervall zu markieren.
  5. Events: Diese zeigen die Zeit , während der ein op ausgeführt wurde oder die Dauer der Meta-Events, wie zum Beispiel Trainingsschritte.
Abschnitte und Spuren

Der Trace-Viewer enthält die folgenden Abschnitte:

  • Ein Abschnitt für jeden Geräteknoten, bezeichnete mit der Nummer des Vorrichtungs - Chips und dem Vorrichtungsknoten innerhalb des Chips (beispielsweise /device:GPU:0 (pid 0) ). Jeder Geräteknotenabschnitt enthält die folgenden Spuren:
    • Schritt: Zeigt die Dauer der Trainingsschritte , die auf dem Gerät ausgeführt wurden
    • TensorFlow Ops: Zeigt die auf dem Gerät ausgeführt ops
    • XLA Ops: Shows XLA - Operationen (ops) dass RAN auf dem Gerät , wenn XLA ist der Compiler verwendet (jede TensorFlow op wird in eine oder mehrere XLA ops übersetzte die XLA - Compiler übersetzt die XLA ops in einen Code, der ausgeführt wird auf dem Gerät.).
  • Ein Abschnitt für Gewinde auf dem Host - Rechner der CPU ausgeführt wird , die mit „Host - Threads“. Der Abschnitt enthält eine Spur für jeden CPU-Thread. Beachten Sie, dass Sie die neben den Abschnittsbeschriftungen angezeigten Informationen ignorieren können.
Veranstaltungen

Ereignisse innerhalb der Zeitleiste werden in verschiedenen Farben angezeigt; die Farben selbst haben keine spezifische Bedeutung.

Der Trace-Viewer kann auch Traces von Python-Funktionsaufrufen in Ihrem TensorFlow-Programm anzeigen. Wenn Sie die Verwendung tf.profiler.experimental.start API können Sie Python Tracing aktivieren , indem die Verwendung von ProfilerOptions namedtuple wenn Profilierung beginnen. Alternativ, wenn Sie den Sampling - Modus zum Profilieren verwenden, können Sie die Tracestufe auswählen , indem Sie die Dropdown - Optionen im Capture - Profil - Dialog.

Bild

GPU-Kernel-Statistiken

Dieses Tool zeigt Leistungsstatistiken und die Ursprungsoperation für jeden GPU-beschleunigten Kernel an.

Bild

Das Tool zeigt Informationen in zwei Bereichen an:

  • Der obere Bereich zeigt ein Tortendiagramm an, das die CUDA-Kernel mit der höchsten Gesamtzeit anzeigt.

  • Im unteren Bereich wird eine Tabelle mit den folgenden Daten für jedes eindeutige Kernel-Op-Paar angezeigt:

    • Ein Rang in absteigender Reihenfolge der gesamten verstrichenen GPU-Dauer, gruppiert nach Kernel-Op-Paar.
    • Der Name des gestarteten Kernels.
    • Die Anzahl der vom Kernel verwendeten GPU-Register.
    • Die Gesamtgröße des gemeinsam genutzten (statischen + dynamischen gemeinsam genutzten) Speichers in Byte.
    • Der Blockmaß ausgedrückt blockDim.x, blockDim.y, blockDim.z .
    • Die Gitterabmessungen ausgedrückt als gridDim.x, gridDim.y, gridDim.z .
    • Ob der op ist berechtigt , verwenden Tensor Cores .
    • Ob der Kernel Tensor Core-Anweisungen enthält.
    • Der Name der Op, die diesen Kernel gestartet hat.
    • Die Anzahl der Vorkommen dieses Kernel-Op-Paares.
    • Die gesamte verstrichene GPU-Zeit in Mikrosekunden.
    • Die durchschnittlich verstrichene GPU-Zeit in Mikrosekunden.
    • Die minimal verstrichene GPU-Zeit in Mikrosekunden.
    • Die maximal verstrichene GPU-Zeit in Mikrosekunden.

Speicherprofil-Tool

Die Memory Profile Tool überwacht die Speichernutzung Ihres Geräts beim Profilieren Intervall. Sie können dieses Tool verwenden, um:

  • Debuggen Sie Out-of-Memory-Probleme (OOM), indem Sie die Spitzenspeicherauslastung und die entsprechende Speicherzuweisung für TensorFlow-Operationen lokalisieren. Sie können debuggen OOM Probleme auch , die entstehen können , wenn Sie laufen Multi-Tenancy - Inferenz.
  • Debuggen von Problemen mit der Speicherfragmentierung.

Das Speicherprofil-Tool zeigt Daten in drei Abschnitten an:

  1. Zusammenfassung des Speicherprofils
  2. Speicher-Timeline-Diagramm
  3. Speicheraufschlüsselungstabelle

Zusammenfassung des Speicherprofils

Dieser Abschnitt zeigt eine allgemeine Zusammenfassung des Speicherprofils Ihres TensorFlow-Programms wie unten gezeigt:

Die Zusammenfassung des Speicherprofils besteht aus sechs Feldern:

  1. Speicher - ID: Drop Down , der alle Speichersysteme zur Verfügung Gerät auflistet. Wählen Sie aus der Dropdown-Liste das Speichersystem aus, das Sie anzeigen möchten.
  2. #Allocation: Die Anzahl der Speicherzuordnungen während des Profilierungsintervall gemacht.
  3. #Deallocation: Die Anzahl der Speicherfreigaben in dem Profilierungs Intervall
  4. Speicherkapazität: Die Gesamtkapazität (in Gibs) des Speichersystems , die Sie auswählen.
  5. Peak Heap - Verbrauch: Die maximale Speichernutzung (in Gibs) , da das Modell ausgeführt wird gestartet.
  6. Peak Speichernutzung: Die maximale Speichernutzung (in Gibs) in der Profilierung Intervall. Dieses Feld enthält die folgenden Unterfelder:
    1. Zeitstempel: Der Zeitstempel, wann die maximale Speichernutzung auf der Timeline Graph aufgetreten.
    2. Stack - Reservierung: Anzahl der Speicher auf dem Stapel reserviert (in Gibs).
    3. Heapzuordnung: Größe des Speichers auf dem Heap (in Nachstelleisten) zugeordnet.
    4. Freie Speicher: Größe des freien Speichers (in Gibs). Die Speicherkapazität ist die Summe aus Stack-Reservierung, Heap-Zuordnung und freiem Speicher.
    5. Fragmentation: Der Anteil der Fragmentierung (weniger ist besser). Es wird als Prozentsatz berechnet (1 - Size of the largest chunk of free memory / Total free memory) .

Speicher-Zeitachsendiagramm

In diesem Abschnitt wird ein Diagramm der Speichernutzung (in GiBs) und des Prozentsatzes der Fragmentierung im Vergleich zur Zeit (in ms) angezeigt.

Bild

Die X-Achse repräsentiert die Zeitachse (in ms) des Profiling-Intervalls. Die Y-Achse auf der linken Seite repräsentiert die Speichernutzung (in GiBs) und die Y-Achse auf der rechten Seite repräsentiert den Prozentsatz der Fragmentierung. Zu jedem Zeitpunkt auf der X-Achse wird der Gesamtspeicher in drei Kategorien unterteilt: Stack (in Rot), Heap (in Orange) und Free (in Grün). Bewegen Sie den Mauszeiger über einen bestimmten Zeitstempel, um die Details zu den Ereignissen zur Speicherzuweisung/zur Aufhebung der Zuweisung zu diesem Zeitpunkt wie folgt anzuzeigen:

Bild

Das Popup-Fenster zeigt die folgenden Informationen an:

  • Zeitstempel (ms): Die Lage des ausgewählten Ereignisses auf der Timeline.
  • Veranstaltung: Die Art der Veranstaltung (Zuweisung oder Freigabe).
  • requested_size (Gibs): Die Menge an Speicher angefordert. Bei Aufhebungsereignissen ist dies eine negative Zahl.
  • allocation_size (Gibs): Die tatsächliche Menge an Speicher zugewiesen. Bei Aufhebungsereignissen ist dies eine negative Zahl.
  • tf_op: Die TensorFlow op, die die Zuordnung / Aufhebung der Zuordnung anfordert.
  • step_id: Der Schritt Training , in dem dieses Ereignis aufgetreten ist .
  • region_type: Der Datenelementtyp , dass diese zugewiesenen Speicher für sind. Mögliche Werte sind temp für Provisorien, output für Aktivierungen und Gradienten und persist / dynamic für Gewichte und Konstanten.
  • data_type: Der Tensor Elementtyp (zB uint8 für 8-bit unsigned integer).
  • tensor_shape: Die Form des Tensor zugeordnet / freigegeben werden.
  • memory_in_use (Gibs): Die Gesamtspeicher, der zu diesem Zeitpunkt in Betrieb ist.

Speicheraufschlüsselungstabelle

Diese Tabelle zeigt die aktiven Speicherzuweisungen zum Zeitpunkt der Spitzenspeichernutzung im Profiling-Intervall.

Bild

Es gibt eine Zeile für jede TensorFlow-Op und jede Zeile hat die folgenden Spalten:

  • Op Name: Der Name des TensorFlow op.
  • Zuordnungsgröße (Gibs): Die Gesamtmenge des Speichers zu diesem op zugeordnet.
  • Angeforderte Größe (Gibs): Die Gesamtmenge an Speicher für diese op angefordert.
  • Vorkommen: Die Anzahl der Zuweisungen für diese op.
  • Region Typ: Der Datenelementtyp , dass diese zugewiesenen Speicher für sind. Mögliche Werte sind temp für Provisorien, output für Aktivierungen und Gradienten und persist / dynamic für Gewichte und Konstanten.
  • Datentyp: Der Tensor Elementtyp.
  • Form: Die Form des zugeordneten Tensoren.

Pod-Viewer

Das Pod Viewer-Tool zeigt die Aufschlüsselung eines Schulungsschritts für alle Mitarbeiter.

Bild

  • Im oberen Bereich befindet sich ein Schieberegler zum Auswählen der Schrittnummer.
  • Im unteren Bereich wird ein gestapeltes Säulendiagramm angezeigt. Dies ist eine übergeordnete Ansicht von aufgeschlüsselten Schritt-Zeit-Kategorien, die übereinander angeordnet sind. Jede gestapelte Spalte repräsentiert einen eindeutigen Arbeiter.
  • Wenn Sie mit der Maus über eine gestapelte Spalte fahren, zeigt die Karte auf der linken Seite weitere Details zur Schrittaufteilung an.

tf.data-Engpassanalyse

Das tf.data Engpass - Analyse - Tool erkennt automatisch Engpässe in tf.data Eingangsleitungen in Ihrem Programm und liefert Empfehlungen, wie sie zu beheben. Es funktioniert mit jedem Programm tf.data unabhängig von der Plattform (CPU / GPU / TPU). Seine Analysen und Empfehlungen sind auf dieser Basis Führung .

Es erkennt einen Engpass, indem es die folgenden Schritte ausführt:

  1. Finden Sie den Host mit den meisten Eingaben.
  2. Finden Sie die langsamste Ausführung einer tf.data Eingang Pipeline.
  3. Rekonstruieren Sie das Eingabepipelinediagramm aus dem Profiler-Trace.
  4. Suchen Sie den kritischen Pfad im Eingabepipelinediagramm.
  5. Identifizieren Sie die langsamste Transformation auf dem kritischen Pfad als Engpass.

Die Benutzeroberfläche ist in drei Abschnitte unterteilt: Performance - Analyse Zusammenfassung, Zusammenfassung aller Eingänge Pipelines und Input Pipeline Graph.

Zusammenfassung der Leistungsanalyse

Bild

Dieser Abschnitt enthält die Zusammenfassung der Analyse. Es berichtet über langsame tf.data Eingangsleitungen im Profil erfasst. Dieser Abschnitt zeigt auch den Host mit der höchsten Eingabebeschränkung und seine langsamste Eingabepipeline mit der maximalen Latenz. Am wichtigsten ist, dass es identifiziert, welcher Teil der Eingabepipeline der Engpass ist und wie er behoben werden kann. Die Engpassinformationen werden mit dem Iteratortyp und seinem langen Namen bereitgestellt.

So lesen Sie den langen Namen des tf.data-Iterators

Ein langer Name wird als formatiert Iterator::<Dataset_1>::...::<Dataset_n> . In dem langen Namen, <Dataset_n> entspricht den Iteratortyp und die anderen Datensätze in dem langen Namen repräsentieren Downstream - Transformationen.

Betrachten Sie beispielsweise das folgende Eingabepipeline-Dataset:

dataset = tf.data.Dataset.range(10).map(lambda x: x).repeat(2).batch(5)

Die langen Namen für die Iteratoren aus dem obigen Datensatz lauten:

Iteratortyp Langer Name
Reichweite Iterator::Batch::Repeat::Map::Range
Karte Iterator::Batch::Wiederholen::Map
Wiederholen Iterator::Batch::Wiederholen
Stapel Iterator::Batch

Zusammenfassung aller Eingabepipelines

Bild

Dieser Abschnitt enthält eine Zusammenfassung aller Eingabepipelines auf allen Hosts. Normalerweise gibt es eine Eingabepipeline. Wenn die Verteilungsstrategie verwendet wird , gibt es eine Host - Eingabe - Pipeline des Programms läuft tf.data Code und mehrere Vorrichtungseingangsleitungen Daten von der Host - Eingabe - Pipeline abgerufen und zu den Vorrichtungen zu übertragen.

Für jede Eingabepipeline zeigt sie die Statistik ihrer Ausführungszeit an. Ein Anruf wird als langsam gezählt, wenn er länger als 50 μs dauert.

Eingabe-Pipeline-Diagramm

Bild

Dieser Abschnitt zeigt das Eingabepipeline-Diagramm mit den Informationen zur Ausführungszeit. Sie können mit "Host" und "Eingabepipeline" auswählen, welcher Host und welche Eingabepipeline angezeigt werden sollen. Exekutionen der Eingangsleitung werden durch die Ausführungszeit sortiert in absteigender Reihenfolge , die Sie auswählen können , die Rank Drop - Down verwenden.

Bild

Die Knoten auf dem kritischen Pfad haben fette Umrisse. Der Engpassknoten, der Knoten mit der längsten Selbstzeit auf dem kritischen Pfad, ist rot umrandet. Die anderen nicht kritischen Knoten haben graue gestrichelte Umrisse.

In jedem Knoten gibt Startzeit die Startzeit der Ausführung. Derselbe Knoten kann mehrmals ausgeführt werden, zum Beispiel, wenn es eine ist Batch op in der Eingangsleitung. Bei mehrfacher Ausführung ist dies die Startzeit der ersten Ausführung.

Gesamtdauer ist die Wand Zeitpunkt der Ausführung. Bei mehrfacher Ausführung ist es die Summe der Wandzeiten aller Ausführungen.

Selbst Zeit ist Gesamtspielzeit ohne Überlappungszeit mit seinem unmittelbaren untergeordneten Knoten.

"# Calls" gibt an, wie oft die Eingabepipeline ausgeführt wird.

Leistungsdaten sammeln

Der TensorFlow Profiler sammelt Hostaktivitäten und GPU-Traces Ihres TensorFlow-Modells. Sie können den Profiler so konfigurieren, dass Leistungsdaten entweder im programmgesteuerten Modus oder im Sampling-Modus erfasst werden.

Profilerstellungs-APIs

Sie können die folgenden APIs verwenden, um Profilerstellung durchzuführen.

  • Programmatischen Modus des TensorBoard Keras Rückruf nutzen ( tf.keras.callbacks.TensorBoard )

    # Profile from batches 10 to 15
    tb_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
                                                 profile_batch='10, 15')
    
    # Train the model and use the TensorBoard Keras callback to collect
    # performance profiling data
    model.fit(train_data,
              steps_per_epoch=20,
              epochs=5,
              callbacks=[tb_callback])
    
  • Programmatische Modus , um die Verwendung von tf.profiler Funktion API

    tf.profiler.experimental.start('logdir')
    # Train the model here
    tf.profiler.experimental.stop()
    
  • Programmatischer Modus mit dem Kontextmanager

    with tf.profiler.experimental.Profile('logdir'):
        # Train the model here
        pass
    

  • Sampling - Modus: Führen Sie On-Demand - Profilerstellung mithilfe von tf.profiler.experimental.server.start einen gRPC Server mit Ihrem TensorFlow Modelllauf starten. Die gRPC Server und läuft Ihr Modell Nach dem Start können Sie ein Profil durch das Capture - Profil Button im TensorBoard Profil Plugin erfassen. Verwenden Sie das Skript im Abschnitt Profiler installieren oben, um eine TensorBoard-Instanz zu starten, wenn sie noch nicht ausgeführt wird.

    Als Beispiel,

    # Start a profiler server before your model runs.
    tf.profiler.experimental.server.start(6009)
    # (Model code goes here).
    #  Send a request to the profiler server to collect a trace of your model.
    tf.profiler.experimental.client.trace('grpc://localhost:6009',
                                          'gs://your_tb_logdir', 2000)
    

    Ein Beispiel für die Profilerstellung mehrerer Mitarbeiter:

    # E.g. your worker IP addresses are 10.0.0.2, 10.0.0.3, 10.0.0.4, and you
    # would like to profile for a duration of 2 seconds.
    tf.profiler.experimental.client.trace(
        'grpc://10.0.0.2:8466,grpc://10.0.0.3:8466,grpc://10.0.0.4:8466',
        'gs://your_tb_logdir',
        2000)
    

Verwenden Sie den Capture - Profil Dialog näher zu spezifizieren:

  • Eine durch Kommas getrennte Liste von Profildienst-URLs oder TPU-Namen.
  • Eine Profilierungsdauer.
  • Die Ebene der Ablaufverfolgung von Geräte-, Host- und Python-Funktionsaufrufen.
  • Wie oft der Profiler die Erfassung von Profilen wiederholen soll, wenn er zunächst nicht erfolgreich war.

Profilerstellung benutzerdefinierter Trainingsschleifen

Um individuelle Trainingsschlaufen in Ihrem TensorFlow Code zu profilieren, Instrument der Trainingsschleife mit dem tf.profiler.experimental.Trace API , um die Schritt Grenzen für den Profiler zu markieren.

Der name Argument als Präfix für die Schrittnamen verwendet wird, die step_num ist Schlüsselwort - Argument in den Schrittnamen angehängt und das _r Schlüsselwort - Argument macht dieses Trace - Ereignis als einen Schritt Ereignis durch den Profiler verarbeitet bekommen.

Als Beispiel,

for step in range(NUM_STEPS):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_data = next(dataset)
        train_step(train_data)

Dadurch wird die schrittbasierte Leistungsanalyse des Profilers aktiviert und die Schrittereignisse werden im Trace-Viewer angezeigt.

Stellen Sie sicher , dass Sie den Datensatz Iterator im umfassen tf.profiler.experimental.Trace Kontext für eine genaue Analyse des Eingangs Pipeline.

Das folgende Code-Snippet ist ein Anti-Muster:

for step, train_data in enumerate(dataset):
    with tf.profiler.experimental.Trace('train', step_num=step, _r=1):
        train_step(train_data)

Anwendungsfälle profilieren

Der Profiler deckt eine Reihe von Anwendungsfällen entlang von vier verschiedenen Achsen ab. Einige der Kombinationen werden derzeit unterstützt und andere werden in Zukunft hinzugefügt. Einige der Anwendungsfälle sind:

  • Lokale vs. Fernprofilierungs: Dies sind zwei gängige Möglichkeiten der Einrichtung Ihr Profil Umgebung. Bei der lokalen Profilerstellung wird die Profilerstellungs-API auf demselben Computer aufgerufen, den Ihr Modell ausführt, beispielsweise eine lokale Arbeitsstation mit GPUs. Beim Remote-Profiling wird die Profiling-API auf einem anderen Computer aufgerufen, auf dem Ihr Modell ausgeführt wird, beispielsweise auf einer Cloud TPU.
  • Mehrere Arbeiter Profilierungs: Sie können mehrere Maschinen Profil , wenn die verteilten Trainingsfunktionen von TensorFlow verwenden.
  • Hardware - Plattform: Profil CPUs, GPUs und TPUs.

Die folgende Tabelle bietet einen schnellen Überblick über die oben genannten Anwendungsfälle, die von TensorFlow unterstützt werden:

Profilerstellungs-API Lokal Fernbedienung Mehrere Arbeiter Hardware-Plattformen
Rückruf von TensorBoard Keras Unterstützt Nicht unterstützt Nicht unterstützt CPU, GPU
tf.profiler.experimental Start / Stopp - API Unterstützt Nicht unterstützt Nicht unterstützt CPU, GPU
tf.profiler.experimental client.trace API Unterstützt Unterstützt Unterstützt CPU, GPU, TPU
Kontextmanager-API Unterstützt Nicht unterstützt Nicht unterstützt CPU, GPU

Best Practices für eine optimale Modellleistung

Verwenden Sie die folgenden Empfehlungen für Ihre TensorFlow-Modelle, um eine optimale Leistung zu erzielen.

Führen Sie im Allgemeinen alle Transformationen auf dem Gerät durch und stellen Sie sicher, dass Sie die neueste kompatible Version von Bibliotheken wie cuDNN und Intel MKL für Ihre Plattform verwenden.

Optimieren Sie die Eingabedatenpipeline

Verwenden Sie die Daten aus dem [#input_pipeline_analyzer], um Ihre Dateneingabepipeline zu optimieren. Eine effiziente Dateneingabepipeline kann die Geschwindigkeit Ihrer Modellausführung drastisch verbessern, indem sie die Leerlaufzeit von Geräten reduziert. Versuchen Sie, die besten Praktiken detailliert in der einzuarbeiten Bessere Leistung mit dem tf.data API Guide und unten auf Ihre Dateneingabe Pipeline effizienter zu machen.

  • Im Allgemeinen kann die Parallelisierung von Operationen, die nicht sequenziell ausgeführt werden müssen, die Dateneingabepipeline erheblich optimieren.

  • In vielen Fällen hilft es, die Reihenfolge einiger Aufrufe zu ändern oder die Argumente so abzustimmen, dass sie für Ihr Modell am besten funktionieren. Benchmarken Sie beim Optimieren der Eingabedatenpipeline nur den Datenlader ohne die Trainings- und Backpropagation-Schritte, um den Effekt der Optimierungen unabhängig zu quantifizieren.

  • Versuchen Sie, Ihr Modell mit synthetischen Daten auszuführen, um zu überprüfen, ob die Eingabepipeline einen Leistungsengpass darstellt.

  • Verwenden tf.data.Dataset.shard für die Ausbildung Multi-GPU. Stellen Sie sicher, dass Sie sehr früh in der Eingabeschleife Sharding durchführen, um eine Verringerung des Durchsatzes zu vermeiden. Stellen Sie beim Arbeiten mit TFRecords sicher, dass Sie die Liste der TFRecords und nicht den Inhalt der TFRecords teilen.

  • Parallelisieren mehrere ops durch dynamisch den Wert der Einstellung num_parallel_calls mit tf.data.AUTOTUNE .

  • Betrachten sie die Nutzung der Begrenzung tf.data.Dataset.from_generator wie es langsamer im Vergleich zu reinem TensorFlow ops.

  • Betrachten wir die Nutzung der Begrenzung tf.py_function , da es nicht serialisiert werden kann und wird nicht unterstützt in verteilten TensorFlow laufen.

  • Verwendung tf.data.Options steuern statische Optimierungen auf die Eingangsleitung.

Lesen Sie auch die tf.data Performance - Analyse Leitfaden für mehr Orientierung auf Ihre Eingabe Pipeline zu optimieren.

Optimieren Sie die Datenerweiterung

Wenn mit Bilddaten arbeiten, stellen Sie Ihre Daten Augmentation effizienter durch nach der Anwendung von räumlichen Transformationen auf unterschiedliche Datentypen Gießen, wie Spiegeln, Zuschneiden, Drehen, usw.

Verwenden Sie NVIDIA® DALI

In einigen Fällen, z. B. bei einem System mit einem hohen GPU-zu-CPU-Verhältnis, reichen möglicherweise alle oben genannten Optimierungen nicht aus, um Engpässe im Datenlader aufgrund von Einschränkungen der CPU-Zyklen zu beseitigen.

Wenn Sie mit NVIDIA® GPUs für Computer Vision und Audio tiefe Lernanwendungen, sollten Sie mit dem Laden von Daten Library ( DALI ) , um die Datenpipeline zu beschleunigen.

Überprüfen Sie die NVIDIA® DALI: Operationen Dokumentation für eine Liste der unterstützten DALI ops.

Verwenden Sie Threading und parallele Ausführung

Führen Sie ops auf mehreren CPU - Threads mit dem tf.config.threading API , um sie schneller auszuführen.

TensorFlow legt die Anzahl der Parallelitätsthreads standardmäßig automatisch fest. Der für die Ausführung von TensorFlow-Operationen verfügbare Thread-Pool hängt von der Anzahl der verfügbaren CPU-Threads ab.

Steuert die maximale Beschleunigung parallel für eine einzige op durch Verwendung tf.config.threading.set_intra_op_parallelism_threads . Beachten Sie, dass, wenn Sie mehrere Operationen parallel ausführen, sich alle den verfügbaren Thread-Pool teilen.

Wenn Sie unabhängige Non-Blocking - ops haben (ops ohne gerichteten Weg zwischen ihnen auf der Grafik), Verwendung tf.config.threading.set_inter_op_parallelism_threads sie gleichzeitig auszuführen , um die verfügbaren Thread - Pool verwendet wird .

Sonstiges

Wenn Sie mit kleineren Modellen auf NVIDIA® GPUs arbeiten, können Sie festlegen tf.compat.v1.ConfigProto.force_gpu_compatible=True alle CPU Tensoren zu zwingen , mit CUDA - Abonnenten Speicher zugewiesen werden , um eine deutliche Steigerung Modell Leistung zu geben. Seien Sie jedoch vorsichtig, wenn Sie diese Option für unbekannte/sehr große Modelle verwenden, da dies die Leistung des Hosts (CPU) beeinträchtigen kann.

Geräteleistung verbessern

Folgen Sie den Best Practices detailliert hier und in der GPU - Performance - Optimierung Leitfaden zur Optimierung der On-Device TensorFlow Modell Leistung.

Wenn Sie NVIDIA-GPUs verwenden, protokollieren Sie die GPU- und Arbeitsspeicherauslastung in einer CSV-Datei, indem Sie Folgendes ausführen:

nvidia-smi
--query-gpu=utilization.gpu,utilization.memory,memory.total,
memory.free,memory.used --format=csv

Datenlayout konfigurieren

Wenn Sie mit Daten arbeiten, die Kanalinformationen (wie Bilder) enthalten, optimieren Sie das Datenlayoutformat, um Kanäle zuletzt zu bevorzugen (NHWC gegenüber NCHW).

Kanal letzte Datenformate verbessern Tensor Core - Auslastung und bieten erhebliche Leistungsverbesserungen insbesondere in Faltungsmodellen , wenn sie mit AMP gekoppelt. NCHW-Datenlayouts können weiterhin von Tensor-Cores bearbeitet werden, führen jedoch aufgrund automatischer Transponierungsoperationen zu zusätzlichem Overhead.

Sie können die Daten - Layout optimieren NHWC Layouts , indem Sie bevorzugen data_format="channels_last" für Schichten wie tf.keras.layers.Conv2D , tf.keras.layers.Conv3D und tf.keras.layers.experimental.preprocessing.RandomRotation .

Verwendung tf.keras.backend.set_image_data_format das Standarddatenlayoutformat für den Back - End - API Keras einzustellen.

Maximiere den L2-Cache

When working with NVIDIA® GPUs, execute the code snippet below before the training loop to max out the L2 fetch granularity to 128 bytes.

import ctypes

_libcudart = ctypes.CDLL('libcudart.so')
# Set device limit on the current device
# cudaLimitMaxL2FetchGranularity = 0x05
pValue = ctypes.cast((ctypes.c_int*1)(), ctypes.POINTER(ctypes.c_int))
_libcudart.cudaDeviceSetLimit(ctypes.c_int(0x05), ctypes.c_int(128))
_libcudart.cudaDeviceGetLimit(pValue, ctypes.c_int(0x05))
assert pValue.contents.value == 128

Configure GPU thread usage

The GPU thread mode decides how GPU threads are used.

Set the thread mode to gpu_private to make sure that preprocessing does not steal all the GPU threads. This will reduce the kernel launch delay during training. You can also set the number of threads per GPU. Set these values using environment variables.

import os

os.environ['TF_GPU_THREAD_MODE']='gpu_private'
os.environ['TF_GPU_THREAD_COUNT']='1'

Configure GPU memory options

In general, increase the batch size and scale the model to better utilize GPUs and get higher throughput. Note that increasing the batch size will change the model's accuracy so the model needs to be scaled by tuning hyperparameters like the learning rate to meet the target accuracy.

Also, use tf.config.experimental.set_memory_growth to allow GPU memory to grow to prevent all the available memory from being fully allocated to ops that require only a fraction of the memory. This allows other processes which consume GPU memory to run on the same device.

To learn more, check out the Limiting GPU memory growth guidance in the GPU guide to learn more.

Sonstiges

  • Increase the training mini-batch size (number of training samples used per device in one iteration of the training loop) to the maximum amount that fits without an out of memory (OOM) error on the GPU. Increasing the batch size impacts the model's accuracy—so make sure you scale the model by tuning hyperparameters to meet the target accuracy.

  • Disable reporting OOM errors during tensor allocation in production code. Set report_tensor_allocations_upon_oom=False in tf.compat.v1.RunOptions .

  • For models with convolution layers, remove bias addition if using batch normalization. Batch normalization shifts values by their mean and this removes the need to have a constant bias term.

  • Use TF Stats to find out how efficiently on-device ops run.

  • Use tf.function to perform computations and optionally, enable the jit_compile=True flag ( tf.function(jit_compile=True ). To learn more, go to Use XLA tf.function .

  • Minimize host Python operations between steps and reduce callbacks. Calculate metrics every few steps instead of at every step.

  • Keep the device compute units busy.

  • Send data to multiple devices in parallel.

  • Consider using 16-bit numerical representations , such as fp16 —the half-precision floating point format specified by IEEE—or the Brain floating-point bfloat16 format.

Additional resources

Known limitations

Profiling multiple GPUs on TensorFlow 2.2 and TensorFlow 2.3

TensorFlow 2.2 and 2.3 support multiple GPU profiling for single host systems only; multiple GPU profiling for multi-host systems is not supported. To profile multi-worker GPU configurations, each worker has to be profiled independently. From TensorFlow 2.4 multiple workers can be profiled using the tf.profiler.experimental.client.trace API.

CUDA® Toolkit 10.2 or later is required to profile multiple GPUs. As TensorFlow 2.2 and 2.3 support CUDA® Toolkit versions only up to 10.1, you need to create symbolic links to libcudart.so.10.1 and libcupti.so.10.1 :

sudo ln -s /usr/local/cuda/lib64/libcudart.so.10.2 /usr/local/cuda/lib64/libcudart.so.10.1
sudo ln -s /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.2 /usr/local/cuda/extras/CUPTI/lib64/libcupti.so.10.1