Memecahkan masalah TensorFlow - TPU

Panduan ini, beserta FAQ, memberikan bantuan pemecahan masalah bagi pengguna yang melatih model TensorFlow di Cloud TPU. Jika memecahkan masalah pelatihan Pytorch atau JAX, Anda dapat melihat dokumen pemecahan masalah untuk framework tersebut:

Memecahkan masalah PyTorch - TPU
Memecahkan masalah JAX - TPU

Penting: Cloud TPU mendukung dua arsitektur TPU: VM TPU atau TPU Node. Kedua arsitektur VM dijelaskan di Arsitektur Sistem. Prosedur pemecahan masalah dalam dokumen ini berlaku untuk kedua konfigurasi, tetapi ada juga bagian TPU VM terpisah yang khusus untuk memecahkan masalah yang hanya terjadi pada konfigurasi VM TPU.

Untuk panduan umum lebih lanjut mengenai cara menggunakan Cloud TPU, lihat:

Ringkasan

Masalah umum yang dialami dengan Cloud TPU termasuk dalam kategori berikut:

Masalah saat menghubungkan ke TPU
Proses debug error umum
Mengurangi penggunaan memori
Meningkatkan kecepatan pelatihan
Men-debug penurunan dalam akurasi model

Terjadi masalah saat menghubungkan ke server TPU

Bagian ini menjelaskan cara memecahkan masalah saat TensorFlow berhenti merespons atau mencetak error saat terhubung ke TPU. Langkah kompilasi grafik TPU dapat memerlukan waktu lama untuk model besar. Jadi, biarkan skrip dieksekusi setidaknya selama 5 menit sebelum menyimpulkan bahwa skrip berhenti merespons.

Langkah pertama adalah memverifikasi apakah masalah terdapat pada server itu sendiri, atau pada pipeline pelatihan TensorFlow Anda. Untuk melakukannya, jalankan tutorial MNIST menggunakan URL server TPU dan pastikan URL tersebut berfungsi dengan benar. Jika masih ada masalah koneksi dengan tutorial MNIST, hal ini menunjukkan bahwa masalah tersebut terdapat pada server TPU. Dalam kasus ini:

Jalankan perintah berikut untuk membuat daftar TPU yang tersedia. Mengganti zone dan project-id dengan zona dan project ID Anda.

(vm)$ gcloud compute tpus list --zone zone --project project-id

Tindakan ini akan mencetak output seperti:

NAME       ZONE           ACCELERATOR_TYPE  NETWORK_ENDPOINT   NETWORK  RANGE          STATUS
demo-tpu   us-central1-b  v2-8              10.240.1.2:8470    default  10.240.1.0  READY

Pastikan Anda meneruskan nilai yang benar ke --tpu (demo-tpu dalam contoh di atas), dan bahwa TPU ini dicantumkan sebagai READY.
Jika TPU Anda tidak tercantum sebagai READY atau Anda masih mengalami masalah untuk menghubungkan, mulai ulang server secara manual dengan:
```
(vm)$ gcloud compute tpus stop $TPU_SERVER_NAME && gcloud compute tpus start $TPU_SERVER_NAME
```
Pada contoh di atas, $TPU_SERVER_NAME adalah demo-tpu. Proses ini mungkin memerlukan waktu beberapa menit.
Jalankan kembali perintah ... tpus list di atas dan tunggu hingga TPU berada dalam status READY. Proses ini mungkin perlu waktu beberapa menit.
Coba jalankan tutorial MNIST lagi.
Jika Anda masih mengalami masalah dalam menjalankan tutorial MNIST, mintalah bantuan untuk menggunakan salah satu mekanisme yang dijelaskan dalam Mendapatkan Dukungan.

Jika contoh MNIST berjalan dengan benar, tetapi model masih berhenti merespons, kemungkinan ada masalah pada pipeline pelatihan Anda. Untuk melakukan debug, mulailah dengan mengganti TPUStrategy dalam kode Anda dengan strategi default. Saat Anda menggunakan strategi default, di mana pun Anda menggunakan strategy.scope() atau strategy.run(), model akan berjalan di CPU (atau GPU jika ada), bukan di TPU. Jika model berjalan pada CPU, bukan TPU, pasti ada masalah khusus TPU. Jika masih tidak berjalan, praktik terbaiknya adalah men-debug masalahnya di CPU.

Kehilangan koneksi `ssh` selama pelatihan

Waktu tunggu koneksi ssh ke Cloud TPU mungkin habis selama pelatihan yang berjalan lama (terutama jika Anda menggunakan Cloud Shell). Pada saat itu, tidak ada output ke konsol TPU dan konsol TPU mungkin akan tampak seolah-olah TPU telah menghentikan pelatihan. Untuk menghindari hal ini, jalankan sesi pelatihan dengan multiplexer terminal atau alat pengelolaan sesi seperti tmux atau screen. Tindakan ini akan membuat koneksi ssh tetap aktif, berapa pun durasi pelatihan.

