Optimalkan kinerja TensorFlow menggunakan Profiler

Panduan ini menunjukkan cara menggunakan alat yang tersedia dengan TensorFlow Profiler untuk melacak kinerja model TensorFlow Anda. Anda akan mempelajari cara memahami bagaimana kinerja model Anda pada host (CPU), perangkat (GPU), atau pada kombinasi host dan perangkat.

Pembuatan profil membantu memahami konsumsi sumber daya perangkat keras (waktu dan memori) dari berbagai operasi (operasi) TensorFlow dalam model Anda dan mengatasi kemacetan kinerja dan, pada akhirnya, membuat model dijalankan lebih cepat.

Panduan ini akan memandu Anda tentang cara menginstal Profiler, berbagai alat yang tersedia, berbagai mode cara Profiler mengumpulkan data kinerja, dan beberapa praktik terbaik yang disarankan untuk mengoptimalkan kinerja model.

Jika Anda ingin profil kinerja model Anda pada Cloud TPUs, mengacu pada Cloud TPU panduan .

Instal prasyarat Profiler dan GPU

Instal plugin Profiler untuk TensorBoard dengan pip. Perhatikan bahwa Profiler memerlukan versi terbaru dari TensorFlow dan TensorBoard (>=2.2).

pip install -U tensorboard_plugin_profile

Untuk membuat profil di GPU, Anda harus:

  1. Memenuhi driver NVIDIA GPU dan persyaratan CUDA® Toolkit terdaftar di persyaratan dukungan software TensorFlow GPU .
  2. Pastikan Alat NVIDIA® CUDA® Profiling Antarmuka (CUPTI) ada di jalan:

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

Jika Anda tidak memiliki CUPTI di jalan, tambahkan direktori instalasi ke $LD_LIBRARY_PATH variabel lingkungan dengan menjalankan:

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

Kemudian, jalankan ldconfig perintah di atas lagi untuk memverifikasi bahwa perpustakaan CUPTI ditemukan.

Selesaikan masalah hak istimewa

Ketika Anda menjalankan profiling dengan CUDA® Toolkit di lingkungan Docker atau Linux, Anda mungkin mengalami masalah yang berkaitan dengan hak-hak istimewa CUPTI cukup ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ). Pergi ke NVIDIA Docs Pengembang untuk mempelajari lebih lanjut tentang bagaimana Anda dapat mengatasi masalah ini di Linux.

Untuk menyelesaikan masalah hak istimewa CUPTI di lingkungan Docker, jalankan

docker run option '--privileged=true'

Alat profiler

Akses Profiler dari tab Profil di TensorBoard, yang muncul hanya setelah Anda telah menangkap beberapa model data.

Profiler memiliki pilihan alat untuk membantu analisis kinerja:

  • Halaman Ikhtisar
  • Input Pipeline Analyzer
  • Statistik TensorFlow
  • Jejak Penampil
  • Statistik Kernel GPU
  • Alat Profil Memori
  • Penampil Pod

Halaman ikhtisar

Halaman ikhtisar memberikan tampilan tingkat atas tentang performa model Anda selama menjalankan profil. Halaman tersebut menampilkan halaman ikhtisar gabungan untuk host Anda dan semua perangkat, dan beberapa rekomendasi untuk meningkatkan performa pelatihan model Anda. Anda juga dapat memilih masing-masing host di dropdown Host.

Halaman ikhtisar menampilkan data sebagai berikut:

gambar

  • Ringkasan Kinerja: Menampilkan ringkasan tingkat tinggi kinerja model Anda. Ringkasan kinerja memiliki dua bagian:

    1. Rincian langkah-waktu: Mengurai waktu langkah rata-rata menjadi beberapa kategori di mana waktu dihabiskan:

      • Kompilasi: Waktu yang dihabiskan untuk mengkompilasi kernel.
      • Input: Waktu yang dihabiskan untuk membaca data input.
      • Output: Waktu yang dihabiskan untuk membaca data output.
      • Peluncuran kernel: Waktu yang dihabiskan oleh host untuk meluncurkan kernel
      • Waktu komputasi tuan rumah..
      • Waktu komunikasi perangkat-ke-perangkat.
      • Waktu komputasi di perangkat.
      • Semua yang lain, termasuk overhead Python.
    2. Presisi komputasi perangkat - Melaporkan persentase waktu komputasi perangkat yang menggunakan komputasi 16 dan 32-bit.

  • Langkah-time Grafik: Menampilkan grafik waktu perangkat langkah (dalam milidetik) atas semua langkah sampel. Setiap langkah dipecah menjadi beberapa kategori (dengan warna berbeda) di mana waktu dihabiskan. Area merah sesuai dengan porsi waktu langkah perangkat dalam keadaan diam menunggu data input dari host. Area hijau menunjukkan berapa lama perangkat benar-benar berfungsi.

  • Top 10 operasi TensorFlow pada perangkat (misalnya GPU): Menampilkan ops on-perangkat yang berlari paling lama.

    Setiap baris menampilkan waktu mandiri operasi (sebagai persentase waktu yang dibutuhkan oleh semua operasi), waktu kumulatif, kategori, dan nama.

  • Run Lingkungan: Menampilkan ringkasan tingkat tinggi dari lingkungan menjalankan model termasuk:

    • Jumlah host yang digunakan.
    • Jenis perangkat (GPU/TPU).
    • Jumlah inti perangkat.
  • Rekomendasi untuk Langkah Berikutnya: Laporan ketika model adalah masukan terikat dan merekomendasikan peralatan yang dapat Anda gunakan untuk mencari dan kemacetan kinerja model tekad.

