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 membuat profil performa model Anda di Cloud TPU, lihat panduan Cloud TPU .

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. Penuhi persyaratan driver NVIDIA® GPU dan CUDA® Toolkit yang tercantum pada persyaratan perangkat lunak dukungan GPU TensorFlow .

  2. Pastikan NVIDIA® CUDA® Profiling Tools Interface (CUPTI) ada di jalur:

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

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

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

Kemudian, jalankan kembali perintah ldconfig di atas untuk memverifikasi bahwa pustaka CUPTI ditemukan.

Selesaikan masalah hak istimewa

Saat Anda menjalankan pembuatan profil dengan CUDA® Toolkit di lingkungan Docker atau di Linux, Anda mungkin mengalami masalah terkait dengan hak istimewa CUPTI yang tidak mencukupi ( CUPTI_ERROR_INSUFFICIENT_PRIVILEGES ). Buka NVIDIA Developer Docs 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 hanya muncul setelah Anda mengambil beberapa data model.

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 dan semua perangkat Anda, 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 dari kinerja model Anda. Ringkasan kinerja memiliki dua bagian:

    1. Perincian 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.

  • Grafik Langkah-waktu : Menampilkan grafik waktu langkah perangkat (dalam milidetik) untuk semua langkah yang diambil sampelnya. 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.

  • 10 operasi TensorFlow teratas pada perangkat (misalnya GPU) : Menampilkan operasi pada perangkat yang berjalan paling lama.

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

  • Run Environment : Menampilkan ringkasan tingkat tinggi dari model run environment termasuk:

    • Jumlah host yang digunakan.
    • Jenis perangkat (GPU/TPU).
    • Jumlah inti perangkat.

  • Rekomendasi untuk Langkah Berikutnya : Melaporkan saat model terikat input dan merekomendasikan alat yang dapat Anda gunakan untuk menemukan dan mengatasi kemacetan kinerja model.

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 pembacaan data ini disebut pipa input .

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 sebagai input terikat ketika menghabiskan sebagian besar waktu dalam pipa input. 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 penganalisis pipa input, pilih Profile , lalu pilih input_pipeline_analyzer dari dropdown Tools .

gambar

Dasbor berisi tiga bagian:

  1. Ringkasan : Meringkas keseluruhan saluran input dengan informasi tentang apakah aplikasi Anda terikat input dan, jika demikian, seberapa banyak.
  2. Analisis sisi perangkat : Menampilkan hasil analisis sisi perangkat yang terperinci, termasuk waktu langkah perangkat dan rentang waktu perangkat yang dihabiskan untuk menunggu data input lintas inti pada setiap langkah.
  3. Analisis sisi host : Menampilkan analisis rinci di sisi host, termasuk perincian waktu pemrosesan input di host.

Ringkasan saluran masukan

Ringkasan melaporkan jika program Anda terikat dengan input dengan menyajikan persentase waktu perangkat yang dihabiskan untuk menunggu input dari host. 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. Waktu langkah diplot terhadap nomor langkah : Menampilkan grafik waktu langkah perangkat (dalam milidetik) untuk semua langkah yang diambil sampelnya. 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. Statistik waktu langkah : Melaporkan rata-rata, simpangan baku, dan rentang ([minimum, maksimum]) waktu langkah perangkat.

Analisis sisi tuan rumah

Analisis sisi host melaporkan perincian waktu pemrosesan input (waktu yang dihabiskan untuk tf.data API) di host ke dalam beberapa kategori:

  • Membaca data dari file sesuai permintaan : Waktu yang dihabiskan untuk membaca data dari file tanpa caching, prefetching, dan interleaving.
  • Membaca data dari file sebelumnya : Waktu yang dihabiskan untuk membaca file, termasuk caching, prefetching, dan interleaving.
  • Prapemrosesan data : Waktu yang dihabiskan untuk operasi prapemrosesan, seperti dekompresi gambar.
  • Mengantrekan data yang akan ditransfer ke perangkat : Waktu yang dihabiskan untuk memasukkan data ke dalam antrean umpan sebelum mentransfer data ke perangkat.

Perluas Statistik Operasi Input untuk memeriksa statistik operasi input individual dan kategorinya yang dikelompokkan berdasarkan waktu eksekusi.

