Bagaimana cara menghitung dampak memori batch mini saat melatih model pembelajaran yang mendalam?

Saya mencoba menghitung jumlah memori yang dibutuhkan oleh GPU untuk melatih model saya berdasarkan catatan dari Andrej Karphaty: http://cs231n.github.io/convolutional-networks/#computational-considerations

Jaringan saya memiliki 532.752 aktivasi dan 19.072.984 parameter (bobot dan bias). Ini semua adalah nilai float 32 bit, sehingga masing-masing membutuhkan 4 byte dalam memori.

Gambar input saya adalah 180x50x1 (lebar x tinggi x kedalaman) = 9.000 float 32 nilai. Saya tidak menggunakan augmentasi gambar, jadi saya pikir memori lain-lain hanya akan terkait dengan ukuran mini-batch. Saya menggunakan ukuran mini-batch 128 gambar.

Berdasarkan rekomendasi Andrej, saya mendapatkan ukuran memori berikut:

Aktivasi: 532.752 * 4 / (1024 ^ 2) = 2,03 MB

Parameter: 19.072.984 * 4 / (1024 ^ 2) * 3 = 218,27 MB

Lain-lain: 128 * 9.000 * 4 / (1024 ^ 2) = 4,39 MB

Jadi total memori untuk melatih jaringan ini adalah 224,69 MB .

Saya menggunakan TensorFlow dan saya pikir saya kehilangan sesuatu. Saya belum menjalankan pelatihan, tapi saya cukup yakin (berdasarkan pengalaman masa lalu) bahwa memori yang digunakan akan jauh lebih tinggi dari apa yang saya hitung.

Jika untuk setiap gambar dalam mini-batch, TensorFlow menjaga gradien mereka sehingga dapat menormalkannya nanti untuk langkah pembaruan bobot / bias tunggal, maka saya pikir memori harus mempertimbangkan nilai 532.752 * 128 lainnya (gradien untuk setiap gambar di mini-batch). Jika itu masalahnya, maka saya akan membutuhkan lebih dari 260,13 MB untuk melatih model ini dengan 128 gambar / mini-batch.

Bisakah Anda membantu saya memahami pertimbangan ingatan untuk melatih model pembelajaran mendalam saya? Apakah pertimbangan di atas benar?

Saya pikir Anda berada di jalur yang benar.

Ya, Anda perlu menyimpan turunan dari aktivasi dan parameter untuk backpropagation.

Selain itu, pilihan pengoptimalan Anda mungkin penting. Apakah Anda berlatih menggunakan SGD, atau Adam, atau Adagrad? Ini semua akan memiliki persyaratan memori yang berbeda. Misalnya, Anda harus menyimpan cache ukuran langkah untuk metode berbasis momentum, meskipun itu harus sekunder dibandingkan dengan pertimbangan memori lain yang Anda sebutkan.

Jadi, secara keseluruhan, Anda tampaknya telah menghitung persyaratan memori untuk umpan maju. Andrej Karpathy menyebutkan bahwa backward pass dapat mengambil hingga 3x memori forward pass, jadi ini mungkin mengapa Anda melihat perbedaan seperti itu (gulir ke bawah ke 'Studi Kasus' di situs web untuk melihat contoh untuk VGGNet).

@StatsSorceress TL; DR:

Saya akan melalui kegiatan ini untuk melihat apakah saya dapat menghitung sendiri memori yang dibutuhkan:

Aktivasi: 532.752 * 2 * 4 / (1024 ^ 2) = 4,06 MB

Parameter: 19.072.984 * 4 / (1024 ^ 2) * 3 = 218,27 MB

Lain-lain: 128 * 9.000 * 4 / (1024 ^ 2) = 4,39 MB

Total Memori: (4.06 * 128 ) + 218.27 + 4.39 = 742.34 MB

( Seseorang tolong perbaiki saya jika ini salah. FYI, Anda sudah mengalikannya dengan 128, jadi itu sebabnya saya tidak melipatgandakannya dengan 128 di atas )

Saya akan mengarahkan Anda ke artikel ini dan video terkait . Mereka membantu saya memahami apa yang sedang terjadi jauh lebih baik.

CATATAN: Memori yang diperlukan untuk menggunakan jaringan untuk prediksi jauh lebih sedikit daripada yang dibutuhkan untuk pelatihan karena dua alasan:

• Saat memprediksi, kami hanya mengirim gambar ke depan melalui jaringan dan tidak mundur (jadi kami tidak memperbanyak memori X 3; lihat di bawah)
• Ada satu prediksi per gambar (jadi kami tidak perlu mengalikan memori yang diperlukan untuk satu gambar dengan ukuran batch karena kami tidak menggunakan batch dalam prediksi).

Proses (Memori untuk Melatih)

1. Hitung memori yang diperlukan untuk berlatih pada satu gambar
2. Lipat gandakan angka ini dengan jumlah gambar dalam kumpulan Anda