Penganalisis pipa masukan

Saat program TensorFlow membaca data dari file, program itu dimulai di bagian atas grafik TensorFlow secara pipelined. Proses read dibagi menjadi beberapa tahapan pengolahan data yang dihubungkan secara seri, dimana output dari satu tahapan menjadi input untuk tahapan berikutnya. Sistem ini data membaca disebut pipa masukan.

Pipa khas untuk membaca catatan dari file memiliki tahapan berikut:

  1. Pembacaan berkas.
  2. Pra-pemrosesan file (opsional).
  3. Transfer file dari host ke perangkat.

Pipeline input yang tidak efisien dapat sangat memperlambat aplikasi Anda. Sebuah aplikasi dianggap masukan terikat ketika menghabiskan sebagian besar waktu di pipa masukan. Gunakan wawasan yang diperoleh dari penganalisis pipa masukan untuk memahami di mana pipa input tidak efisien.

Penganalisa saluran masukan segera memberi tahu Anda apakah program Anda terikat dengan masukan dan memandu Anda melalui analisis sisi perangkat dan host untuk men-debug kemacetan kinerja pada setiap tahap dalam saluran masukan.

Periksa panduan kinerja saluran input untuk praktik terbaik yang direkomendasikan untuk mengoptimalkan saluran input data Anda.

Masukan dasbor pipa

Untuk membuka masukan pipa analyzer, pilih Profil, kemudian pilih input_pipeline_analyzer dari Alat dropdown.

gambar

Dasbor berisi tiga bagian:

  1. Ringkasan: Merangkum pipa masukan secara keseluruhan dengan informasi apakah aplikasi Anda masukan terikat dan, jika demikian, seberapa banyak.
  2. Analisis perangkat-side: Menampilkan rinci, hasil analisis perangkat-sisi, termasuk perangkat langkah-waktu dan rentang waktu perangkat dihabiskan menunggu input data di core pada setiap langkah.
  3. Analisis host-sisi: Acara analisis rinci di sisi tuan rumah, termasuk rincian dari waktu pemrosesan masukan pada host.

Ringkasan saluran masukan

Ringkasan laporan jika program anda adalah masukan terikat dengan menghadirkan persentase waktu perangkat dihabiskan untuk menunggu masukan dari tuan rumah. Jika Anda menggunakan pipa input standar yang telah diinstrumentasi, alat tersebut melaporkan di mana sebagian besar waktu pemrosesan input dihabiskan.

Analisis sisi perangkat

Analisis sisi perangkat memberikan wawasan tentang waktu yang dihabiskan di perangkat versus di host dan berapa banyak waktu perangkat yang dihabiskan untuk menunggu input data dari host.

  1. Langkah waktu diplot terhadap sejumlah langkah: Menampilkan grafik waktu perangkat langkah (dalam milidetik) atas semua langkah sampel. Setiap langkah dipecah menjadi beberapa kategori (dengan warna berbeda) di mana waktu dihabiskan. Area merah sesuai dengan porsi waktu langkah perangkat dalam keadaan diam menunggu data input dari host. Area hijau menunjukkan berapa lama perangkat benar-benar berfungsi.
  2. Waktu statistik langkah: Laporan rata-rata, standar deviasi, dan jangkauan ([minimum, maksimum]) dari waktu perangkat langkah.

Analisis sisi tuan rumah

Analisis host-sisi melaporkan rincian dari waktu pemrosesan input (waktu yang dihabiskan di tf.data API ops) pada host ke dalam beberapa kategori:

  • Membaca data dari file pada permintaan: Waktu yang dihabiskan membaca data dari file tanpa caching, prefetching, dan interleaving.
  • Membaca data dari file di muka: Waktu yang dihabiskan membaca file, termasuk caching, prefetching, dan interleaving.
  • Data preprocessing: Waktu yang dihabiskan di preprocessing ops, seperti dekompresi image.
  • Enqueuing data yang akan ditransfer ke perangkat: Waktu yang dihabiskan memasukkan data ke dalam antrian infeed sebelum mentransfer data ke perangkat.