gambar

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

  1. Input Op : Menampilkan nama op TensorFlow dari input op.
  2. Hitungan : Menunjukkan jumlah total contoh eksekusi operasi selama periode pembuatan profil.
  3. Total Waktu (dalam md) : Menampilkan jumlah kumulatif waktu yang dihabiskan untuk setiap instans tersebut.
  4. Total Time % : Menampilkan total waktu yang dihabiskan pada operasi sebagai bagian dari total waktu yang dihabiskan dalam pemrosesan input.
  5. Total Self Time (dalam md) : Menampilkan jumlah kumulatif dari waktu mandiri yang dihabiskan untuk masing-masing instans tersebut. Waktu mandiri di sini mengukur waktu yang dihabiskan di dalam badan fungsi, tidak termasuk waktu yang dihabiskan dalam fungsi yang dipanggilnya.
  6. Total Waktu Sendiri % . 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 tombol Ekspor sebagai CSV 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. Panel garis waktu : Menunjukkan operasi yang dijalankan perangkat dan host dari waktu ke waktu.
  2. Panel detail : Menampilkan informasi tambahan untuk operasi yang dipilih di panel Timeline.

Panel Timeline berisi elemen berikut:

  1. Bilah atas : Berisi berbagai kontrol tambahan.
  2. Sumbu waktu : Menunjukkan waktu relatif terhadap awal jejak.
  3. Label bagian dan trek : Setiap bagian berisi beberapa trek dan memiliki segitiga di sebelah kiri yang dapat Anda klik untuk meluaskan dan menciutkan bagian. Ada satu bagian untuk setiap elemen pemrosesan dalam sistem.
  4. Pemilih alat : Berisi berbagai alat untuk berinteraksi dengan penampil jejak seperti Zoom, Pan, Select, dan Timing. Gunakan alat Waktu untuk menandai interval waktu.
  5. Events : Ini menunjukkan waktu selama op dieksekusi atau durasi meta-event, seperti langkah-langkah pelatihan.
Bagian dan trek

Penampil pelacakan berisi bagian berikut:

  • Satu bagian untuk setiap node perangkat , diberi label dengan nomor chip perangkat dan node perangkat di dalam chip (misalnya, /device:GPU:0 (pid 0) ). Setiap bagian node perangkat berisi trek berikut:
    • Langkah : Menunjukkan durasi langkah-langkah pelatihan yang berjalan di perangkat
    • TensorFlow Ops : Menampilkan operasi yang dijalankan pada perangkat
    • XLA Ops : Menampilkan operasi XLA (ops) yang berjalan pada perangkat jika XLA adalah compiler yang digunakan (setiap operasi TensorFlow diterjemahkan ke dalam satu atau beberapa operasi XLA. Compiler XLA menerjemahkan operasi XLA ke dalam kode yang berjalan pada perangkat).
  • Satu bagian untuk utas yang berjalan pada CPU mesin host, berlabel "Utas Host" . 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 pelacakan Python dengan menggunakan tuple bernama ProfilerOptions saat memulai pembuatan profil. Atau, jika Anda menggunakan mode pengambilan sampel untuk pembuatan profil, Anda dapat memilih tingkat penelusuran dengan menggunakan opsi tarik-turun dalam 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 grid dinyatakan sebagai gridDim.x, gridDim.y, gridDim.z .
    • Apakah operasi 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

