5 tips untuk pelatihan multi-GPU dengan Keras

• Januari 21, 2018
• Vasilis Vriniotis
• . 1 Komentar

Deep Learning (kata kunci favorit akhir 2010-an bersama dengan blockchain / bitcoin dan Data Science / Machine Learning) telah memungkinkan kami untuk melakukan beberapa hal yang sangat keren beberapa tahun terakhir. Selain kemajuan dalam algoritma (yang diakui didasarkan pada ide-ide yang sudah dikenal sejak 1990-an alias "Era Data Mining"), alasan utama keberhasilannya dapat dikaitkan dengan ketersediaan dataset gratis besar, pengenalan perpustakaan open-source dan penggunaan GPU. Dalam posting blog ini saya akan fokus pada dua yang terakhir dan saya akan berbagi dengan Anda beberapa tips yang saya pelajari dengan cara yang sulit.

Mengapa TensorFlow & Keras?

TensorFlow adalah perpustakaan Deep Learning yang sangat populer yang dikembangkan oleh Google yang memungkinkan Anda membuat prototipe jaringan yang kompleks dengan cepat. Muncul dengan banyak fitur menarik seperti auto-diferensiasi (yang menyelamatkan Anda dari estimasi / pengkodean gradien fungsi biaya) dan dukungan GPU (yang memungkinkan Anda untuk dengan mudah meningkatkan kecepatan 200x menggunakan perangkat keras yang layak). Selain itu ia menawarkan antarmuka Python yang berarti bahwa Anda dapat membuat prototipe dengan cepat tanpa perlu menulis kode C atau CUDA. Diakui ada banyak kerangka kerja lain yang bisa digunakan daripada TensorFlow, seperti Torch, MXNet, Theano, Caffe, Deeplearning4j, CNTK, dll. Tapi semuanya bermuara pada case-use Anda dan preferensi pribadi Anda.

Tapi kenapa Keras? Bagi saya menggunakan TF secara langsung seperti melakukan Machine Learning dengan Numpy. Ya itu layak dan dari waktu ke waktu Anda harus melakukannya (terutama jika Anda menulis lapisan kustom / fungsi-hilang) tetapi apakah Anda benar-benar ingin menulis kode yang menggambarkan jaringan kompleks sebagai serangkaian operasi vektor (ya, saya tahu ada metode level tinggi di TF tapi tidak sekeren Keras)? Juga bagaimana jika Anda ingin pindah ke perpustakaan yang berbeda? Kalau begitu Anda mungkin perlu menulis ulang kode, yang menyebalkan. Ta ta taaa, Keras untuk menyelamatkan! Keras memungkinkan Anda untuk menggambarkan jaringan Anda menggunakan konsep tingkat tinggi dan menulis kode yang agnostik backend, artinya Anda dapat menjalankan jaringan di berbagai pustaka pembelajaran mendalam. Beberapa hal yang saya sukai dari Keras adalah bahwa ia ditulis dengan baik, memiliki arsitektur berorientasi objek, mudah untuk berkontribusi dan memiliki komunitas yang ramah. Jika Anda suka, ucapkan terima kasih François Chollet untuk mengembangkannya dan membuka-sumbernya.

Kiat dan Gotcha untuk pelatihan Multi-GPU

Tanpa basa-basi lagi, mari kita lompat ke beberapa tips tentang cara memanfaatkan pelatihan GPU tentang Keras dan beberapa tantangan yang harus Anda ingat:

1. Pelatihan multi-GPU tidak otomatis

Model pelatihan pada GPU menggunakan Keras & Tensorflow berjalan mulus. Jika Anda memiliki kartu NVIDIA dan telah menginstal CUDA, perpustakaan akan secara otomatis mendeteksinya dan menggunakannya untuk pelatihan. Keren abis! Tetapi bagaimana jika Anda adalah anak manja dan Anda memiliki banyak GPU? Sayangnya Anda harus bekerja sedikit untuk mencapai pelatihan multi-GPU.