Bentangkan Masukan Statistik Op untuk memeriksa statistik untuk ops masukan individu dan kategori mereka dipecah oleh waktu eksekusi.

gambar

Tabel data sumber akan muncul dengan setiap entri berisi informasi berikut:

  1. Masukan Op: Shows yang TensorFlow nama op dari input op.
  2. Count: Menunjukkan jumlah total kasus eksekusi op selama periode profiling.
  3. Total Waktu (dalam ms): Menunjukkan jumlah kumulatif dari waktu yang dihabiskan pada masing-masing kasus.
  4. Total Waktu%: Menampilkan total waktu yang dihabiskan pada op sebagai sebagian kecil dari total waktu yang dihabiskan dalam pengolahan masukan.
  5. Jumlah Diri Waktu (dalam ms): Menunjukkan jumlah kumulatif dari waktu diri dihabiskan untuk masing-masing kasus. Waktu mandiri di sini mengukur waktu yang dihabiskan di dalam badan fungsi, tidak termasuk waktu yang dihabiskan dalam fungsi yang dipanggilnya.
  6. Total Waktu Diri%. Menunjukkan total waktu mandiri sebagai bagian dari total waktu yang dihabiskan untuk pemrosesan input.
  7. Kategori. Menunjukkan kategori pemrosesan dari input op.

Statistik TensorFlow

Alat TensorFlow Stats menampilkan kinerja setiap operasi (operasi) TensorFlow yang dijalankan di host atau perangkat selama sesi pembuatan profil.

gambar

Alat ini menampilkan informasi kinerja dalam dua panel:

  • Panel atas menampilkan hingga empat diagram lingkaran:

    1. Distribusi waktu eksekusi sendiri dari setiap operasi pada host.
    2. Distribusi waktu eksekusi sendiri dari setiap jenis op pada host.
    3. Distribusi waktu eksekusi sendiri dari setiap operasi pada perangkat.
    4. Distribusi waktu eksekusi sendiri dari setiap jenis operasi pada perangkat.
  • Panel bawah memperlihatkan tabel yang melaporkan data tentang operasi TensorFlow dengan satu baris untuk setiap operasi dan satu kolom untuk setiap jenis data (urutkan kolom dengan mengklik judul kolom). Klik Ekspor sebagai CSV tombol di sisi kanan panel atas untuk mengekspor data dari tabel ini sebagai file CSV.

    Perhatikan bahwa:

    • Jika ada operasi yang memiliki operasi anak:

      • Total waktu "akumulasi" dari operasi termasuk waktu yang dihabiskan di dalam operasi anak.
      • Total waktu "sendiri" dari operasi tidak termasuk waktu yang dihabiskan di dalam operasi anak.
    • Jika op dijalankan pada Host:

      • Persentase total waktu mandiri pada perangkat yang dikeluarkan oleh operasi akan menjadi 0.
      • Persentase kumulatif dari total waktu mandiri pada perangkat hingga dan termasuk operasi ini akan menjadi 0.
    • Jika op dijalankan pada perangkat:

      • Persentase total waktu mandiri pada host yang dikeluarkan oleh operasi ini akan menjadi 0.
      • Persentase kumulatif dari total waktu mandiri di host hingga dan termasuk operasi ini akan menjadi 0.

Anda dapat memilih untuk menyertakan atau mengecualikan waktu Idle dalam diagram lingkaran dan tabel.

Jejak pemirsa

Penampil jejak menampilkan garis waktu yang menunjukkan:

  • Durasi untuk operasi yang dijalankan oleh model TensorFlow Anda
  • Bagian mana dari sistem (host atau perangkat) yang menjalankan operasi. Biasanya, host mengeksekusi operasi input, mempraproses data pelatihan dan mentransfernya ke perangkat, sementara perangkat menjalankan pelatihan model aktual.

Penampil pelacakan memungkinkan Anda mengidentifikasi masalah kinerja dalam model Anda, lalu mengambil langkah-langkah untuk mengatasinya. Misalnya, pada tingkat tinggi, Anda dapat mengidentifikasi apakah pelatihan input atau model menghabiskan sebagian besar waktu. Menelusuri, Anda dapat mengidentifikasi operasi mana yang membutuhkan waktu paling lama untuk dieksekusi. Perhatikan bahwa penampil pelacakan dibatasi hingga 1 juta peristiwa per perangkat.

Lacak antarmuka penampil

Saat Anda membuka penampil pelacakan, itu akan menampilkan proses terbaru Anda:

gambar

Layar ini berisi elemen utama berikut:

  1. Timeline panel: Menunjukkan ops bahwa perangkat dan host dieksekusi dari waktu ke waktu.
  2. Rincian panel: Menampilkan informasi tambahan untuk ops yang dipilih di panel Timeline.