Alat Profil Memori memantau penggunaan memori perangkat Anda selama interval pembuatan profil. 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 muncul saat Anda menjalankan inferensi multi-penyewaan .
  • 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. ID Memori : Dropdown yang mencantumkan semua sistem memori perangkat yang tersedia. Pilih sistem memori yang ingin Anda lihat dari dropdown.
  2. #Allocation : Jumlah alokasi memori yang dibuat selama interval pembuatan profil.
  3. #Deallocation : Jumlah alokasi memori dalam interval pembuatan profil
  4. Kapasitas Memori : Kapasitas total (dalam GiB) sistem memori yang Anda pilih.
  5. Peak Heap Usage : Penggunaan memori puncak (dalam GiB) sejak model mulai berjalan.
  6. Penggunaan Memori Puncak : Penggunaan memori puncak (dalam GiB) dalam interval pembuatan profil. Bidang ini berisi sub-bidang berikut:
    1. Stempel Waktu : Stempel waktu saat penggunaan memori puncak terjadi pada Grafik Garis Waktu.
    2. Reservasi Stack : Jumlah memori yang dicadangkan pada stack (dalam GiB).
    3. Alokasi Heap : Jumlah memori yang dialokasikan pada heap (dalam GiB).
    4. Memori Bebas : Jumlah memori bebas (dalam GiB). Kapasitas Memori adalah jumlah total dari Reservasi Stack, Alokasi Heap, dan Memori Bebas.
    5. Fragmentasi : Persentase fragmentasi (lebih rendah lebih baik). Ini dihitung sebagai persentase (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.
  • event : Jenis event (allocation atau deallocation).
  • request_size(GiBs) : Jumlah memori yang diminta. Ini akan menjadi angka negatif untuk peristiwa deallokasi.
  • alokasi_size(GiBs) : Jumlah sebenarnya dari memori yang dialokasikan. Ini akan menjadi angka negatif untuk peristiwa deallokasi.
  • tf_op : Operasi TensorFlow yang meminta alokasi/dealokasi.
  • step_id : Langkah pelatihan di mana peristiwa ini terjadi.
  • region_type : Tipe entitas data untuk memori yang dialokasikan ini. Nilai yang mungkin adalah temp untuk sementara, output untuk aktivasi dan gradien, dan persist / dynamic untuk bobot dan konstanta.
  • data_type : Jenis elemen tensor (misalnya, uint8 untuk bilangan bulat tidak bertanda 8-bit).
  • tensor_shape : Bentuk tensor yang dialokasikan/dialokasikan.
  • memory_in_use(GiBs) : Total memori yang digunakan saat ini.

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 Operasi : Nama operasi TensorFlow.
  • Ukuran Alokasi (GiBs) : Jumlah total memori yang dialokasikan untuk operasi ini.
  • Ukuran yang Diminta (GiBs) : Jumlah total memori yang diminta untuk operasi ini.
  • Kemunculan : Jumlah alokasi untuk operasi ini.
  • Tipe wilayah : Tipe entitas data untuk memori yang dialokasikan ini. Nilai yang mungkin adalah temp untuk sementara, output untuk aktivasi dan gradien, dan persist / dynamic untuk bobot dan konstanta.
  • Tipe data : Tipe elemen tensor.
  • Bentuk : Bentuk tensor yang 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

Alat analisis bottleneck tf.data secara otomatis mendeteksi kemacetan di saluran input tf.data di program Anda dan memberikan rekomendasi tentang cara memperbaikinya. Ia bekerja dengan program apa pun yang menggunakan tf.data terlepas dari platformnya (CPU/GPU/TPU). Analisis dan rekomendasinya didasarkan pada panduan ini.

Ini mendeteksi kemacetan dengan mengikuti langkah-langkah ini:

  1. Temukan host terikat input paling banyak.
  2. Temukan eksekusi paling lambat dari pipeline input tf.data .
  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: Ringkasan Analisis Kinerja , Ringkasan Semua Pipa Input dan Grafik Pipa Input .

Ringkasan analisis kinerja

gambar

Bagian ini memberikan ringkasan analisis. Ini melaporkan saluran input tf.data lambat yang terdeteksi di 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

Nama panjang diformat sebagai Iterator::<Dataset_1>::...::<Dataset_n> . Dalam nama panjang, <Dataset_n> cocok dengan tipe iterator dan kumpulan data lainnya dalam 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
Ulang 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. Saat menggunakan strategi distribusi, ada satu jalur input host yang menjalankan kode tf.data program dan beberapa jalur input perangkat mengambil data dari jalur input host dan mentransfernya 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 pipa input diurutkan berdasarkan waktu eksekusi dalam urutan menurun yang dapat Anda pilih menggunakan dropdown Peringkat .

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.

Di setiap node, Start Time menunjukkan waktu mulai eksekusi. Node yang sama dapat dieksekusi beberapa kali, misalnya, jika ada operasi Batch di pipa input. Jika dieksekusi beberapa kali, itu adalah waktu mulai dari eksekusi pertama.

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

Self Time adalah Waktu Total tanpa waktu yang tumpang tindih dengan node anak langsungnya.

"# 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.

  • Mode terprogram 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])

  • Mode terprogram menggunakan tf.profiler Function 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

  • Mode pengambilan sampel: Lakukan pembuatan profil sesuai permintaan dengan menggunakan tf.profiler.experimental.server.start untuk memulai server gRPC dengan menjalankan model TensorFlow Anda. Setelah memulai server gRPC dan menjalankan model, Anda dapat mengambil profil melalui tombol Tangkap Profil 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 Capture Profile 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 membuat profil loop pelatihan khusus dalam kode TensorFlow Anda, lengkapi loop pelatihan dengan tf.profiler.experimental.Trace API untuk menandai batas langkah untuk Profiler.