Ada beberapa cara untuk memparalelkan jaringan tergantung pada apa yang ingin Anda capai tetapi dua pendekatan utama adalah model dan paralelisasi data. Yang pertama dapat membantu Anda jika model Anda terlalu rumit untuk dimuat dalam satu GPU sementara yang kedua membantu ketika Anda ingin mempercepat eksekusi. Biasanya ketika orang berbicara tentang pelatihan multi-GPU yang mereka maksud adalah yang terakhir. Dulu lebih sulit untuk dicapai tetapi untungnya Keras baru-baru ini memasukkan metode utilitas yang disebut mutli_gpu_model yang membuat pelatihan / prediksi paralel lebih mudah (saat ini hanya tersedia dengan backend TF). Gagasan utamanya adalah Anda melewatkan model Anda melalui metode dan disalin ke berbagai GPU. Input asli dibagi menjadi potongan-potongan yang diumpankan ke berbagai GPU dan kemudian dikumpulkan sebagai output tunggal. Metode ini dapat digunakan untuk mencapai pelatihan dan prediksi paralel, namun perlu diingat bahwa untuk pelatihan tidak skala secara linear dengan jumlah GPU karena sinkronisasi yang diperlukan.

2. Perhatikan Ukuran Batch

Ketika Anda melakukan pelatihan multi-GPU perhatikan ukuran batch karena memiliki banyak efek pada kecepatan / memori, konvergensi model Anda dan jika Anda tidak hati-hati Anda dapat merusak bobot model Anda!

Kecepatan / memori: Jelas semakin besar batch, semakin cepat pelatihan / prediksi. Ini karena ada overhead untuk memasukkan dan mengambil data dari GPU, sehingga batch kecil memiliki lebih banyak overhead. Di sisi lain, semakin besar batch semakin banyak memori yang Anda butuhkan di GPU. Terutama selama pelatihan, input dari setiap lapisan disimpan dalam memori karena mereka diperlukan pada langkah back-propagation, sehingga menambah ukuran batch Anda terlalu banyak dapat menyebabkan kesalahan kehabisan memori.

Konvergensi: Jika Anda menggunakan Stochastic Gradient Decent (SGD) atau beberapa variannya untuk melatih model Anda, Anda harus ingat bahwa ukuran batch dapat memengaruhi kemampuan jaringan Anda untuk melakukan konvergen dan generalisasi. Ukuran batch umum dalam banyak masalah penglihatan komputer adalah antara 32-512 contoh. Sebagai Keskar dkk katakan, "Telah diamati dalam prakteknya bahwa ketika menggunakan batch yang lebih besar (dari 512) ada penurunan dalam kualitas model, yang diukur dengan kemampuannya untuk menggeneralisasi.". Perhatikan bahwa pengoptimal lain yang berbeda memiliki sifat yang berbeda dan teknik pengoptimalan terdistribusi khusus dapat membantu mengatasi masalah tersebut. Jika Anda tertarik pada perincian matematisnya, saya sarankan untuk membaca Tesis Joeri Hermans “On Scalable Deep Learning dan Parallelizing Gradient Descent".

Merusak bobot: Ini adalah detail teknis yang buruk yang dapat memiliki hasil yang menghancurkan. Saat Anda melakukan pelatihan multi-GPU, penting untuk memberi makan semua GPU dengan data. Bisa jadi bahwa batch terakhir dari zaman Anda memiliki lebih sedikit data daripada yang ditentukan (karena ukuran dataset Anda tidak dapat dibagi persis dengan ukuran batch Anda). Ini mungkin menyebabkan beberapa GPU tidak menerima data apa pun selama langkah terakhir. Sayangnya beberapa Lapisan Keras, terutama Lapisan Normalisasi Batch, tidak dapat mengatasi hal itu yang menyebabkan nilai-nilai nan muncul dalam bobot (rata-rata berjalan dan varian di lapisan BN). Untuk membuat hal-hal lebih nastier, orang tidak akan mengamati masalah selama pelatihan (sedangkan fase pembelajaran adalah 1) karena lapisan spesifik menggunakan rata-rata / varians batch dalam estimasi. Namun demikian selama prediksi (fase pembelajaran diatur ke 0), running mean / variance digunakan yang dalam kasus kami dapat menjadi nan mengarah ke hasil yang buruk. Jadi bantulah diri Anda sendiri dan selalu pastikan bahwa ukuran batch Anda tetap ketika Anda melakukan pelatihan multi-GPU. Dua cara sederhana untuk mencapai hal ini adalah dengan menolak kumpulan yang tidak cocok dengan ukuran yang telah ditentukan atau mengulangi rekaman di dalam batch sampai Anda mencapai ukuran yang telah ditentukan. Terakhir, namun perlu diingat bahwa dalam pengaturan multi-GPU, ukuran batch harus merupakan kelipatan dari jumlah GPU yang tersedia di sistem Anda.