Panel Timeline berisi elemen berikut:

  1. Top bar: Berisi berbagai kontrol tambahan.
  2. Waktu sumbu: Menampilkan waktu relatif terhadap awal jejak.
  3. Bagian dan track label: Setiap bagian berisi beberapa lagu dan memiliki segitiga di sebelah kiri yang dapat Anda klik untuk memperluas dan runtuh bagian. Ada satu bagian untuk setiap elemen pemrosesan dalam sistem.
  4. Alat pemilih: Berisi berbagai alat untuk berinteraksi dengan pemirsa jejak seperti Zoom, Pan, Pilih, dan Timing. Gunakan alat Waktu untuk menandai interval waktu.
  5. Peristiwa ini menunjukkan waktu selama op dieksekusi atau durasi meta-acara, seperti langkah-langkah pelatihan.
Bagian dan trek

Penampil pelacakan berisi bagian berikut:

  • Satu bagian untuk setiap node perangkat, diberi label dengan jumlah chip perangkat dan node perangkat dalam chip (misalnya, /device:GPU:0 (pid 0) ). Setiap bagian node perangkat berisi trek berikut:
    • Langkah: Menunjukkan durasi langkah-langkah pelatihan yang berjalan pada perangkat
    • TensorFlow Ops: Menunjukkan ops dieksekusi pada perangkat
    • XLA Ops: Shows XLA operasi (ops) yang berlari pada perangkat jika XLA adalah compiler yang digunakan (masing-masing TensorFlow op diterjemahkan ke dalam satu atau beberapa ops XLA The XLA compiler menerjemahkan ops XLA ke dalam kode yang berjalan pada perangkat.).
  • Satu bagian untuk thread yang berjalan pada CPU mesin host, berlabel "host Threads". Bagian ini berisi satu trek untuk setiap utas CPU. Perhatikan bahwa Anda dapat mengabaikan informasi yang ditampilkan di samping label bagian.
Acara

Acara dalam timeline ditampilkan dalam warna yang berbeda; warna itu sendiri tidak memiliki arti khusus.

Penampil pelacakan juga dapat menampilkan jejak panggilan fungsi Python di program TensorFlow Anda. Jika Anda menggunakan tf.profiler.experimental.start API, Anda dapat mengaktifkan Python tracing dengan menggunakan ProfilerOptions namedtuple ketika memulai profiling. Atau, jika Anda menggunakan modus sampling untuk profil, Anda dapat memilih tingkat tracing dengan menggunakan opsi dropdown pada dialog Tangkap Profil.

gambar

Statistik kernel GPU

Alat ini menunjukkan statistik kinerja dan operasi awal untuk setiap kernel yang dipercepat GPU.

gambar

Alat ini menampilkan informasi dalam dua panel:

  • Panel atas menampilkan diagram lingkaran yang memperlihatkan kernel CUDA yang memiliki total waktu tertinggi yang telah berlalu.

  • Panel bawah menampilkan tabel dengan data berikut untuk setiap pasangan kernel-op yang unik:

    • Peringkat dalam urutan menurun dari total durasi GPU yang telah berlalu yang dikelompokkan berdasarkan pasangan kernel-op.
    • Nama kernel yang diluncurkan.
    • Jumlah register GPU yang digunakan oleh kernel.
    • Ukuran total memori bersama (statis + dinamis bersama) yang digunakan dalam byte.
    • Dimensi blok dinyatakan sebagai blockDim.x, blockDim.y, blockDim.z .
    • Dimensi jaringan dinyatakan sebagai gridDim.x, gridDim.y, gridDim.z .
    • Apakah op yang memenuhi syarat untuk menggunakan Tensor Cores .
    • Apakah kernel berisi instruksi Tensor Core.
    • Nama op yang meluncurkan kernel ini.
    • Jumlah kemunculan pasangan kernel-op ini.
    • Total waktu GPU yang telah berlalu dalam mikrodetik.
    • Rata-rata waktu GPU yang telah berlalu dalam mikrodetik.
    • Waktu GPU minimum yang telah berlalu dalam mikrodetik.
    • Waktu GPU maksimum yang telah berlalu dalam mikrodetik.

Alat profil memori

Memory Profile alat monitor penggunaan memori perangkat Anda selama interval profiling. Anda dapat menggunakan alat ini untuk:

  • Debug masalah kehabisan memori (OOM) dengan menunjukkan penggunaan memori puncak dan alokasi memori yang sesuai untuk operasi TensorFlow. Anda juga dapat men-debug masalah OOM yang mungkin timbul ketika Anda menjalankan multi-tenancy inferensi.
  • Debug masalah fragmentasi memori.

Alat profil memori menampilkan data dalam tiga bagian:

  1. Ringkasan Profil Memori
  2. Grafik Garis Waktu Memori
  3. Tabel Kerusakan Memori

Ringkasan profil memori

Bagian ini menampilkan ringkasan tingkat tinggi dari profil memori program TensorFlow Anda seperti yang ditunjukkan di bawah ini:

Ringkasan profil memori memiliki enam bidang:

  1. Memori ID: Dropdown yang berisi semua sistem memori perangkat yang tersedia. Pilih sistem memori yang ingin Anda lihat dari dropdown.
  2. #Allocation: Jumlah alokasi memori yang dilakukan selama interval profiling.
  3. #Deallocation: Jumlah deallocations memori dalam interval profil
  4. Kapasitas Memory: Total kapasitas (di gibs) dari sistem memori yang Anda pilih.
  5. Puncak Heap Penggunaan: Penggunaan memori puncak (di gibs) karena model mulai berjalan.
  6. Puncak Memory Usage: Penggunaan memori puncak (di gibs) dalam interval profiling. Bidang ini berisi sub-bidang berikut:
    1. Timestamp: The timestamp ketika penggunaan memori puncak terjadi pada Timeline Grafik.
    2. Stack Reservation: Jumlah memori dicadangkan pada stack (di gibs).
    3. Alokasi Heap: Jumlah memori yang dialokasikan pada heap (di gibs).
    4. Gratis Memory: Jumlah memori bebas (di gibs). Kapasitas Memori adalah jumlah total dari Reservasi Stack, Alokasi Heap, dan Memori Bebas.
    5. Fragmentasi: Persentase fragmentasi (lebih rendah lebih baik). Hal ini dihitung sebagai persentase dari (1 - Size of the largest chunk of free memory / Total free memory) .

Grafik garis waktu memori

Bagian ini menampilkan plot penggunaan memori (dalam GiB) dan persentase fragmentasi terhadap waktu (dalam ms).

gambar

Sumbu X mewakili garis waktu (dalam ms) dari interval pembuatan profil. Sumbu Y di sebelah kiri mewakili penggunaan memori (dalam GiBs) dan sumbu Y di sebelah kanan mewakili persentase fragmentasi. Pada setiap titik waktu pada sumbu X, total memori dipecah menjadi tiga kategori: tumpukan (berwarna merah), heap (berwarna oranye), dan bebas (berwarna hijau). Arahkan kursor ke stempel waktu tertentu untuk melihat detail tentang acara alokasi/dealokasi memori pada saat itu seperti di bawah ini:

gambar

Jendela pop-up menampilkan informasi berikut:

  • timestamp (ms): Lokasi acara yang dipilih pada timeline.
  • Acara: Jenis acara (alokasi atau dealokasi).
  • requested_size (Gibs): Jumlah memori yang diminta. Ini akan menjadi angka negatif untuk peristiwa deallokasi.
  • allocation_size (Gibs): Jumlah aktual memori yang dialokasikan. Ini akan menjadi angka negatif untuk peristiwa deallokasi.
  • tf_op: The TensorFlow op yang meminta alokasi / dealokasi.
  • step_id: Langkah pelatihan di mana peristiwa ini terjadi.
  • REGION_TYPE: Entitas Data jenis yang memori yang dialokasikan ini adalah untuk. Nilai yang mungkin adalah temp untuk temporaries, output untuk aktivasi dan gradien, dan persist / dynamic untuk bobot dan konstanta.
  • data_type: Jenis tensor elemen (misalnya, uint8 untuk 8-bit unsigned integer).
  • tensor_shape: Bentuk tensor yang sedang dialokasikan / deallocated.
  • memory_in_use (Gibs): Total memori yang digunakan pada saat ini waktu.

Tabel kerusakan memori

Tabel ini menunjukkan alokasi memori aktif pada titik penggunaan memori puncak dalam interval pembuatan profil.

gambar

Ada satu baris untuk setiap TensorFlow Op dan setiap baris memiliki kolom berikut:

  • Nama op: Nama TensorFlow op.
  • Ukuran alokasi (Gibs): Jumlah total memori yang dialokasikan untuk op ini.
  • Diminta Ukuran (Gibs): Jumlah total memori yang diminta untuk op ini.
  • Kemunculan: Jumlah alokasi untuk op ini.
  • Tipe wilayah: Tipe entitas data yang memori yang dialokasikan ini adalah untuk. Nilai yang mungkin adalah temp untuk temporaries, output untuk aktivasi dan gradien, dan persist / dynamic untuk bobot dan konstanta.
  • Jenis data: Jenis tensor elemen.
  • Bentuk: Bentuk tensor dialokasikan.

Penampil pod

Alat Pod Viewer menunjukkan rincian langkah pelatihan di semua pekerja.

gambar

  • Panel atas memiliki penggeser untuk memilih nomor langkah.
  • Panel bawah menampilkan bagan kolom bertumpuk. Ini adalah tampilan tingkat tinggi dari kategori langkah-waktu yang dipecah yang ditempatkan di atas satu sama lain. Setiap kolom bertumpuk mewakili pekerja unik.
  • Saat Anda mengarahkan kursor ke kolom bertumpuk, kartu di sisi kiri menampilkan detail selengkapnya tentang perincian langkah.

