Masalah Kecerunan Lenyap & Meletup & Masalah ReLU Mati

Beli Saya Kopi☕

*Memo:

• Siaran saya menerangkan Overfitting dan Underfitting.
• Siaran saya menerangkan lapisan dalam PyTorch.
• Siaran saya menerangkan fungsi pengaktifan dalam PyTorch.
• Siaran saya menerangkan fungsi kehilangan dalam PyTorch.
• Siaran saya menerangkan pengoptimum dalam PyTorch.

Masalah Kecerunan Lenyap:

• adalah semasa perambatan belakang, kecerunan menjadi lebih kecil dan lebih kecil atau mendapat sifar, mendarabkan kecerunan kecil bersama-sama berkali-kali daripada lapisan keluaran ke lapisan input, maka model tidak boleh dilatih dengan berkesan.
• lebih mudah berlaku dengan lebih banyak lapisan dalam model.
• mudah disebabkan oleh Fungsi pengaktifan Sigmoid iaitu Sigmoid() dalam PyTorch kerana ia menghasilkan nilai kecil yang julatnya ialah 0
• berlaku dalam:
  • CNN(Rangkaian Neural Konvolusi).
  • RNN(Rangkaian Neural Berulang) iaitu RNN() dalam PyTorch.
• tidak mudah berlaku dalam:
  • LSTM(Memori Jangka Pendek Panjang) iaitu LSTM() dalam PyTorch.
  • GRU(Unit Berulang Berpagar) iaitu GRU() dalam PyTorch.
  • Resnet(Rangkaian Neural Residual) iaitu Resnet dalam PyTorch.
  • Transformer iaitu Transformer() dalam PyTorch.
  • dll.
• boleh dikesan jika:
  • parameter berubah dengan ketara pada lapisan berhampiran lapisan output manakala parameter berubah sedikit atau kekal tidak berubah pada lapisan berhampiran lapisan input.
  • Berat lapisan berhampiran lapisan input adalah hampir 0 atau menjadi 0.
  • penumpuan adalah perlahan atau terhenti.
• boleh dikurangkan dengan:
  • Lapisan Normalisasi Kelompok iaitu BatchNorm1d(), BatchNorm2d() atau BatchNorm3d() dalam PyTorch.
  • Fungsi pengaktifan ReLU yang bocor iaitu LeakyReLU() dalam PyTorch. *Anda juga boleh menggunakan fungsi pengaktifan ReLU iaitu ReLU() dalam PyTorch tetapi kadangkala ia menyebabkan Masalah ReLU Mati yang saya terangkan kemudian.
  • Fungsi pengaktifan PReLU iaitu PReLU() dalam PyTorch.
  • Fungsi pengaktifan ELU iaitu ELU() dalam PyTorch.
  • Keratan Kecerunan iaitu clip_grad_norm_() atau clip_grad_value_() dalam PyTorch. *Keratan Kecerunan ialah kaedah untuk mengekalkan kecerunan dalam julat tertentu.

Masalah Kecerunan Meletup:

• adalah semasa perambatan belakang, kecerunan menjadi lebih besar dan lebih besar, mendarabkan kecerunan yang lebih besar bersama-sama berkali-kali daripada lapisan output ke lapisan input, kemudian penumpuan menjadi mustahil.
• lebih mudah berlaku dengan lebih banyak lapisan dalam model.
• berlaku dalam:
  • CNN.
  • RNN.
  • LSTM.
  • GRU.
• tidak mudah berlaku dalam:
  • Resnet.
  • Pengubah.
  • dll.
• boleh dikesan jika:
  • Berat model meningkat dengan ketara.
  • Berat model yang meningkat dengan ketara akhirnya menjadi NaN.
  • penumpuan turun naik tanpa selesai.
• boleh dikurangkan dengan:
  • Lapisan Normalisasi Kelompok.
  • Keratan Kecerunan.

Masalah ReLU Meninggal Dunia:

• adalah semasa perambatan balik, sebaik sahaja nod(neuron) dengan fungsi pengaktifan ReLU menerima sifar atau nilai input negatif, ia sentiasa menghasilkan sifar untuk sebarang nilai input, akhirnya, ia tidak pernah dipulihkan untuk menghasilkan sebarang nilai kecuali sifar, maka model tidak boleh dilatih dengan berkesan.
• juga dipanggil Masalah ReLU Mati.
• lebih mudah berlaku dengan:
  • kadar pembelajaran yang lebih tinggi.
  • berat sebelah negatif yang lebih tinggi.
• boleh dikesan jika:
  • penumpuan adalah perlahan atau terhenti.
  • fungsi kerugian mengembalikan nan.
• boleh dikurangkan dengan:
  • kadar pembelajaran yang lebih rendah.
  • berat sebelah positif.
  • Fungsi pengaktifan ReLU yang bocor.
  • Fungsi pengaktifan PReLU.
  • Fungsi pengaktifan ELU.

Atas ialah kandungan terperinci Masalah Kecerunan Lenyap & Meletup & Masalah ReLU Mati. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!