3. Data GPU Kelaparan alias CPU tidak dapat bersaing dengan GPU

Biasanya bagian yang paling mahal saat melatih / memprediksi jaringan dalam adalah estimasi yang terjadi pada GPU. Data diproses dalam CPU di latar belakang dan diumpankan ke GPU secara berkala. Namun demikian, orang tidak boleh meremehkan seberapa cepat GPU; itu bisa terjadi bahwa jika jaringan Anda terlalu dangkal atau langkah preprocessing terlalu kompleks sehingga CPU Anda tidak dapat mengikuti GPU Anda atau dengan kata lain mereka tidak memberi mereka makan dengan data dengan cukup cepat. Hal ini dapat menyebabkan pemanfaatan GPU yang rendah yang berarti terbuangnya uang / sumber daya.

Keras biasanya melakukan estimasi batch secara paralel namun karena Python GIL (Global Interpreter Lock) Anda tidak dapat benar-benar mencapai multi-threading dalam Python. Ada dua solusi untuk itu: baik menggunakan beberapa proses (perhatikan bahwa ada banyak gotcha dalam satu ini yang saya tidak akan bahas di sini) atau buat langkah preprocessing Anda sederhana. Di masa lalu saya telah mengirimkan Pull-Request on Keras untuk mengurangi beberapa ketegangan yang tidak perlu yang kami lakukan pada CPU selama Image preprocessing, sehingga sebagian besar pengguna tidak akan terpengaruh jika mereka menggunakan generator standar. Jika Anda memiliki generator khusus, coba dorong logika sebanyak mungkin ke pustaka C seperti Numpy karena beberapa metode ini sebenarnya lepaskan GIL yang berarti Anda dapat meningkatkan derajat paralelisasi. Cara yang baik untuk mendeteksi apakah Anda menghadapi kelaparan data GPU adalah dengan memantau pemanfaatan GPU, namun perlu diingatkan bahwa ini bukan satu-satunya alasan untuk mengamati bahwa (sinkronisasi yang terjadi selama pelatihan di beberapa GPU juga merupakan penyebab rendahnya pemanfaatan. ). Biasanya kelaparan data GPU dapat dideteksi dengan mengamati semburan GPU diikuti dengan jeda lama tanpa pemanfaatan. Di masa lalu saya telah membuka sumber ekstensi untuk Dstat yang dapat membantu Anda mengukur pemanfaatan GPU Anda, jadi lihatlah di posting blog asli.

4. Menyimpan model paralel Anda

Katakanlah Anda menggunakan metode mutli_gpu_model untuk memparalelkan model Anda, pelatihan telah selesai dan sekarang Anda ingin mempertahankan bobotnya. Berita buruknya adalah Anda tidak bisa memanggil save () saja. Saat ini Keras memiliki batasan yang tidak memungkinkan Anda untuk melakukannya simpan model paralel. Ada 2 cara untuk mengatasi ini: panggil save () dengan referensi model asli (bobot akan diperbarui secara otomatis) atau Anda perlu membuat serial model dengan memotong versi paralel dan membersihkan semua koneksi yang tidak perlu. Opsi pertama adalah cara yang lebih mudah tetapi di masa depan saya berencana untuk open-source metode serialize () yang melakukan yang terakhir.

5. Menghitung GPU yang tersedia memiliki efek samping yang buruk

Sayangnya saat ini, ada efek samping yang buruk pada metode tensorflow.python.client.device_lib.list_local_devices () yang menyebabkan Sesi TensorFlow baru dibuat dan inisialisasi semua GPU yang tersedia pada sistem. Ini dapat menyebabkan hasil yang tidak terduga seperti melihat lebih banyak GPU daripada yang ditentukan atau menginisialisasi sesi baru secara prematur (Anda dapat membaca semua detail tentang ini) tarik-permintaan). Untuk menghindari kejutan serupa, Anda disarankan untuk menggunakan metode Keras 'K.get_session (). List_devices (), yang akan mengembalikan Anda semua GPU yang saat ini terdaftar di sesi. Terakhir, ingatlah bahwa memanggil metode list_devices () itu mahal, jadi jika Anda hanya tertarik pada jumlah GPU yang tersedia, panggil metode tersebut satu kali dan simpan nomor mereka pada variabel lokal.

Itu dia! Semoga Anda menemukan daftar ini bermanfaat. Jika Anda menemukan Gotcha / tips lain untuk pelatihan GPU di Keras, bagikan di bawah ini di komentar. 🙂