tf.analisis kemacetan data

The tf.data alat analisis bottleneck secara otomatis mendeteksi kemacetan di tf.data pipa masukan dalam program Anda dan memberikan rekomendasi tentang bagaimana untuk memperbaikinya. Ia bekerja dengan program menggunakan tf.data terlepas dari platform (CPU / GPU / TPU). Analisis dan rekomendasi yang didasarkan pada ini panduan .

Ini mendeteksi kemacetan dengan mengikuti langkah-langkah ini:

  1. Temukan host terikat input paling banyak.
  2. Cari eksekusi paling lambat dari tf.data pipa masukan.
  3. Rekonstruksi grafik saluran input dari jejak profiler.
  4. Temukan jalur kritis dalam grafik pipa input.
  5. Identifikasi transformasi paling lambat pada jalur kritis sebagai hambatan.

UI dibagi menjadi tiga bagian: Analisis Kinerja Ringkasan, Ringkasan Semua Masukan Pipa dan Input Pipeline Grafik.

Ringkasan analisis kinerja

gambar

Bagian ini memberikan ringkasan analisis. Ini melaporkan lambat tf.data pipa masukan terdeteksi dalam profil. Bagian ini juga menunjukkan host yang terikat input paling banyak dan pipeline input paling lambat dengan latensi maksimal. Yang terpenting, ini mengidentifikasi bagian pipa input mana yang menjadi hambatan dan cara memperbaikinya. Informasi bottleneck disediakan dengan tipe iterator dan nama panjangnya.

Cara membaca nama panjang tf.data iterator

Sebuah nama yang panjang diformat sebagai Iterator::<Dataset_1>::...::<Dataset_n> . Dalam nama panjang, <Dataset_n> cocok dengan jenis iterator dan dataset lainnya atas nama panjang mewakili transformasi hilir.

Misalnya, pertimbangkan kumpulan data saluran input berikut:

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

Nama panjang untuk iterator dari dataset di atas adalah:

Tipe Iterator Nama panjang
Jangkauan Iterator::Batch::Ulangi::Peta::Rentang
Peta Iterator::Batch::Ulangi::Peta
Mengulang Iterator::Batch::Ulangi
Kelompok Iterator::Batch

Ringkasan semua saluran input

gambar

Bagian ini memberikan ringkasan semua saluran input di semua host. Biasanya ada satu pipa input. Bila menggunakan strategi distribusi, ada satu pipa masukan host menjalankan program tf.data kode dan beberapa pipa masukan perangkat mengambil data dari pipa masukan host dan mentransfer ke perangkat.

Untuk setiap pipa input, ini menunjukkan statistik waktu eksekusinya. Panggilan dianggap lambat jika membutuhkan waktu lebih dari 50 s.

Grafik pipa masukan

gambar

Bagian ini menunjukkan grafik pipa input dengan informasi waktu eksekusi. Anda dapat menggunakan "Host" dan "Input Pipeline" untuk memilih host dan saluran input mana yang akan dilihat. Eksekusi dari pipa masukan diurutkan menurut waktu eksekusi dalam urutan yang dapat anda pilih menggunakan dropdown Rank.

gambar

Node di jalur kritis memiliki garis tebal. Node bottleneck, yang merupakan node dengan self time terpanjang pada jalur kritis, memiliki garis merah. Node non-kritis lainnya memiliki garis putus-putus abu-abu.

Pada setiap node, Start Time menunjukkan waktu mulai dari eksekusi. Node yang sama dapat dilaksanakan beberapa kali, misalnya, jika ada Batch op dalam pipa masukan. Jika dieksekusi beberapa kali, itu adalah waktu mulai dari eksekusi pertama.

Total Durasi adalah waktu dinding eksekusi. Jika dieksekusi beberapa kali, itu adalah jumlah waktu dinding dari semua eksekusi.

Diri Waktu adalah Total Waktu tanpa waktu tumpang tindih dengan node anak langsung nya.

"# Panggilan" adalah berapa kali pipa input dieksekusi.

Kumpulkan data kinerja

TensorFlow Profiler mengumpulkan aktivitas host dan jejak GPU model TensorFlow Anda. Anda dapat mengonfigurasi Profiler untuk mengumpulkan data kinerja melalui mode terprogram atau mode pengambilan sampel.

Memprofilkan API