( INGAT: Mini-batching mengatakan kami mengambil subset dari data kami, menghitung gradien dan kesalahan untuk setiap gambar di subset, kemudian rata-rata ini dan melangkah maju ke arah rata-rata. Untuk convnets, bobot dan bias dibagi, tetapi jumlah aktivasi dirusak oleh jumlah gambar dalam kumpulan. ).

LANGKAH 1: Memori untuk 1 Gambar

Untuk melatih satu gambar, Anda harus menyimpan memori untuk:

• Parameter model:

  The bobot dan bias pada setiap lapisan, mereka gradien , dan mereka variabel momentum (jika Adam, Adagrad, RMSProp, dll, pengoptimalan digunakan)

  Untuk memperkirakan memori untuk ini, hitung memori yang diperlukan untuk menyimpan bobot dan bias dan kalikan dengan 3 (yaitu "dengan 3" karena kami mengatakan jumlah memori yang dibutuhkan untuk menyimpan bobot dan bias adalah (kira-kira) sama dengan yang diperlukan untuk gradien dan untuk variabel momentum)

  PERSAMAAN:

  Konvolusi:

  bobot (n) = kedalaman (n) * (kernel_width * kernel_height) * kedalaman (n-1)

  bias (n) = kedalaman (n)

  Lapisan Penuh (Terhubung):

  bobot (n) = keluaran (n) * input (n)

  bias (n) = keluaran (n)

di mana n adalah lapisan saat ini dan n-1 adalah lapisan sebelumnya, dan output adalah jumlah output dari lapisan FC dan input adalah jumlah input ke lapisan FC (jika lapisan sebelumnya bukan lapisan yang terhubung sepenuhnya, jumlah input sama dengan ukuran layer yang diratakan).

CATATAN: Memori untuk bobot dan bias saja, ditambah memori untuk aktivasi untuk satu gambar (lihat di bawah), adalah jumlah total memori yang Anda butuhkan untuk prediksi (tidak termasuk beberapa overhead untuk memori untuk konvolusi dan beberapa hal lainnya).

• Aktivasi (ini adalah "Gumpalan" di Caffe):

(Saya menggunakan istilah longgar di sini, bersabarlah)

Setiap konvolusi dalam lapisan konvolusi menghasilkan aktivasi " jumlah piksel dalam gambar " (yaitu, Anda melewatkan gambar melalui konvolusi tunggal, Anda mendapatkan peta fitur tunggal yang terdiri dari aktivasi " m ", di mana " m " adalah jumlah piksel dari Anda gambar / input).

Untuk lapisan yang terhubung sepenuhnya, jumlah aktivasi yang Anda hasilkan sama dengan ukuran output Anda.

Konvolusi:

aktivasi (n) = image_width * image_height * image_num_channels

Lapisan Penuh (Terhubung):

aktivasi (n) = keluaran (n)

Perhatikan bahwa input Anda benar-benar hanya gambar di awal jaringan. Setelah berbelit-belit, itu berubah menjadi sesuatu yang lain (peta fitur). Jadi, ganti "image_width", "image_height", dan "image_num_channels" dengan "input_width", "input_height", dan "layer_depth" dengan lebih tepat. (Hanya lebih mudah bagi saya untuk memikirkan konsep ini dalam hal gambar.)

Karena kita juga perlu menyimpan kesalahan untuk aktivasi di setiap lapisan (digunakan pada backward pass), kita mengalikan jumlah aktivasi dengan 2 untuk mendapatkan jumlah entitas yang kita perlukan untuk memberikan ruang di ruang penyimpanan kita. Jumlah aktivasi meningkat dengan jumlah gambar dalam kumpulan, sehingga Anda mengalikan jumlah ini dengan ukuran kumpulan.

LANGKAH 2: Memori untuk Melatih Kelompok

Jumlahkan bobot dan bias (kali 3) dan jumlah aktivasi (kali 2 kali ukuran batch). Kalikan ini dengan 4, dan Anda mendapatkan jumlah byte yang dibutuhkan untuk melatih bets. Anda dapat membagi dengan 1024 ^ 2 untuk mendapatkan jawaban dalam GB.

Atau, saya pikir Anda dapat menggunakan pustaka profiler apa pun untuk menganalisis memori dan penggunaan CPU oleh program Anda. Ada banyak pustaka python yang dapat memberikan Anda snapshot dari memori dan penggunaan CPU dengan utas atau proses tertentu pada interval milidetik.

Anda dapat menjalankan bagian dari program yang ingin Anda pantau dalam sub-proses yang berbeda menggunakan popen dan memonitor memori itu dan penggunaan CPU menggunakan PID-nya.

psutil saya temukan bagus untuk pekerjaan seperti itu. Padahal ada banyak lainnya.

Saya harap ini akan membantu.