Argumen name digunakan sebagai awalan untuk nama langkah, argumen kata kunci step_num ditambahkan dalam nama langkah, dan argumen kata kunci _r membuat peristiwa jejak ini diproses sebagai peristiwa 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 Anda menyertakan iterator set data dalam konteks tf.profiler.experimental.Trace untuk analisis yang akurat dari pipeline input.

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:

  • Pembuatan profil lokal vs. jarak jauh : Ini adalah dua cara umum untuk menyiapkan lingkungan pembuatan 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.
  • Membuat profil beberapa pekerja : Anda dapat membuat profil beberapa mesin saat menggunakan kemampuan pelatihan terdistribusi dari TensorFlow.
  • Platform perangkat keras : Profil CPU, GPU, dan TPU.

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 praktik terbaik yang dirinci dalam Performa yang lebih baik dengan panduan API tf.data dan di bawah ini untuk membuat jalur 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 pipeline data input, tolok ukur hanya pemuat data tanpa langkah pelatihan dan backpropagation 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.

  • Paralelkan beberapa operasi dengan mengatur nilai num_parallel_calls secara dinamis menggunakan tf.data.AUTOTUNE .

  • Pertimbangkan untuk membatasi penggunaan tf.data.Dataset.from_generator karena lebih lambat dibandingkan dengan operasi TensorFlow murni.

  • Pertimbangkan untuk membatasi penggunaan tf.py_function karena tidak dapat diserialisasi dan tidak didukung untuk berjalan di TensorFlow terdistribusi.

  • Gunakan tf.data.Options untuk mengontrol pengoptimalan statis ke saluran input.

Baca juga panduan analisis kinerja tf.data untuk panduan lebih lanjut tentang mengoptimalkan saluran input Anda.

Optimalkan augmentasi data

Saat bekerja dengan data gambar, buat augmentasi data Anda lebih efisien dengan mentransmisikan ke tipe data yang berbeda setelah menerapkan transformasi spasial, seperti membalik, memotong, 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 GPU NVIDIA® untuk visi komputer dan aplikasi pembelajaran mendalam audio, pertimbangkan untuk menggunakan Data Loading Library ( DALI ) untuk mempercepat jalur data.

Periksa NVIDIA® DALI: Dokumentasi operasi untuk daftar operasi DALI yang didukung.

Gunakan threading dan eksekusi paralel

Jalankan operasi pada beberapa utas CPU dengan tf.config.threading API untuk menjalankannya 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.

Kontrol kecepatan paralel maksimum untuk operasi 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 operasi non-pemblokiran independen (ops tanpa jalur terarah di antara mereka pada grafik), gunakan tf.config.threading.set_inter_op_parallelism_threads untuk menjalankannya secara bersamaan menggunakan kumpulan utas yang tersedia.

Aneka ragam

Saat bekerja dengan model yang lebih kecil pada GPU NVIDIA®, Anda dapat mengatur tf.compat.v1.ConfigProto.force_gpu_compatible=True untuk memaksa semua tensor CPU dialokasikan dengan memori yang disematkan CUDA untuk memberikan peningkatan yang signifikan pada 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 yang dirinci di sini dan di panduan pengoptimalan performa GPU untuk mengoptimalkan performa model TensorFlow di 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 pemanfaatan Tensor Core dan memberikan peningkatan kinerja yang signifikan terutama dalam model konvolusi saat 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 untuk memilih tata letak NHWC dengan mengatur 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 menyetel format tata letak data default untuk API backend Keras.

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