Anda dapat menggunakan API berikut untuk melakukan pembuatan profil.

  • Modus program menggunakan TensorBoard Keras Callback ( 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])
    
  • Modus program menggunakan tf.profiler Fungsi API

    tf.profiler.experimental.start('logdir')
    # Train the model here
    tf.profiler.experimental.stop()
    
  • Mode terprogram menggunakan pengelola konteks

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

  • Modus Sampling: Lakukan on-demand profil dengan menggunakan tf.profiler.experimental.server.start untuk memulai server gRPC dengan model yang TensorFlow Anda berjalan. Setelah memulai server gRPC dan menjalankan model Anda, Anda dapat menangkap profil melalui Tangkap Profil tombol di plugin profil TensorBoard. Gunakan skrip di bagian Instal profiler di atas untuk meluncurkan instans TensorBoard jika belum berjalan.

    Sebagai contoh,

    # 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)
    

    Contoh untuk membuat profil beberapa pekerja:

    # 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)
    

Gunakan dialog Tangkap Profil untuk menentukan:

  • Daftar URL layanan profil atau nama TPU yang dipisahkan koma.
  • Durasi pembuatan profil.
  • Tingkat pelacakan panggilan fungsi perangkat, host, dan Python.
  • Berapa kali Anda ingin Profiler mencoba lagi mengambil profil jika awalnya tidak berhasil.

Membuat profil loop pelatihan khusus

Untuk profil loop pelatihan khusus dalam kode TensorFlow Anda, instrumen loop pelatihan dengan tf.profiler.experimental.Trace API untuk menandai batas-batas langkah untuk Profiler.

The name argumen yang digunakan sebagai awalan untuk nama-nama langkah, step_num kata kunci argumen ditambahkan pada nama langkah, dan _r argumen kata kunci membuat acara jejak ini diproses sebagai event langkah oleh Profiler.

Sebagai contoh,

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)

Ini akan mengaktifkan analisis kinerja berbasis langkah Profiler dan menyebabkan peristiwa langkah muncul di penampil pelacakan.

Pastikan bahwa Anda menyertakan iterator dataset dalam tf.profiler.experimental.Trace konteks untuk analisis akurat dari pipa masukan.

Cuplikan kode di bawah ini adalah anti-pola:

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

Membuat profil kasus penggunaan

Profiler mencakup sejumlah kasus penggunaan di sepanjang empat sumbu yang berbeda. Beberapa kombinasi saat ini didukung dan lainnya akan ditambahkan di masa mendatang. Beberapa kasus penggunaan adalah:

  • Vs lokal terpencil profil: Ini adalah dua cara umum pengaturan lingkungan profil Anda. Dalam pembuatan profil lokal, API pembuatan profil dipanggil pada mesin yang sama dengan yang dijalankan model Anda, misalnya, workstation lokal dengan GPU. Dalam pembuatan profil jarak jauh, API pembuatan profil dipanggil pada mesin yang berbeda dari tempat model Anda dieksekusi, misalnya, pada Cloud TPU.
  • Profil beberapa pekerja: Anda dapat profil beberapa mesin ketika menggunakan kemampuan pelatihan didistribusikan TensorFlow.
  • Platform perangkat keras: CPU Profil, GPU, dan TPUs.

Tabel di bawah ini memberikan ikhtisar singkat tentang kasus penggunaan yang didukung TensorFlow yang disebutkan di atas:

API Profil Lokal Terpencil Banyak pekerja Platform Perangkat Keras
Panggilan Balik TensorBoard Keras Didukung Tidak didukung Tidak didukung CPU, GPU
tf.profiler.experimental start / stop API Didukung Tidak didukung Tidak didukung CPU, GPU
tf.profiler.experimental client.trace API Didukung Didukung Didukung CPU, GPU, TPU
API pengelola konteks Didukung Tidak didukung Tidak didukung CPU, GPU

Praktik terbaik untuk performa model yang optimal

Gunakan rekomendasi berikut sebagaimana berlaku untuk model TensorFlow Anda untuk mencapai kinerja yang optimal.

Secara umum, lakukan semua transformasi pada perangkat dan pastikan Anda menggunakan versi perpustakaan terbaru yang kompatibel seperti cuDNN dan Intel MKL untuk platform Anda.

Optimalkan pipa data input