Men-debug error umum

Tidak dapat membuat TPU

Saat membuat Cloud TPU, Anda mungkin melihat error berikut:

googleapiclient.errors.HttpError: < HttpError 403 when requesting https://content-tpu.googleapis.com/v1/projects/{PROJECT}/locations/{ZONE}/nodes/{TPU_NAME}?alt=json returned "Request had insufficient authentication scopes."

Ini adalah masalah izin dan dapat diatasi dengan menjalankan perintah berikut:

gcloud auth login --update-adc

Perintah ini memperbarui Kredensial Default Aplikasi (ADC) Anda dan akan menyelesaikan masalah tersebut. Untuk mengetahui informasi selengkapnya, lihat gcloud auth login.

Tidak dapat menggunakan sistem file lokal

Pesan Error

InvalidArgumentError: Unimplemented: File system scheme '[local]' not implemented

Framework dan Konfigurasi yang Terpengaruh

Pesan ini dapat muncul saat melakukan pelatihan dengan TensorFlow menggunakan arsitektur Node TPU.

Detail

Semua file input dan direktori model harus menggunakan jalur bucket Cloud Storage (gs://bucket-name/...), dan bucket ini harus dapat diakses dari server TPU. Perhatikan bahwa semua pemrosesan data dan checkpoint model dilakukan di server TPU, bukan mesin lokal. Untuk informasi cara mengonfigurasi penyimpanan cloud dengan benar untuk digunakan dengan TPU, lihat panduan Menghubungkan ke Bucket Cloud Storage.

Jenis data tidak didukung

Pesan Error

TypeError: DataType is not a supported TPU infeed type.

Framework dan Konfigurasi yang Terpengaruh

Pesan ini dapat muncul saat melakukan pelatihan dengan TensorFlow menggunakan arsitektur Node TPU.

Detail

Saat ini, hanya jenis data tf.float32, tf.int32, tf.bfloat16, dan tf.bool yang didukung di TPU. Jenis data umum lainnya, seperti tf.uint8, tf.string, dan tf.int64, harus dikonversi ke salah satu jenis data yang didukung selama pra-pemrosesan data (yaitu, di pipeline tf.data.Dataset).

Lihat contoh konversi dalam fungsi decode_image yang digunakan dalam pelatihan MNIST.

Bentuk dinamis tidak didukung

Pesan Error

ValueError: shape [Shape] must have a fixed size for dimension
d that is known at graph construction time.

Framework dan Konfigurasi yang Terpengaruh

Pesan ini hanya muncul selama kompilasi XLA dengan TensorFlow.

Detail

Untuk menjalankan model di TPU, TensorFlow mengompilasi model menggunakan compiler XLA. Meskipun langkah kompilasi ini meningkatkan kecepatan pelatihan dan penggunaan memori secara signifikan, bentuk (ukuran dimensi) semua TensorFlow dalam grafik harus diketahui pada waktu kompilasi grafik. Jika bentuk apa pun tidak dapat ditentukan pada waktu kompilasi, kompilasi TPU akan gagal dengan error seperti di atas.

Satu operasi umum yang menampilkan bentuk dinamis adalah dataset.batch(batch_size), karena jumlah sampel yang tersisa dalam aliran mungkin lebih kecil dari ukuran tumpukan. Oleh karena itu, saat melakukan pelatihan di TPU, tetapkan drop remainder=True untuk dataset.batch. Tindakan ini berpotensi menghapus beberapa sampel terakhir dari file untuk memastikan bahwa setiap batch memiliki bentuk batch_size statis. Contoh:

dataset = tf.data.Dataset.range(8)
dataset = dataset.batch(3, drop_remainder=True)

Operasi TensorFlow tidak tersedia

Pesan Error

NotFoundError: No registered 'OpName' OpKernel for XLA_TPU_JIT
devices compatible with node

Framework dan Konfigurasi yang Terpengaruh

Pesan ini dapat muncul saat melakukan pelatihan dengan TensorFlow.

Detail

Model ini menggunakan operasi TensorFlow yang saat ini tidak tersedia di TPU.

Untuk daftar operasi yang tersedia di TPU, beserta rencana dukungan di masa mendatang dan saran solusi, lihat panduan untuk Ops TensorFlow yang tersedia.

Pesan error kehabisan memori

Pesan Error

ResourceExhaustedError: Ran out of memory in memory space hbm; used:
YYY; limit: 7.48G.

Framework dan Konfigurasi yang Terpengaruh

Pesan ini dapat muncul saat melakukan pelatihan dengan TensorFlow, PyTorch, atau JAX.

Detail

Setiap Cloud TPU terdiri dari delapan core TPU. TPU v2 memiliki TPU 8 GB dan v3 memiliki RAM 16 GB (atau HBM, Memori Bandwidth Tinggi). Memori ini digunakan untuk menyimpan tensor bobot (variabel), serta TensorFlow hasil menengah yang diperlukan untuk komputasi gradien. Jika model terlalu besar untuk dimuat dengan TPU RAM, inisialisasi akan gagal dan pesan error di atas akan dicetak. Lihat bagian tentang mengurangi penggunaan memori untuk mendapatkan bantuan lebih lanjut.

Tips untuk mengurangi penggunaan memori:

Periksa padding TensorFlow yang berlebihan
Menggunakan format bfloat16
Jika model atau ukuran input terlalu besar, Anda mungkin dapat menggunakan paralelisme model eksperimental TensorFlow untuk mengatasi ukuran model.

Masalah saat menghentikan eksekusi

Jika TensorFlow mengalami error selama eksekusi TPU, skrip terkadang tampak berhenti merespons, bukan keluar ke shell. Jika hal ini terjadi, tekan CTRL+\ pada keyboard untuk memicu SIGQUIT, yang menyebabkan Python segera keluar.

Demikian pula, menekan CTRL+C selama eksekusi TPU tidak akan langsung menonaktifkan TensorFlow, tetapi menunggu hingga akhir loop iterasi saat ini untuk keluar dengan benar.

Jika Anda mengalami error baru saat menghubungkan kembali ke TPU setelah keluar dengan cara ini, reset server TPU secara manual menggunakan perintah:

gcloud compute tpus stop tpu-name --zone=zone
gcloud compute tpus start tpu-name --zone=zone

dengan tpu-name diambil dari kolom pertama yang ditampilkan oleh perintah gcloud compute tpus list dan zone adalah zona yang ditampilkan di kolom kedua.

Padding TensorFlow berlebihan

Kemungkinan Penyebab Masalah Memori

Tensor dalam memori TPU diberi padding, yaitu TPU membulatkan ukuran TensorFlow yang disimpan dalam memori untuk melakukan komputasi dengan lebih efisien. Padding ini terjadi secara transparan di tingkat hardware dan tidak memengaruhi hasil. Namun, dalam kasus tertentu, padding dapat mengakibatkan peningkatan penggunaan memori dan waktu eksekusi secara signifikan.

Cara Mengurangi Penggunaan Memori

Software TPU mencoba menata letak TensorFlow di memori untuk memaksimalkan efisiensi komputasi dan meminimalkan padding. Namun, proses tata letak memori ini bersifat kompleks, tetapi untuk mendapatkan hasil terbaik, model harus mematuhi aturan praktis berikut. Untuk meminimalkan overhead memori dan memaksimalkan efisiensi komputasi, salah satu hal berikut harus terpenuhi:

Total ukuran tumpukan harus kelipatan 64 (8 per inti TPU), dan dimensi fitur harus kelipatan 128,

atau
Total ukuran batch harus kelipatan 1.024 (128 per inti TPU), dan dimensi fitur harus kelipatan 8.

Menggunakan ukuran tumpukan 1024 dan dimensi fitur yang merupakan kelipatan 128 akan menghasilkan efisiensi terbaik, meskipun hal ini mungkin tidak memungkinkan untuk semua model. Agar lebih jelas, "dimensi fitur" mengacu pada ukuran tersembunyi dari lapisan yang terhubung sepenuhnya atau jumlah saluran output dalam konvolusi. Tidak semua lapisan dapat mematuhi aturan ini, terutama lapisan pertama dan terakhir pada jaringan. Hal ini tidak masalah, dan diharapkan sebagian besar model memerlukan sejumlah padding.

Mengurangi penggunaan memori

Jika mengalami error kehabisan memori saat mengeksekusi model di TPU, Anda harus mengambil langkah-langkah untuk mengurangi penggunaan memori model.

Cara paling efektif untuk mengurangi penggunaan memori adalah dengan:

Mengurangi padding Tensor yang berlebihan
Mengurangi ukuran tumpukan

Ukuran atau model tumpukan terlalu besar

Kemungkinan Penyebab Masalah Memori

Saat melatih jaringan neural di CPU, GPU, atau TPU, penggunaan memori berasal dari dua tempat:

Penggunaan memori sebanding dengan jumlah bobot dalam model.
Menyimpan aktivasi perantara dari penerusan maju yang diperlukan untuk menghitung {i>backward pass<i}. Penggunaan memori proporsional secara langsung dengan ukuran tumpukan, ukuran lapisan, dan jumlah lapisan.

Oleh karena itu, memori yang dibutuhkan oleh model sangat bergantung pada ukuran batch.

Memori yang dibutuhkan oleh model bergantung pada jumlah lapisan di jaringan.

Runtime TPU mencoba mengoptimalkan operator agar sesuai dengan model dalam memori (disebut rematerialisasi, mirip dengan pemeriksaan gradien), tetapi hal ini tidak selalu dapat dilakukan.

Cara Mengurangi Penggunaan Memori

Kurangi ukuran tumpukan secara perlahan hingga sesuai di memori, dan pastikan ukuran tumpukan totalnya kelipatan 64 (ukuran tumpukan per inti harus kelipatan 8). Perlu diingat bahwa ukuran tumpukan yang lebih besar akan lebih efisien pada TPU. Secara umum, ukuran batch total 1.024 (128 per inti) merupakan titik awal yang baik.

Jika model tidak dapat dijalankan di TPU meskipun dengan ukuran tumpukan kecil (misalnya 64), coba kurangi jumlah lapisan atau ukuran lapisan.

Meningkatkan kecepatan pelatihan

Jika model Anda berhasil berjalan di TPU, tetapi kecepatan pelatihan lebih rendah dari yang diharapkan, bagian ini menjelaskan beberapa cara yang mungkin dilakukan untuk meningkatkan kecepatan. Lihat Panduan performa untuk saran lain tentang cara meningkatkan performa pelatihan.

Terlalu sedikit langkah per eksekusi per loop pelatihan

Deskripsi Masalah Performa

Meneruskan argumen steps_per_execution ke Model.compile akan mengontrol jumlah langkah pelatihan yang dijalankan di antara callback host. Setiap callback host memerlukan komunikasi yang signifikan antara CPU host server TPU dan perangkat TPU, sehingga jika steps_per_execution terlalu kecil, hal tersebut dapat memperlambat pelatihan.

Cara Mengetahui Apakah Model Anda Terpengaruh

Jika profil TPU menampilkan callback CPU host yang sering ditampilkan di antara langkah perangkat TPU, pelatihan Anda akan mendapatkan manfaat dari nilai steps_per_execution yang lebih besar.

Cara Melakukan Mitigasi

Tetapkan steps_per_execution ke nilai yang lebih besar. Perlu diperhatikan bahwa steps_per_execution dapat ditetapkan ke nilai besar. Namun, perlu diingat bahwa mencatat pesan ke dalam log dan menyimpan checkpoint hanya dapat dilakukan setelah jumlah langkah yang ditentukan berjalan.

Hambatan pemrosesan input

Deskripsi Masalah Performa

Saat TPU melatih potongan data tertentu, fungsi pemrosesan input menyiapkan potongan data berikutnya pada CPU. Jika fungsi input Anda memerlukan waktu lebih lama daripada fungsi model, TPU akan dibiarkan tidak ada aktivitas saat fungsi input Anda mengambil data.

Cara Mengetahui Apakah Model Anda Terpengaruh

Ikuti petunjuk di Cloud TPU Tools: Input Pipeline Analyzer untuk melihat analisis pipeline input di TensorBoard:

gambar

Halaman analisis pipeline input menampilkan ringkasan jelas yang menunjukkan apakah model Anda mengalami bottleneck oleh pemrosesan input. Halaman yang sama juga menunjukkan waktu eksekusi per operasi, yang memungkinkan Anda menemukan operasi yang bermasalah.

Cara Melakukan Mitigasi

Ada beberapa kemungkinan mitigasi saat memuat data dengan Dataset API:

Simpan data Anda sebagai kumpulan struktur tf.train.Example di file TFRecord, dan muat dengan TFRecordDataset. Lihat tutorial Dataset API atau tutorial ResNet untuk mengetahui contohnya.
Gunakan dataset.cache() dan/atau dataset.prefetch() untuk melakukan buffering data input. Tindakan ini mencegah perlambatan sporadis dalam akses file agar tidak menimbulkan bottleneck.
Tentukan parameter num_parallel_calls fungsi dataset.map() untuk mengaktifkan operasi map() multi-thread. Heuristik sederhana untuk nilai num_parallel_calls adalah menggunakan jumlah core CPU yang tersedia.
Lakukan pra-pemrosesan data yang mahal secara offline sebagai biaya satu kali, bukan mengeluarkan biaya pada setiap epoch setiap pelatihan.

Semua pemrosesan input dilakukan pada CPU yang terletak di server TPU, bukan di komputer lokal, sehingga kecepatan mesin lokal tidak berpengaruh.

Waktu langkah lambat dan pemakaian MXU rendah

Deskripsi Masalah Performa

Cloud TPU dapat melakukan perkalian dan konvolusi matriks dengan kecepatan yang sangat tinggi. Mayoritas operasi TensorFlow lainnya memiliki implementasi yang efisien pada TPU, tetapi ini bukan kekuatan utama TPU dibandingkan dengan hardware lainnya. Oleh karena itu, model harus didominasi oleh perkalian atau konvolusi matriks untuk memanfaatkan TPU tersebut sepenuhnya.

Cara Mengetahui Apakah Model Anda Terpengaruh

Gejala yang akan Anda lihat dalam kasus ini adalah waktu langkah lambat ditambah dengan penggunaan MXU yang rendah yang ditampilkan saat Anda membuat profil performa.

Cara Melakukan Mitigasi

Coba kurangi jumlah operasi yang bukan merupakan perkalian matriks. Setelah mengurangi jumlah perkalian matriks, lakukan benchmark ulang untuk melihat apakah performa dapat diterima di TPU.

Padding TensorFlow berlebihan

Deskripsi Masalah Performa

TPU memberikan pad pada TensorFlow di memori sehingga TPU dapat menggunakan unit komputasinya secara efisien. Padding ini dapat meningkatkan penggunaan bandwidth memori dan memori. Lihat bagian padding tensor untuk mendapatkan bantuan memahami dan memperbaiki masalah padding TensorFlow.

Throughput lambat dan penggunaan memori rendah

Deskripsi Masalah Performa

Pada dasarnya, penggunaan ukuran tumpukan yang lebih besar akan menghasilkan kecepatan pelatihan yang lebih tinggi pada TPU, dalam hal sampel/detik.

Cara Mengetahui Apakah Model Anda Terpengaruh

Ukuran batch model apa pun harus selalu minimal 64 (8 per inti TPU), karena TPU selalu menambahkan bantalan pada TensorFlow ke ukuran ini. Ukuran batch yang ideal saat melakukan pelatihan di TPU adalah 1.024 (128 per inti TPU), karena hal ini akan menghilangkan inefisiensi terkait transfer memori dan padding.

Cara Melakukan Mitigasi

Praktik terbaiknya adalah menggunakan ukuran tumpukan terbesar yang sesuai dengan memori dan merupakan kelipatan dari 64. Cara termudah untuk mencapainya adalah dengan memulai dengan 1024, dan jika ini menyebabkan error kehabisan memori, cobalah mengurangi ukuran tumpukan hingga model berhasil berjalan. Mengubah ukuran tumpukan model mungkin memerlukan penyesuaian hyperparameter lainnya untuk mencapai akurasi model yang sama, seperti kecepatan pemelajaran, tetapi hal ini harus dievaluasi secara kasus per kasus.

Ukuran lapisan terlalu kecil

Deskripsi Masalah Performa

Meskipun model didominasi oleh perkalian atau konvolusi matriks, TPU mungkin tidak berjalan pada efisiensi penuh jika TensorFlow inputnya kecil. Jika dibandingkan dengan hardware lain, TPU berjalan paling efisien jika ukuran tumpukan dan ukuran lapisannya besar (misalnya, dimensi >= 512).

Cara Mengetahui Apakah Model Anda Terpengaruh

Umumnya, ukuran lapisan yang lebih kecil dari 128 akan mencapai efisiensi yang buruk pada TPU, karena 128 adalah dimensi native dari unit perkalian matriks TPU. Untuk lapisan yang terhubung sepenuhnya, sebaiknya gunakan ukuran tersembunyi minimum sebesar 512 untuk mencapai efisiensi tinggi. Perhatikan bahwa lapisan konvolusional biasanya tidak perlu sebesar lapisan yang terhubung sepenuhnya untuk mencapai tingkat efisiensi yang sama.

Cara Melakukan Mitigasi

Jika motivasi utama terkait ukuran lapisan kecil dalam model Anda adalah kecepatan pelatihan, tolok ukur ulang model Anda dengan lapisan yang lebih besar pada TPU. Misalnya, meningkatkan ukuran output lapisan dari 256 menjadi 512 hanya dapat meningkatkan waktu pelatihan sebesar 20% meskipun model ini melakukan komputasi 2x lipat.

Pembuatan profil model level operasi

Sering kali ada baiknya untuk mengukur waktu eksekusi level op dan penggunaan memori untuk mengidentifikasi bottleneck performa. Untuk petunjuk cara melakukannya,
lihat panduan Alat Cloud TPU: Trace Viewer.

Men-debug penurunan akurasi model

Salah satu tujuan ekosistem Cloud TPU adalah model apa pun yang saat ini sedang dilatih pada CPU atau GPU akan mencapai akurasi yang sangat mirip saat dilatih di TPU, dengan mungkin penyesuaian kecil pada hyperparameter seperti ukuran tumpukan dan kecepatan pemelajaran. Namun, terkadang pengguna dapat mengamati penurunan akurasi saat melatih model di TPU. Proses debug masalah semacam itu bisa sangat menjengkelkan karena sifat pelatihan jaringan neural yang acak. Bagian ini berisi panduan tentang cara menemukan akar masalah dari penurunan akurasi model saat mem-porting model ke TPU.

Memahami sharding data (paralelisme data)

Salah satu tujuan utama TensorFlow adalah bahwa setiap operasi harus memberikan hasil yang hampir identik, baik dijalankan di CPU, GPU, maupun TPU. Ada pengecualian tertentu untuk hal ini, seperti operasi acak. Secara umum, jika Anda menemukan perbedaan yang signifikan antara output operasi non-acak di TPU dan CPU, laporkan sebagai bug.

Namun, untuk pipeline pelatihan secara keseluruhan, ada perbedaan yang signifikan antara pelatihan pada CPU/GPU dan TPU. Saat melatih TPU, TensorFlow melakukan sharding data, Setiap Cloud TPU berisi 8 core TPU yang beroperasi sebagai unit pemrosesan independen. Untuk setiap langkah dalam pelatihan, setiap inti TPU menerima sekumpulan data, menghitung gradien bobot, menukar gradien dengan inti TPU lainnya, lalu menghitung pembaruan bobot. Secara default, kerugian dirata-ratakan di seluruh core, tetapi dapat dijumlahkan dengan mengubah parameter CrossShardOptimizer.

Jika kerugian total model dapat dihitung sebagai rata-rata (atau jumlah) kerugian per sampel independen, prosedur ini secara matematis setara dengan pelatihan pada satu batch besar.

Operasi paling umum yang tidak independen per sampel adalah normalisasi batch, yang berjalan pada setiap batch per inti secara terpisah. Misalnya, jika total ukuran batch adalah 128, ukuran batch per inti adalah 16, dan masing-masing dari 8 inti tersebut melakukan normalisasi batch terhadap 16 sampelnya sendiri. Dalam beberapa kasus, melakukan normalisasi batch pada batch kecil (misalnya, kurang dari 32) terbukti dapat menurunkan akurasi. Dalam skenario yang ideal, total ukuran tumpukan harus besar (misalnya, 256 hingga 1024). Jika ukuran tumpukan terlalu besar untuk dimuat ke dalam memori, efek sharding harus dievaluasi secara kasus per kasus.

Pelatihan deterministik

Salah satu alasan sulitnya men-debug perbedaan dalam akurasi model adalah karena di berbagai framework (TensorFlow, PyTorch, JAX), software pelatihan menggunakan inisialisasi bobot dan pengacakan data yang berbeda setiap kali model dilatih. Sebaiknya modifikasi prosedur pelatihan agar menjadi deterministik, sehingga beberapa operasi akan menghasilkan model yang hampir identik. Bagian ini menunjukkan cara menjalankan tutorial MNIST secara deterministik:

Membuat file checkpoint awal dengan menjalankan satu langkah di CPU. Langkah ini digunakan untuk mencapai inisialisasi bobot deterministik. Selain itu, pastikan Anda menggunakan seed acak tetap untuk fungsi acak dalam model.

# Run training for 1 step to create an initial checkpoint.
python mnist_tpu.py \
  --use_tpu=False \
  --data_dir=${STORAGE_BUCKET}/data/ \
  --model_dir=${STORAGE_BUCKET}/init_output \
  --random_seed=12345 \
  --iterations=1
  --train_steps=1

Ubah fungsi pengacakan data apa pun dalam fungsi input Anda untuk menggunakan seed acak. Hal ini telah dilakukan dalam tutorial MNIST. Ini berfungsi untuk operasi pemrosesan data input karena operasi tersebut selalu berjalan di CPU. Operasi acak dalam fungsi model mungkin tidak bersifat deterministik antara TPU dan CPU. Setiap kali Anda memanggil operasi acak, teruskan seed tetap untuk memastikan hasil yang sama di antara operasi. Contoh:

# In the flag definitions
tf.flags.DEFINE_integer("batch_size", None, "Random seed for training")

# In the input_fn
if FLAGS.random_seed is not None:
dataset = dataset.shuffle(seed=FLAGS.random_seed)

Jalankan model yang sama dua kali pada CPU untuk memverifikasi bahwa pelatihan bersifat deterministik. Perhatikan bahwa pelatihan harus dijalankan untuk jumlah langkah yang wajar (misalnya, 1.000), tetapi tidak perlu dijalankan untuk konvergensi.

Karena pelatihan CPU dibandingkan dengan pelatihan TPU core tunggal, gunakan ukuran tumpukan yang dapat dimuat pada satu inti TPU (biasanya, ukuran tumpukan penuh dibagi dengan 8). TensorFlow tidak menjamin determinisme bit-untuk-bit antar-operasi, tetapi kerugiannya harus sangat mendekati:

Salin bobot awal

gsutil mkdir ${STORAGE_BUCKET}/cpu_output_1
gsutil cp -f ${STORAGE_BUCKET}/init_output/* ${STORAGE_BUCKET}/cpu_output_1
gsutil mkdir ${STORAGE_BUCKET}/cpu_output_2
gsutil cp -f ${STORAGE_BUCKET}/init_output/* ${STORAGE_BUCKET}/cpu_output_2

Putaran 1

python mnist_tpu.py \
  --use_tpu=False \
  --data_dir=${STORAGE_BUCKET}/data/ \
  --model_dir=${STORAGE_BUCKET}/cpu_output_1 \
  --batch_size=128 \
  --random_seed=12345 \
  --train_steps=2000 \
  --eval_steps=10

Output 1

accuracy = 0.9910644, global_step = 1000, loss = 0.025323588

Putaran 2

python mnist_tpu.py \
  --use_tpu=False \
  --data_dir=${STORAGE_BUCKET}/data/ \
  --model_dir=${STORAGE_BUCKET}/cpu_output_1 \
  --batch_size=128 \
  --random_seed=12345 \
  --train_steps=2000 \
  --eval_steps=10

Output 2

accuracy = 0.9910644, global_step = 1000, loss = 0.025323414

Pelatihan TPU single-core

Setelah Anda dapat menjalankan tutorial MNIST secara pasti, langkah berikutnya adalah mereplikasi hasil yang dilatih CPU di TPU, menggunakan satu inti TPU untuk menentukan apakah masalah tersebut terkait dengan sharding data atau mesin eksekusi TPU itu sendiri.

Berikut cara menjalankan pelatihan dan evaluasi inti tunggal pada tutorial MNIST:

Gunakan inisialisasi bobot yang sama seperti CPU

gsutil cp -f ${STORAGE_BUCKET}/init_output/* ${STORAGE_BUCKET}/tpu_output

Jalankan pelatihan untuk 1.000 langkah

python mnist.py \
    --use_tpu=True \
    --master=$GRPC_SERVER \
    --train_file=${STORAGE_BUCKET}/data/train.tfrecords \
    --model_dir=${STORAGE_BUCKET}/tpu_output \
    --random_seed=12345 \
    --num_shards=1 \
    --batch_size=128 \
    --train_steps=1000 \
    --eval_steps=10

Output

  accuracy = 0.9910644, global_step = 1000, loss = 0.02514153

Kerugian tidak akan sama persis dengan model yang dilatih CPU, tetapi harus mendekati. Jika tidak mirip dengan model Anda, hal ini mungkin menunjukkan bahwa Anda menemukan bug di mesin eksekusi TPU. Sebelum mengirim laporan bug, periksa kembali hal-hal berikut:

Anda meneruskan num_shards=1 ke TPUConfig.
Anda tidak memiliki op acak dalam fungsi model, dan op acak dalam fungsi input Anda di-seed dengan benar.
Anda menggunakan file checkpoint awal yang sama untuk pelatihan CPU dan TPU.

Melakukan debug pelatihan TPU multi-core

Jika model Anda memang mengalami kerugian yang sama pada CPU dan TPU single-core, masalahnya kemungkinan adalah salah satu dari hal berikut:

(a) Penurunan terjadi karena varians acak alami saat melatih model neural dengan inisialisasi yang berbeda.

(b) Penurunan terjadi karena masalah terkait sharding data di TPU.

Untuk mengetahui apakah (a) masalahnya, latih ulang model lengkap pada CPU/GPU dan TPU multi-core menggunakan inisialisasi bobot yang sama, seperti di atas.

Jika Anda yakin bahwa penurunan akurasi secara signifikan secara statistik, masalah yang paling mungkin terkait dengan sharding data adalah:

Jika model Anda menggunakan normalisasi batch, ukuran tumpukan total kurang dari 256 (misalnya, kurang dari 32 per inti) dapat mengurangi akurasi.
Fungsi kerugian batch-wise terpengaruh oleh sharding. Fungsi kerugian tersebut biasanya cukup khusus. Misalnya, Karras et al. 2017 menggunakan diskriminator batch saat melatih jaringan saraf generatif berlawanan.

Pemecahan masalah VM TPU

Masalah dan solusi berikut hanya berlaku untuk konfigurasi VM TPU.

pemecahan masalah penyiapan gcloud

Masalah: gcloud components update menampilkan pesan error berikut:

ERROR: (gcloud.components.update)
You cannot perform this action because the Cloud SDK component manager is
disabled for this installation.

Solusi: Untuk menggunakan gcloud dengan TPU VM, Anda harus menggunakan penginstalan gcloud yang tidak dikelola melalui pengelola paket. Ikuti langkah-langkah berikut untuk menginstal gcloud dari kode sumber:

  sudo apt-get remove google-cloud-sdk
  curl -O https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-sdk-311.0.0-linux-x86_64.tar.gz
  tar -xzf google-cloud-sdk-311.0.0-linux-x86_64.tar.gz
  ./google-cloud-sdk/install.sh
  source ~/.bashrc

Masalah

Perintah gcloud compute tpus tpu-vm ssh ${TPU_NAME} --zone ${ZONE} menampilkan pesan error berikut:

Waiting for SSH key to propagate.
ssh: connect to host 34.91.136.59 port 22: Connection timed out
ssh: connect to host 34.91.136.59 port 22: Connection timed out
ssh: connect to host 34.91.136.59 port 22: Connection timed out
ERROR: (gcloud.compute.tpus.tpu-vm.ssh) Could not SSH into the instance.  It is possible that your SSH key has not propagated to the instance yet. Try running this command again.  If you still cannot connect, verify that the firewall and instance are set to accept ssh traffic.

Solusi

Mungkin ada yang salah dengan penerapan kunci SSH. Coba pindahkan kunci yang dibuat secara otomatis ke lokasi cadangan untuk memaksa gcloud membuatnya ulang:

mv ~/.ssh/google_compute_engine ~/.ssh/old-google_compute_engine
mv ~/.ssh/google_compute_engine.pub ~/.ssh/old-google_compute_engine.pub

Log debug

Framework Cloud TPU yang didukung, JAX, PyTorch, dan TensorFlow mengakses TPU melalui library bersama yang disebut libtpu yang ada di setiap VM TPU. Library ini mencakup compiler XLA yang digunakan untuk mengompilasi program TPU, runtime TPU yang digunakan untuk menjalankan program yang dikompilasi, dan driver TPU yang digunakan oleh runtime untuk akses level rendah ke TPU.

Library libtpu mencatat informasi log yang dapat berguna untuk proses debug. Secara default, log ini ditulis ke /tmp/tpu_logs pada setiap VM Cloud TPU. Variabel lingkungan berikut dapat ditetapkan sebelum Anda memulai pelatihan untuk mengubah perilaku logging:

TPU_LOG_DIR: direktori tempat log ditulis: Lokasi direktori ditetapkan secara default ke /tmp/tpu_logs. Direktori akan dibuat jika belum ada, tetapi tidak ada direktori induk yang dibuat. Jika terjadi error saat menemukan atau membuat direktori yang ditentukan, pesan akan dicetak ke stderr, tetapi program tidak akan dihentikan dan logging dinonaktifkan. Setel nama direktori ke "disabled" untuk menonaktifkan logging ke disk sepenuhnya.
TPU_MIN_LOG_LEVEL: tingkat keparahan minimum yang akan dicatat ke disk: Pilihannya adalah 0 (INFO), 1 (WARNING), 2 (ERROR), dan 3 (FATAL). Nilai defaultnya adalah 0.
TPU_STDERR_LOG_LEVEL: tingkat keparahan minimum yang akan dicatat ke stderr, selain disk, jika ada: Pilihannya sama seperti TPU_MIN_LOG_LEVEL. Defaultnya adalah 3.
TPU_MAX_LOG_SIZE_MB: ukuran maksimum dalam megabyte untuk setiap file log: File log baru akan otomatis dimulai saat file log sebelumnya mencapai sekitar ukuran ini. Default-nya adalah 1024.

Memecahkan masalah TensorFlow - TPU

Ringkasan

Terjadi masalah saat menghubungkan ke server TPU

Kehilangan koneksi ssh selama pelatihan

Men-debug error umum

Tidak dapat membuat TPU

Tidak dapat menggunakan sistem file lokal

Jenis data tidak didukung

Bentuk dinamis tidak didukung

Operasi TensorFlow tidak tersedia

Pesan error kehabisan memori

Masalah saat menghentikan eksekusi

Padding TensorFlow berlebihan

Mengurangi penggunaan memori

Ukuran atau model tumpukan terlalu besar

Meningkatkan kecepatan pelatihan

Terlalu sedikit langkah per eksekusi per loop pelatihan

Hambatan pemrosesan input

Waktu langkah lambat dan pemakaian MXU rendah

Padding TensorFlow berlebihan

Throughput lambat dan penggunaan memori rendah

Ukuran lapisan terlalu kecil

Pembuatan profil model level operasi

Men-debug penurunan akurasi model

Memahami sharding data (paralelisme data)

Pelatihan deterministik

Salin bobot awal

Putaran 1

Output 1

Putaran 2

Output 2

Pelatihan TPU single-core

Gunakan inisialisasi bobot yang sama seperti CPU

Jalankan pelatihan untuk 1.000 langkah

Output

Melakukan debug pelatihan TPU multi-core

Pemecahan masalah VM TPU

pemecahan masalah penyiapan gcloud

Log debug

Kehilangan koneksi `ssh` selama pelatihan