Gunakan data dari [#input_pipeline_analyzer] untuk mengoptimalkan jalur input data Anda. Pipeline input data yang efisien dapat secara drastis meningkatkan kecepatan eksekusi model Anda dengan mengurangi waktu idle perangkat. Cobalah untuk menggabungkan praktek-praktek terbaik rinci dalam kinerja yang lebih baik dengan tf.data API panduan dan bawah untuk membuat pipa input data Anda lebih efisien.

  • Secara umum, memparalelkan operasi apa pun yang tidak perlu dieksekusi secara berurutan dapat mengoptimalkan jalur input data secara signifikan.

  • Dalam banyak kasus, ada baiknya mengubah urutan beberapa panggilan atau menyetel argumen sedemikian rupa sehingga berfungsi paling baik untuk model Anda. Saat mengoptimalkan jalur pipa data input, tolok ukur hanya pemuat data tanpa langkah pelatihan dan propagasi balik untuk mengukur efek pengoptimalan secara mandiri.

  • Coba jalankan model Anda dengan data sintetis untuk memeriksa apakah pipeline input merupakan hambatan kinerja.

  • Gunakan tf.data.Dataset.shard untuk pelatihan multi-GPU. Pastikan Anda melakukan sharding sejak awal dalam loop input untuk mencegah pengurangan throughput. Saat bekerja dengan TFRecords, pastikan Anda memisahkan daftar TFRecords dan bukan konten TFRecords.

  • Memparalelkan beberapa ops dengan dinamis menetapkan nilai num_parallel_calls menggunakan tf.data.AUTOTUNE .

  • Mempertimbangkan membatasi penggunaan tf.data.Dataset.from_generator seperti yang lambat dibandingkan dengan ops TensorFlow murni.

  • Mempertimbangkan membatasi penggunaan tf.py_function karena tidak dapat serial dan tidak didukung untuk berjalan dalam TensorFlow didistribusikan.

  • Gunakan tf.data.Options untuk mengontrol optimasi statis untuk pipa masukan.

Juga membaca tf.data analisis kinerja panduan untuk panduan lebih lanjut tentang mengoptimalkan pipa masukan Anda.

Optimalkan augmentasi data

Ketika bekerja dengan data gambar, membuat Anda Data pembesaran lebih efisien dengan casting untuk tipe data yang berbeda setelah menerapkan transformasi spasial, seperti flipping, cropping, memutar, dll

Gunakan NVIDIA® DALI

Dalam beberapa kasus, seperti ketika Anda memiliki sistem dengan rasio GPU terhadap CPU yang tinggi, semua pengoptimalan di atas mungkin tidak cukup untuk menghilangkan kemacetan pada pemuat data yang disebabkan karena keterbatasan siklus CPU.

Jika Anda menggunakan NVIDIA® GPU untuk visi komputer dan aplikasi pembelajaran audio yang mendalam, pertimbangkan menggunakan data Memuat Perpustakaan ( DALI ) untuk mempercepat pipa data.

Periksa NVIDIA® DALI: Operasi dokumentasi untuk daftar didukung ops DALI.

Gunakan threading dan eksekusi paralel

Jalankan ops di beberapa thread CPU dengan tf.config.threading API untuk mengeksekusi mereka lebih cepat.

TensorFlow secara otomatis menyetel jumlah utas paralelisme secara default. Kumpulan utas yang tersedia untuk menjalankan operasi TensorFlow bergantung pada jumlah utas CPU yang tersedia.

Mengontrol speedup paralel maksimum untuk op tunggal dengan menggunakan tf.config.threading.set_intra_op_parallelism_threads . Perhatikan bahwa jika Anda menjalankan beberapa operasi secara paralel, mereka semua akan berbagi kumpulan utas yang tersedia.

Jika Anda memiliki independen non-blocking ops (ops tanpa jalur diarahkan antara mereka pada grafik), penggunaan tf.config.threading.set_inter_op_parallelism_threads untuk menjalankannya secara bersamaan menggunakan tersedia kolam thread.

Aneka ragam

Ketika bekerja dengan model yang lebih kecil pada NVIDIA® GPU, Anda dapat mengatur tf.compat.v1.ConfigProto.force_gpu_compatible=True untuk memaksa semua tensor CPU akan dialokasikan dengan CUDA memori disematkan untuk memberikan dorongan signifikan terhadap kinerja model. Namun, berhati-hatilah saat menggunakan opsi ini untuk model yang tidak diketahui/sangat besar karena ini dapat berdampak negatif pada kinerja host (CPU).

Tingkatkan kinerja perangkat

Ikuti praktik terbaik rinci di sini dan di panduan optimasi kinerja GPU untuk mengoptimalkan model yang TensorFlow kinerja pada perangkat.

Jika Anda menggunakan GPU NVIDIA, catat penggunaan GPU dan memori ke file CSV dengan menjalankan:

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

Konfigurasikan tata letak data

Saat bekerja dengan data yang berisi informasi saluran (seperti gambar), optimalkan format tata letak data untuk memilih saluran terakhir (NHWC daripada NCHW).

Format data saluran-terakhir meningkatkan Tensor Inti pemanfaatan dan memberikan peningkatan kinerja yang signifikan terutama di model convolutional ketika digabungkan dengan AMP. Tata letak data NCHW masih dapat dioperasikan oleh Tensor Cores, tetapi memperkenalkan overhead tambahan karena operasi transpos otomatis.

Anda dapat mengoptimalkan tata letak data yang lebih suka layout NHWC dengan menetapkan data_format="channels_last" untuk lapisan seperti tf.keras.layers.Conv2D , tf.keras.layers.Conv3D , dan tf.keras.layers.RandomRotation .

Gunakan tf.keras.backend.set_image_data_format untuk mengatur default format yang tata letak data untuk Keras backend API.

Maksimalkan cache L2

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.

Miscellaneous

  • 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