Bab 1–Pembelajaran Mendalam dan Badai

Sempurna

Minat terhadap Pembelajaran Mesin (Machine Learning) meledak dalam dekade terakhir. Dunia ini
perputaran kita sedang mengalami transformasi dan kita melihat interaksi yang semakin besar dari aplikasi-aplikasi
komputer dengan manusia. Perangkat lunak deteksi spam, sistem rekomendasi, penandaan
dalam foto media sosial, asisten pribadi yang diaktifkan dengan suara, mobil otonom, smartphone dengan
pengenalan wajah dan banyak lagi.

Dan minat terhadap Pembelajaran Mesin semakin jelas terlihat dari jumlah yang semakin meningkat dari
konferensi, meetup, artikel, buku, kursus, pencarian di Google dan profesional serta perusahaan yang mencari
memahami apa itu dan bagaimana menggunakan pembelajaran mesin, meskipun banyak yang masih bingung tentang apa yang dapat
melakukan apa yang mereka inginkan. Tidak ada cara untuk tidak peduli pada revolusi ini yang dibawa oleh pembelajaran
mesin dan, menurut Gartner, hingga 2020 semua perangkat lunak perusahaan akan memiliki beberapa fungsionalitas terkait
Pembelajaran Mesin.

Pada dasarnya, Pembelajaran Mesin adalah penggunaan algoritma untuk mengekstrak informasi dari data mentah
e mewakili mereka melalui semacam model matematis. Kami kemudian menggunakan model ini untuk melakukan
inferensi dari kumpulan data lain. Ada banyak algoritma yang memungkinkan untuk melakukan ini, tetapi
sebuah jenis khusus telah menonjol, jaringan saraf buatan.

Jaringan syaraf buatan tidaklah baru, sudah ada setidaknya sejak tahun 1950-an.
Namun selama beberapa dekade, meskipun arsitektur model-model ini telah berkembang, masih ada kekurangan
bahan-bahan yang membuat model benar-benar berfungsi. Dan bahan-bahan ini muncul hampir pada saat yang sama
tempo. Salah satunya mungkin sudah Anda dengar: Big Data. Volume data, yang dihasilkan dalam variasi dan kecepatan
setiap kali semakin besar, memungkinkan untuk membuat model dan mencapai tingkat akurasi yang tinggi. Tapi masih ada satu bahan yang kurang.
Faltava! Bagaimana cara memproses model Machine Learning besar dengan jumlah data yang besar? Seperti
CPU tidak dapat menangani tugas tersebut.

Itulah ketika para gamer dan hasrat mereka akan daya komputasi dan grafik yang sempurna, membantu kami menemukan
bahan kedua: Pemrograman Paralel di GPU. Unit pemrosesan grafis, yang memungkinkan
melakukan operasi matematika secara paralel, terutama operasi dengan matriks dan vektor,
elemen-elemen yang hadir dalam model jaringan saraf buatan, membentuk badai sempurna, yang memungkinkan untuk
evolusi yang kita hadapi saat ini: Big Data + Pemrosesan Paralel + Model Pembelajaran
Mesin = Kecerdasan Buatan.

Unitas dasar dari jaringan saraf buatan adalah sebuah simpul (atau neuron matematis), yang pada gilirannya adalah
berdasarkan pada neuron biologis. Koneksi antara neuron matematis ini juga terinspirasi
pada otak biologis, terutama dalam cara koneksi ini berkembang seiring waktu
Dengan "pelatihan". Di tengah tahun 1980-an dan awal tahun 1990-an, banyak kemajuan penting
di arsitektur jaringan saraf buatan terjadi. Namun, jumlah waktu dan data yang diperlukan
untuk mendapatkan hasil yang baik, penyesuaian ditunda dan, oleh karena itu, minat menjadi surut, sehingga yang tersisa
pengetahuan sebagai AI Winter (Musim Dingin AI).

Pada awal tahun 2000, daya komputasi berkembang secara eksponensial dan pasar melihat sebuah
ledakan teknik komputasional yang tidak mungkin dilakukan sebelumnya. Itu adalah saat ketika pembelajaran
profundo (Deep Learning) muncul dari pertumbuhan komputasi yang eksplosif dekade ini sebagai yang utama
mekanisme pembangunan sistem Kecerdasan Buatan, memenangkan banyak kompetisi penting
dari pembelajaran mesin. Minat terhadap Deep Learning terus berkembang dan hari ini kita melihat istilah
pembelajaran mendalam disebutkan dengan frekuensi yang semakin meningkat dan solusi komersial muncul
setiap saat.
Buku online ini, gratis dan dalam bahasa Portugis, adalah inisiatif dariAkademi Ilmu Datauntuk membantu mereka yang
yang mencari pengetahuan lanjutan dan berkualitas dalam bahasa kami. Akan ada lebih dari 50 bab,
dipublikasikan dalam format pos dan dirilis setiap minggu. Dengan cara ini, kami berharap dapat berkontribusi untuk
pertumbuhan Deep Learning dan Kecerdasan Buatan di Brasil.

Ikuti kami dalam perjalanan luar biasa ini!

Tim DSA
Bab 2–Sejarah Singkat Jaringan
Neurais Artificiais

Untuk memahami di mana kita berada hari ini, kita perlu melihat ke masa lalu dan menganalisis bagaimana kita sampai di sini.
Mari kita lihat Sejarah Singkat Jaringan Saraf Buatan.

O cérebro humano é uma máquina yang sangat kuat dan kompleks yang mampu memproses banyak.
jumlah informasi dalam waktu minimum. Unit utama otak adalah neuron dan itu adalah karena
sebagian dari mereka bahwa informasi ditransmisikan dan diproses. Tugas yang dilakukan oleh otak membuat bingung
peneliti, seperti misalnya, kemampuan otak untuk mengenali wajah yang akrab di antara sebuah
kerumunan dalam hanya milidetik. Jawaban tentang beberapa teka-teki fungsi otak
masih belum terjawab dan terus berlanjut hingga hari ini. Apa yang diketahui tentang cara kerja
do otak adalah bahwa ia mengembangkan aturannya melalui pengalaman yang diperoleh dari situasi yang dialami
sebelumnya.

Fig1–Otak manusia, mesin paling fantastis yang ada di Planet Bumi.

Perkembangan otak manusia terjadi terutama dalam dua tahun pertama kehidupan, tetapi jika
menghancurkan sepanjang hidup. Terinspirasi oleh model ini, berbagai peneliti mencoba mensimulasikan
fungsi otak, terutama proses pembelajaran melalui pengalaman, dengan tujuan untuk menciptakan
sistem pintar yang mampu melakukan tugas seperti klasifikasi, pengenalan pola,
proses pengolahan gambar, di antara aktivitas lainnya. Sebagai hasil dari penelitian ini muncul model dari
neurônio buatan dan selanjutnya sebuah sistem dengan berbagai neuron yang saling terhubung, yang disebut Jaringan
Neural.

Pada tahun 1943, neurofisiolog Warren McCulloch dan matematikawan Walter Pitts menulis sebuah artikel tentang
bagaimana neuron dapat berfungsi dan untuk itu, mereka memodelkan jaringan saraf sederhana menggunakan
ringkaian listrik.

Warren McCulloch dan Walter Pitts menciptakan model komputer untuk jaringan saraf yang didasarkan pada
matematika dan algoritma yang disebut logika ambang (threshold logic). Model ini membuka jalan untuk
penelitian jaringan saraf dibagi menjadi dua pendekatan: satu pendekatan yang fokus pada proses biologis di
otak, sementara yang lain terfokus pada penerapan jaringan saraf dalam kecerdasan buatan.
Pada tahun 1949, Donald Hebb menulis The Organization of Behavior, sebuah karya yang menunjukkan fakta bahwa
jalur saraf diperkuat setiap kali digunakan, konsep yang secara fundamental sangat penting untuk
cara manusia belajar. Jika dua saraf menembak pada waktu yang sama, dia berargumentasi, koneksi
di antara mereka adalah lebih baik.

Seiring dengan kemajuan komputer pada tahun 1950-an, akhirnya memungkinkan untuk
mensimulasikan jaringan saraf hipotetis. Langkah pertama untuk ini dilakukan oleh Nathanial Rochester dari
laboratorium penelitian IBM. Sayangnya baginya, percobaan pertama untuk melakukannya gagal.

Namun, selama waktu ini, para pembela "mesin berpikir" terus berargumen.
penelitian. Pada tahun 1956, Proyek Penelitian Musim Panas Dartmouth tentang Kecerdasan Buatan
memberikan dorongan baik pada Kecerdasan Buatan maupun Jaringan Saraf. Salah satu hasil dari ini
proses tersebut bertujuan untuk merangsang penelitian di bidang IA dalam pengolahan neural.

Pada tahun-tahun berikutnya setelah Proyek Dartmouth, John von Neumann menyarankan untuk meniru fungsi sederhana dari neuron.
menggunakan relay telegram atau tabung vakum. Selain itu, Frank Rosenblatt, seorang neurobiolog, mulai
bekerja di Perceptron. Dia merasa tertarik dengan cara kerja mata seekor lalat. Sebagian besar dari
proses yang dilakukan oleh seekor lalat saat memutuskan untuk melarikan diri, dilakukan di matanya. Perceptron, yang dihasilkan dari ini
penelitian, dibangun di atas perangkat keras dan merupakan jaringan saraf tertua yang masih digunakan hingga saat ini. Sebuah Perceptron dari
lapisan tunggal berguna untuk mengklasifikasikan sekumpulan entri dengan nilai kontinu ke dalam salah satu dari dua kelas.
Perceptron menghitung jumlah tertimbang dari input, mengurangi sebuah batas dan melewatkan salah satu dari dua nilai.
kemungkinan sebagai hasil. Sayangnya, Perceptron terbatas dan terbukti demikian selama "tahun
desiludidos" oleh Marvin Minsky dan buku Seymour Papert tahun 1969, Perceptrons.

Gambar2–Beberapa Arsitektur Jaringan Saraf

Pada tahun 1959, Bernard Widrow dan Marcian Hoff, dari Stanford, mengembangkan model yang disebut
"ADALINE" dan "MADALINE". Dalam sebuah pameran khas cinta Stanford terhadap akronim, nama-nama berasal dari
penggunaan beberapa elemen LINier ADAPtif. ADALINE dikembangkan untuk mengenali pola
binari sehingga, jika ia sedang membaca bit transmisi dari saluran telepon, ia bisa memperkirakan
bit berikutnya. MADALINE adalah jaringan saraf pertama yang diterapkan pada masalah dunia nyata, menggunakan sebuah
filter adaptif yang menghilangkan gema di jalur telepon. Meskipun sistem ini seoldah tua seperti sistem
pengendalian lalu lintas udara, ia masih digunakan secara komersial.

Sayangnya, keberhasilan-keberhasilan sebelumnya membuat orang-orang melebih-lebihkan potensi jaringan saraf,

terutama mengingat keterbatasan dalam elektronik yang tersedia pada waktu itu. Pembrang yang berlebihan ini, yang
terjadi di dunia akademis dan teknis, menginfeksi sastra umum pada masa itu. Banyak janji dibuat,
tetapi hasilnya adalah kekecewaan. Selain itu, banyak penulis mulai merenungkan tentang efek yang
teria "mesin berpikir" dalam manusia. Seri Asimov tentang robot mengungkapkan efeknya terhadap moral dan
nilai-nilai manusia ketika mesin mampu melakukan semua pekerjaan umat manusia. Lainnya
penulis menciptakan komputer yang lebih menyeramkan, seperti HAL dari film 2001.

Seluruh diskusi ini tentang dampak Kecerdasan Buatan terhadap kehidupan manusia, dikombinasikan dengan sedikit
kemajuan, membuat suara yang dihormati mengkritik penelitian tentang jaringan saraf. Hasilnya adalah pengurangan drastis
sebagian besar dari pendanaan dalam penelitian. Periode pertumbuhan terhambat ini berlangsung hingga 1981,
dikenal sebagai Musim Dingin AI (AI Winter).

Pada tahun 1982, beberapa peristiwa memicu minat yang baru. John Hopfield dari Caltech mempersembahkan sebuah
dokumen kepada Akademi Ilmu Pengetahuan Nasional. Pendekatan Hopfield tidak sekadar memodelkan
otak, tetapi menciptakan perangkat yang berguna. Dengan kejelasan dan analisis matematis, ia menunjukkan bagaimana jaringan ini
mungkin bekerja dan apa yang bisa mereka lakukan. Namun, sumber daya terbesar Hopfield adalah karismanya. Dia adalah
berartikulasi dan simpatik dan itu banyak membantu agar dia didengar.

Pada tahun 1985, Institut Fisika Amerika memulai apa yang menjadi pertemuan tahunan - Jaringan Saraf untuk
Komputasi. Pada tahun 1987, Konferensi Internasional Pertama tentang Jaringan Saraf dari Institute of Electrical
dan Insinyur Elektronik (IEEE) menarik lebih dari 1.800 peserta.

Pada tahun 1986, dengan jaringan saraf berlapis-lapis dalam berita, masalahnya adalah bagaimana memperluas aturan Widrow-
Hoff untuk beberapa lapisan. Tiga kelompok peneliti independen, di antaranya David Rumelhart,
mantan anggota departemen psikologi Stanford, menyajikan ide-ide serupa yang sekarang adalah
panggilan jaringan Backpropagation karena mendistribusikan kesalahan pengenalan pola di seluruh jaringan.
Jaringan hibrida hanya menggunakan dua lapisan, sementara jaringan Backpropagation menggunakan banyak lapisan.
hasilnya adalah bahwa jaringan Backpropagation "belajar" lebih lambat, karena memerlukan,
kemungkinan, ribuan iterasi untuk belajar, tetapi menghasilkan hasil yang sangat tepat.

Sekarang, jaringan saraf digunakan dalam berbagai aplikasi. Ide dasar di balik sifat jaringan
neura adalah bahwa jika ia berfungsi di alam, harus mampu berfungsi di komputer. Masa depan dari
jaringan saraf, namun, terletak pada pengembangan perangkat keras. Jaringan saraf yang cepat dan efisien
bergantung pada perangkat keras yang ditentukan untuk penggunaan akhirnya.

Diagram di bawah menunjukkan beberapa tonggak penting dalam evolusi dan penelitian jaringan saraf buatan.
Faktanya, kami masih menulis cerita ini dan banyak evolusi sedang terjadi saat ini, melalui
dari kerja ribuan peneliti dan profesional Kecerdasan Buatan di seluruh dunia. Dan Anda,
tidak mau membantu menulis cerita ini?
 Gambar3–Marcos dalam pengembangan jaringan saraf.

Kita dapat merangkum seperti ini tonggak utama dalam penelitian dan evolusi jaringan saraf buatan sampai
kami sampai pada Pembelajaran Mendalam:

1943: Warren McCulloch dan Walter Pitts menciptakan model komputasional untuk jaringan saraf berdasarkan
matematika dan algoritma yang dikenal sebagai logika ambang.

1958: Frank Rosenblatt menciptakan Perceptron, sebuah algoritma untuk pengenalan pola yang didasarkan pada sebuah
jaringan saraf komputasi dua lapisan menggunakan penjumlahan dan pengurangan sederhana. Dia juga mengusulkan lapisan
tambahan dengan notasi matematis, tetapi itu tidak akan dilakukan sampai tahun 1975.

1980: Kunihiko Fukushima mengusulkan Neoconitron, sebuah jaringan saraf hierarki, multilapis, yang telah
digunakan untuk pengenalan tulisan tangan dan masalah pengenalan pola lainnya.

1989: para ilmuwan berhasil menciptakan algoritma yang menggunakan jaringan saraf dalam, tetapi waktu untuk
pelatihan untuk sistem telah diukur dalam hari, menjadikannya tidak praktis untuk digunakan di dunia nyata.

1992: Juyang Weng menerbitkan Cresceptron, sebuah metode untuk melakukan pengenalan objek 3-D
secara otomatis dari adegan yang tidak teratur.

Pertengahan tahun 2000-an: istilah "pembelajaran mendalam" mulai mendapatkan popularitas setelah sebuah artikel dari
Geoffrey Hinton dan Ruslan Salakhutdinov menunjukkan bagaimana jaringan saraf bertingkat dapat dipra...
dilatih satu lapisan pada satu waktu.

2009: terjadi Workshop NIPS tentang Pembelajaran Mendalam untuk Pengenalan Suara dan menemukan-
saya tahu bahwa dengan sekumpulan data yang cukup besar, jaringan syaraf tidak perlu pra-pelatihan
dan tingkat kesalahan menurun secara signifikan.

2012: algoritma pengenalan pola buatan mencapai kinerja setara manusia dalam
tugas tertentu. Dan algoritma pembelajaran mendalam dari Google mampu mengidentifikasi kucing.

2014: Google membeli sebuah Startup Kecerdasan Buatan bernama DeepMind, dari Inggris, seharga £
400m
2015: Facebook menerapkan teknologi pembelajaran mendalam yang disebut DeepFace untuk
menandai dan mengidentifikasi pengguna Facebook secara otomatis dalam foto. Algoritme menjalankan tugas
superior pengenalan wajah menggunakan jaringan dalam yang mempertimbangkan 120 juta
parameter

2016: algoritma Google DeepMind, AlphaGo, memetakan seni permainan papan kompleks Go dan menang
juara dunia Go, Lee Sedol, dalam turnamen yang sangat dipublikasikan di Seoul.

2017: adopsi massal Deep Learning dalam berbagai aplikasi korporat dan mobile, serta kemajuan dalam
penelitian. Semua acara teknologi yang terkait dengan Data Science, AI, dan Big Data, menunjukkan Deep Learning
sebagai teknologi utama untuk pembuatan sistem cerdas.

Janji pembelajaran mendalam bukanlah agar komputer mulai berpikir seperti manusia.
Ini seperti meminta sebuah apel untuk menjadi jeruk. Sebaliknya, ini menunjukkan bahwa, mengingat satu set dari
data yang cukup besar, prosesor cepat dan algoritma yang cukup canggih,
komputer dapat mulai melakukan tugas yang sebelumnya hanya dapat dilakukan oleh makhluk hidup
manusia, bagaimana mengenali gambar dan suara, menciptakan karya seni atau mengambil keputusan sendiri.

Studi tentang jaringan saraf mengalami revolusi besar sejak tahun 80-an dan bidang studi ini
telah menonjol, baik karena karakteristik menjanjikan yang ditampilkan oleh model jaringan saraf
diusulkan, baik oleh kondisi teknologi saat ini yang memungkinkan pengembangan yang berani
implementasi arsitektur neural paralel di perangkat keras khusus, sehingga mendapatkan hasil yang sangat baik
kinerja sistem ini (yang jauh lebih unggul dibandingkan dengan sistem konvensional). Evolusi alami jaringan
neurai, adalah jaringan saraf dalam (atau Deep Learning). Tapi ini adalah apa yang akan kita diskusikan pada berikutnya
bab! Sampai jumpa.
Bab 3–Apa Itu Jaringan Saraf Buatan
Pembelajaran mendalam atau Deep Learning?

Pembelajaran Mendalam atau Deep Learning, adalah sub-area dari Pembelajaran Mesin, yang digunakan
algoritme untuk memproses data dan meniru pemrosesan yang dilakukan oleh otak manusia. Tapi Apa Itu Jaringan
Neuronal Buatan Dalam atau Deep Learning? Itu yang akan kita lihat di bab ini. Jangan khawatir jika beberapa
istilah-istilah yang lebih teknis tidak membuat sentido sekarang. Semua akan dipelajari sepanjang buku online ini.

Deep Learning menggunakan lapisan neuron matematis untuk memproses data, memahami ucapan manusia dan
mengenali objek secara visual. Informasi disampaikan melalui setiap lapisan, dengan keluaran dari lapisan
anterior menyediakan masukan untuk lapisan berikutnya. Lapisan pertama dalam jaringan disebut lapisan
di awal, sementara yang terakhir disebut lapisan keluaran. Semua lapisan di antara keduanya disebut
seperti lapisan tersembunyi. Setiap lapisan biasanya merupakan algoritma sederhana dan seragam yang berisi suatu jenis dari
fungsi aktivasi.

Fig4–Jaringan Saraf Sederhana dan Jaringan Saraf Dalam (Deep Learning)

Pembelajaran mendalam bertanggung jawab atas kemajuan terbaru dalam visi komputer, pengenalan
fala, pemrosesan bahasa alami dan pengenalan audio. Pembelajaran mendalam didasarkan pada
konsep jaringan saraf buatan, atau sistem komputasi yang meniru cara kerja otak
humano berfungsi.

Ekstraksi sumber daya adalah aspek lain dari Pembelajaran Dalam. Ekstraksi sumber daya menggunakan algoritma
untuk membangun secara otomatis "sumber daya" yang berarti dari data untuk tujuan pelatihan, pembelajaran dan
pemahaman. Normalmente, Ilmuwan Data, atau Insinyur AI, bertanggung jawab untuk ekstraksi dari
sumber daya.

Peningkatan cepat dan dominasi yang tampak dari pembelajaran mendalam atas metode tradisional dari
pembelajaran mesin dalam berbagai tugas telah mengejutkan untuk disaksikan dan, terkadang,
sulit untuk dijelaskan. Deep Learning adalah evolusi dari Jaringan Saraf, yang memiliki sejarahnya sendiri.
fascinasi yang berasal dari dekade 1940-an, penuh dengan pasang surut, perubahan dan pergolakan, teman-teman dan saingan,
sukses dan kegagalan. Dalam cerita yang layak untuk film tahun 90-an, sebuah ide yang pernah menjadi semacam
bebek jelek berkembang menjadi bintang saat ini.

Akibatnya, minat dalam pembelajaran mendalam telah meningkat pesat, dengan liputan konstan di media.
populer. Penelitian pembelajaran mendalam kini muncul secara rutin di jurnal seperti Science,
Alam, Metode Alam dan Forbes hanya untuk menyebutkan beberapa. Pembelajaran mendalam telah menguasai Go,
belajar mengemudikan mobil, didiagnosis kanker kulit dan autisme, menjadi seorang pemalsu seni yang hebat
dan bisa bahkan berhalusinasi gambar fotorealistik.

Algoritma-algoritma pembelajaran mendalam pertama yang memiliki beberapa lapisan fitur tidak-
linear dapat ditelusuri sampai Alexey Grigoryevich Ivakhnenko (mengembangkan Metode Grup
Manipulasi Data) dan Valentin Grigor’evich Lapa (pengarang Cybernetics and Forecasting Techniques)
pada tahun 1965 (Gambar 5), yang menggunakan model yang lebih halus tetapi lebih dalam dengan fungsi aktivasi polinomial yang mana
mereka menganalisis dengan metode statistik. Di setiap lapisan, mereka memilih fitur terbaik melalui
metode statistik dan mengarahkan ke lapisan berikutnya. Mereka tidak menggunakan Backpropagation untuk
melatih jaringan dari awal hingga akhir, tetapi menggunakan kuadrat minimum lapis-demi-lapis, di mana lapisan
yang sebelumnya telah dipasang secara independen di lapisan belakang (sebuah proses yang lambat dan manual).

Gambar 5 - Arsitektur dari jaringan dalam pertama yang dikenal dilatih oleh Alexey Grigorevich Ivakhnenko pada
1965.

Pada akhir dekade 1970-an, musim dingin AI yang pertama dimulai, sebagai hasil dari janji-janji yang tidak dapat dipenuhi.
ser dipertahankan. Dampak dari kekurangan pembiayaan ini membatasi penelitian dalam Jaringan Saraf Dalam dan
Kecerdasan Buatan. Untungnya, ada individu yang melakukan penelitian tanpa pendanaan.
Jaringan saraf konvolusional yang pertama kali digunakan oleh Kunihiko Fukushima. Fukushima merancang
jaringan saraf dengan beberapa lapisan pengelompokan dan konvolusi. Pada tahun 1979, ia mengembangkan sebuah jaringan
neural artificial, yang disebut Neocognitron, yang menggunakan desain hierarkis dan multilapis. Desain ini
memungkinkan komputer untuk "belajar" mengenali pola visual. Jaringan-jaringan itu menyerupai versi
modernas, tetapi telah dilatih dengan strategi penguatan aktivasi berulang di beberapa lapisan,
yang semakin kuat seiring berjalannya waktu. Selain itu, desain Fukushima memungkinkan sumber daya
importantes fossem ajustados manualmente aumentando o “peso” de certas conexões.

Banyak dari konsep Neocognitron masih digunakan. Penggunaan koneksi dari atas ke bawah dan
metode pembelajaran baru telah memungkinkan pelaksanaan berbagai jaringan saraf. Ketika lebih
di mana pola disajikan pada saat yang sama, Model Perhatian Selektif dapat memisahkan dan mengenali
pola individu mengalihkan perhatiannya dari satu ke yang lain (proses yang sama yang kami gunakan di
multitasking). Sebuah Neocognitron modern tidak hanya dapat mengidentifikasi pola dengan informasi yang hilang (oleh
contoh, sebuah angka 5 digambar dengan cara yang tidak lengkap), tetapi juga bisa menyelesaikan gambar
menambahkan informasi yang hilang. Ini dapat digambarkan sebagai "inferensi".

O Backpropagation, penggunaan kesalahan dalam pelatihan model Deep Learning, telah berkembang secara signifikan
pada tahun 1970. Saat itulah Seppo Linnainmaa menulis tesis masternya, termasuk kode FORTRAN
para Backpropagation. Sayangnya, konsep tersebut tidak diterapkan pada jaringan syaraf hingga 1985. Saat itulah
Rumelhart, Williams dan Hinton menunjukkan Backpropagation dalam jaringan saraf yang dapat menyediakan
representasi distribusi 'menarik'. Secara filosofis, penemuan ini mengangkat pertanyaan
dalam psikologi kognitif untuk mengetahui apakah pemahaman manusia bergantung pada logika simbolis
(komputasionalisme) atau representasi terdistribusi (koneksi). Pada tahun 1989, Yann LeCun memberikan
primeira demonstração prática de Backpropagation no Bell Labs. Ele combinou redes neurais convolutivas
dengan Backpropagation untuk membaca angka "tulisan tangan" (topik pada bab berikutnya). Sistem ini telah
digunakan untuk membaca nomor cek yang ditulis tangan.

Gambar 6 - Para pelopor Kecerdasan Buatan. Dari kiri ke kanan: Yann LeCun, Geoffrey
Hinton, Yoshua Bengio dan Andrew Ng
Namun, kita mengalami periode yang dikenal sebagai Musim Dingin II AI, yang terjadi antara 1985-
1990, yang juga mempengaruhi penelitian dalam Jaringan Saraf dan Pembelajaran Mendalam. Beberapa individu
secara berlebihan optimis telah melebih-lebihkan potensi "segera" dari Kecerdasan Buatan, menghancurkan
harapan dan mengganggu para investor. Kemarahan begitu intens, sehingga frasa Kecerdasan Buatan mencapai
status pseudoscience. Untungnya, beberapa orang terus bekerja di AI dan Deep Learning, dan
beberapa kemajuan signifikan telah dibuat. Pada tahun 1995, Dana Cortes dan Vladimir Vapnik mengembangkan
mesin vektor pendukung atau Support Vector Machine (sistem untuk memetakan dan mengenali data
LSTM (Long-Short Term Memory) untuk jaringan saraf berulang dikembangkan pada
1997, oleh Sepp Hochreiter dan Juergen Schmidhuber.

Langkah evolusi signifikan berikutnya untuk Deep Learning terjadi pada tahun 1999, ketika komputer
mulai menjadi lebih cepat dalam pemrosesan data dan GPU (unit pemrosesan)
grafik) dikembangkan. Penggunaan GPU berarti loncatan dalam waktu pemrosesan, menghasilkan
dalam peningkatan kecepatan komputasi sebesar 1000 kali selama periode 10 tahun.
Selama periode ini, jaringan saraf mulai bersaing dengan mesin vektor dukungan. Sementara
sebuah jaringan saraf bisa lebih lambat dibandingkan dengan mesin vektor pendukung, jaringan saraf
menawarkan hasil yang lebih baik menggunakan data yang sama. Jaringan saraf juga memiliki keuntungan dari
terus meningkatkan seiring dengan penambahan lebih banyak data pelatihan.

Sekitar tahun 2000, muncul masalah yang dikenal sebagai Gradien Menghilang. Ditemukan bahwa
“karakteristik” yang dipelajari di lapisan yang lebih rendah tidak dipelajari oleh lapisan atas, karena
tidak ada tanda-tanda pembelajaran yang mencapai lapisan-lapisan ini. Ini bukan masalah mendasar bagi semua
jaringan saraf, hanya yang memiliki metode pembelajaran berbasis gradien. Asal dari
masalahnya akhirnya menjadi beberapa fungsi aktivasi. Serangkaian fungsi aktivasi mengkondensasi mereka
masuk, mengurangi, pada gilirannya, rentang keluaran dengan cara yang agak kacau. Ini menghasilkan area luas dari
entri yang dipetakan dalam rentang yang sangat kecil. Di area masuk ini, akan ada perubahan besar.
direduksi menjadi perubahan kecil dalam keluaran, menghasilkan gradien menurun. Dua solusi yang digunakan
Untuk menyelesaikan masalah ini, dilakukan pelatihan lapisan demi lapisan dan pengembangan memori.
jangka panjang dan jangka pendek.

Pada tahun 2001, sebuah laporan penelitian dari Grup META (sekarang disebut Gartner) menggambarkan tantangan dan
peluang dalam pertumbuhan volume data. Laporan tersebut menggambarkan peningkatan volume data dan
kecepatan data yang meningkat seiring dengan meningkatnya kisaran sumber dan jenis data. Ini adalah seruan untuk
bersiap untuk serangan Big Data, yang baru saja dimulai.

Pada tahun 2009, Fei-Fei Li, profesor IA di Stanford, California, meluncurkan ImageNet dan membangun sebuah basis data
data gratis lebih dari 14 juta gambar yang diberi label. Gambar-gambar yang ditandai diperlukan untuk
“melatih” jaringan saraf. Profesor Li berkata: “Visi kami adalah bahwa Big Data akan mengubah cara kita
Pembelajaran mesin berfungsi. Data mendorong pembelajaran.”. Dia benar-benar tepat!

Hingga 2011, kecepatan GPU meningkat secara signifikan, memungkinkan pembentukan jaringan saraf
konvolutif "tanpa" atau pra-latihan lapisan demi lapisan. Dengan meningkatnya kecepatan komputasi, menjadi
jelas bahwa Deep Learning memiliki keuntungan signifikan dalam hal efisiensi dan kecepatan. Sebuah
Contoh adalah AlexNet, sebuah jaringan saraf konvolusional, yang arsitekturnya telah memenangkan berbagai kompetisi
internasional selama 2011 dan 2012. Unit linear yang direktifikasi digunakan untuk meningkatkan
kecepatan.

Juga pada tahun 2012, Google Brain meluncurkan hasil dari proyek yang tidak biasa dikenal sebagai The Cat
Eksperimen. Proyek semangat bebas mengeksplorasi kesulitan 'pembelajaran tanpa supervisi'. A
Pembelajaran mendalam menggunakan "pembelajaran terawasi", yang berarti bahwa jaringan saraf konvolusional adalah
dilatih menggunakan data berlabel. Menggunakan pembelajaran tanpa pengawasan, sebuah jaringan saraf konvolusional adalah
diberi data yang tidak ditandai, dan kemudian diminta untuk mencari pola yang berulang.
Percobaan Kucing menggunakan jaringan saraf yang tersebar di lebih dari 1.000 komputer. Sepuluh juta
gambar "tanpa label" diambil secara acak dari YouTube, ditunjukkan kepada sistem dan kemudian
perangkat lunak pelatihan telah diizinkan untuk dijalankan. Di akhir pelatihan, sebuah neuron di lapisan
mais alta foi encontrado para responder fortemente às imagens de gatos. Andrew Ng, o fundador do projeto,
Kami juga menemukan neuron yang merespons kuat terhadap wajah manusia.
pembelajaran tidak terawasi tetap menjadi bidang penelitian yang aktif dalam Pembelajaran
Profunda.

Saat ini, pemrosesan Big Data dan evolusi Kecerdasan Buatan keduanya tergantung pada
Pembelajaran Mendalam. Dengan Pembelajaran Dalam kita dapat membangun sistem cerdas dan kita sedang dalam
mendekati penciptaan AI yang sepenuhnya otonom. Ini akan berdampak pada semua segmen dari
masyarakat dan mereka yang tahu bekerja dengan teknologi, akan menjadi pemimpin dunia baru ini yang
mempersembahkan di depan kami.

Di bab selanjutnya, Anda akan mulai memahami secara teknis bagaimana cara kerja Pembelajaran.
Profunda. Sampai bab 4.
Bab 4–Neuron, Biologis dan Matematis

Untuk memahami logika kerja jaringan saraf, beberapa konsep dasar yang berkaitan dengan
fungsi otak manusia dan komponennya, neuron, sangat penting.
pembentukan koneksi antara sel-sel dan beberapa pertimbangan tentang bagaimana secara teoritis konsep tersebut
fungsi matematika, membantu memahami dasar pembelajaran mesin dan jaringan saraf.
Mari kita lihat bagaimana neuron biologis berfungsi dengan meninggalkan Pembelajaran Mesin untuk sementara!

O Neurônio Biológico

Neuronal adalah unit dasar otak manusia, merupakan sel yang mengkhususkan diri dalam transmisi
informasi, karena di dalamnya diperkenalkan sifat eksitabilitas dan konduksi pesan
nervosa. Neuron terdiri dari 3 bagian utama: soma atau tubuh sel, yang memancarkan
beberapa cabang yang disebut dendrit, dan oleh cabang lain yang turun dari jumlah, namun
lebih luas, disebut akson. Di ujung-ujung akson terdapat saraf terminal, melalui mana adalah
realizada a transmissão das informações para outros neurônios. Esta transmissão é conhecida como sinapse.

Gambar7–Representasi Sederhana dari Neuron Biologis

Otak kita terdiri dari miliaran neuron. Tetapi mereka tidak terisolasi. Sebaliknya, ada
ratusan miliaran koneksi antara mereka, membentuk jaringan komunikasi yang besar, jaringan saraf. Setiap
neuron memiliki badan pusat, berbagai dendrit, dan sebuah akson. Dendrit menerima sinyal listrik dari
neurons lain melalui sinapsis, yang merupakan proses komunikasi antar neuron. Tubuh
sel sel memproses informasi dan mengirimkannya ke neuron lain.

Perhatikan bahwa soma dan dendrit membentuk permukaan masuk neuron dan akson adalah permukaan dari
keluar dari aliran informasi (aliran informasi ini penting untuk memahami neuron
matemático sebentar lagi). Informasi yang ditransmisikan oleh neuron sebenarnya adalah impuls listrik. Yang
impuls listrik adalah pesan yang dikirimkan neuron satu sama lain, yaitu penyebaran dari sebuah
stimulasi sepanjang neuron yang dapat berupa sinyal apa pun yang ditangkap oleh reseptor saraf.

Dendrit memiliki fungsi untuk menerima informasi, atau impuls saraf, yang berasal dari neuron lain dan
mengantarkan mereka ke tubuh sel. Di sana, informasi diproses dan impuls baru dihasilkan. Ini
impuls dihantarkan ke neuron lainnya, melewati akson dan mencapai dendrit neuron
selanjutnya. Badan neuron bertanggung jawab untuk mengumpulkan dan menggabungkan informasi yang berasal dari yang lain
neuron

Poin kontak antara terminasi akson neuron dan dendrit neuron lain disebut sinapsis. Itu adalah
melalui sinapsis di mana neuron-neuron saling terhubung secara fungsional, membentuk jaringan saraf. Sinapsis berfungsi
sebagai katup, yang mampu mengontrol transmisi impuls, yaitu, aliran informasi antara
neuron di jaringan saraf. Efek sinapsis bersifat bervariasi dan variasi inilah yang memberikan kemampuan kepada neuron untuk
adaptasi.

Sinyal listrik yang dihasilkan di sensor (retina mata, kuncup rasa, dll…) berjalan melalui akson. Jika
jika sinyal ini melebihi ambang batas (threshold), sinyal akan melanjutkan melalui akson. Jika tidak, sinyal akan
terhalang dan tidak dilanjutkan (dianggap tidak relevan). Perpindahan sinyal ini tidak bersifat elektrik, tetapi
kimia (melalui zat serotonin). Jika sinyal melebihi batas tertentu (ambang), teruskan;
jika tidak, akan diblokir dan tidak akan mengikuti. Kita sedang berbicara di sini tentang neuron biologis dan perhatikan dengan seksama
perhatian pada kata ambang, karena itu adalah esensi dari neuron matematis.

Sebuah neuron menerima sinyal melalui banyak dendrit, yang kemudian dipertimbangkan dan dikirim ke akson,
podendo atau tidak melanjutkan (ambang). Dalam perjalanan melalui neuron, sinyal dapat diperkuat atau
ditingkatkan, tergantung pada dendrit asal, karena setiap konduktor terkait dengan bobot yang mana sinyal
é dikalikan. Bobot adalah apa yang kita sebut sebagai memori.

Setiap wilayah di otak memiliki spesialisasi untuk fungsi tertentu, seperti pemrosesan sinyal pendengaran,
sonoros, pengembangan pemikiran, keinginan, dll... Proses ini terjadi melalui jaringan khusus
interconnected to each other, performing parallel processing. Each region of the brain has an architecture of
rede berbeda: bervariasi jumlah neuron, sinapsis per neuron, nilai ambang dan bobot,
dll...Nilai dari bobot ditetapkan melalui pelatihan yang diterima otak selama hidup
berguna. Ini adalah memori.

Terinspirasi oleh neuron biologis, para peneliti mengembangkan model neuron matematis yang
menjadi dasar Kecerdasan Buatan. Ideanya sederhana: “Jika jaringan neural membentuk kecerdasan
humana, mari kita reproduksi ini dan menciptakan Kecerdasan Buatan. Dan dengan demikian lahirlah neuron matematis,
yang kami jelaskan di bawah ini.

O Neurônio Matemático

Berdasarkan struktur dan fungsi neuron biologis, para peneliti mencoba menyimulasikan sistem ini.
di komputer. Model yang paling diterima baik diusulkan oleh Warren McCulloch dan Walter Pitts pada tahun 1943,
yang mengimplementasikan dengan cara yang disederhanakan komponen dan fungsi dari neuron biologis. Di
Dalam istilah sederhana, sebuah neuron matematis dari jaringan saraf buatan adalah komponen yang menghitung jumlah
ponderada dari beberapa input, menerapkan sebuah fungsi dan meneruskan hasilnya.

Dalam model neuron matematis ini, impuls listrik yang berasal dari neuron lain adalah
diwakili oleh apa yang disebut sinyal masukan (huruf x dalam diagram di bawah ini, yang tidak lebih dari
data yang memberi makan model jaringan saraf buatan Anda). Di antara berbagai rangsangan yang diterima, beberapa
akan lebih dan yang lain kurang membuat neuron penerima terangsang dan ukuran seberapa eksitatori rangsangan itu adalah
diwakili dalam model Warren McCulloch dan Walter Pitts melalui bobot sinaptik. Semakin besar
nilai berat, lebih eksitatori adalah rangsangan. Berat sinaptik direpresentasikan oleh wkn dalam diagram ini
di bawah, di mana k mewakili indeks neuron yang dimaksud dan n merujuk pada terminal masuk sinaps a
apa yang dimaksud dengan berat sinaptik.

Badan atau tubuh sel direpresentasikan oleh komposisi dari dua modul, yang pertama adalah sebuah persimpangan
aditiva, jumlah dari rangsangan (sinyal masukan) dikalikan dengan faktor eksitasi (bobot
sinaptik), dan selanjutnya fungsi aktivasi, yang akan menentukan berdasarkan input dan bobot sinaptik,
apa yang akan menjadi keluaran neuron. Aksion di sini direpresentasikan oleh keluarannya (yk) yang diperoleh dari penerapan fungsi
de ativasi. Sama seperti dalam model biologis, rangsangan dapat bersifat eksitatori atau inhibitori, yang direpresentasikan
pelo berat sinaptik positif atau negatif masing-masing.

Gambar 8 - Representasi Sederhana dari Neuron Matematis

Model yang diusulkan memiliki sifat biner. Baik sinyal masukan maupun keluaran adalah nilai
binari. McCulloch percaya bahwa fungsi sistem saraf pusat memiliki karakter biner,
Artinya, satu neuron mempengaruhi atau tidak mempengaruhi neuron lain, tetapi kemudian terbukti bahwa itu bukan dari ini
bentuk.

Neuron matematis adalah model yang disederhanakan dari neuron biologi. Model-model seperti itu terinspirasi dari
dari analisis generasi dan propagasi impuls listrik melalui membran sel neuron. Neuron
matematik menerima satu atau lebih sinyal input dan mengembalikan satu sinyal output, yang dapat didistribusikan
sebagai sinyal keluaran dari jaringan, atau sebagai sinyal masukan untuk satu atau beberapa neuron lain di lapisan
posterior (yang membentuk jaringan saraf buatan). Dendrit dan akson direpresentasikan secara matematis
hanya melalui sinapsis, dan intensitas hubungan diwakili oleh suatu besaran yang disebut bobot
sinaptik, dilambangkan dengan huruf w. Ketika input, x disajikan kepada neuron, mereka adalah
dikalikan dengan bobot sinaptik yang sesuai, menghasilkan input yang tertimbang, yaitu x1 yang
multiplica w1, dll... Ini menggambarkan salah satu dasar matematis dari cara kerja jaringan saraf
artificial, perkalian matriks:
 Gambar 9 – Perkalian Matriks Antara Sinyal Masukan x dan Bobot Sinaptik w (versi disederhanakan)

Neuronnya kemudian menjumlahkan semua produk untuk menghasilkan satu hasil. Fungsi ini disebut fungsi
kombinasi. Nilai ini kemudian disajikan kepada fungsi aktivasi atau fungsi transfer, yang
menyediakan, antara lain, tujuan untuk mencegah peningkatan progresif nilai keluaran sepanjang lapisan
da rede, visto que tais funções possuem valores máximos e mínimos contidos em intervalos determinados. O
penggunaan fungsi transfer non-linear menjadikan jaringan saraf alat yang kuat. Diketahui bahwa sebuah
jaringan perceptron dua lapisan dengan fungsi transfer non-linear seperti fungsi sigmoid (yang
kita akan melihat lebih lanjut), disebut sebagai pendekatan universal.

Sebuah neuron memicu ketika jumlah impuls yang diterimanya melebihi ambang eksitasinya
panggilan ambang. Badan neuron, pada gilirannya, disimulasi oleh mekanisme sederhana yang membuat
penjumlahan nilai xi dan wi yang diterima oleh neuron (penjumlahan terstandar) dan memutuskan apakah neuron harus atau tidak
disparar (keluaran sama dengan 1 atau 0) membandingkan jumlah yang diperoleh dengan ambang atau threshold neuron. Aktivasi
do neuron diperoleh melalui penerapan "fungsi aktivasi", yang mengaktifkan keluaran atau tidak,
tergantung pada nilai jumlah tertimbang dari masukan Anda.

Perhatikan bahwa model matematis sederhana dari neuron ini bersifat statis, yaitu tidak mempertimbangkan dinamika
pada neuron alami. Di neuron biologis, sinyal dikirim dalam pulsa dan beberapa komponen dari
neurônios biologis, seperti akson, berfungsi sebagai filter frekuensi.

Model neuron matematika juga dapat memasukkan polarisasi atau bias input. Variabel ini adalah
dimasukkan ke dalam penjumlahan fungsi aktivasi, dengan tujuan untuk meningkatkan derajat kebebasan fungsi ini dan,
akibatnya, kemampuan pendekatan jaringan. Nilai bias disesuaikan dengan cara yang sama seperti yang
pesos sinaptik. Bias memungkinkan neuron untuk menghasilkan keluaran yang tidak nol meskipun semua koneksi...
entri menjadi nol. Misalnya, jika tidak ada bias dan semua entri dari suatu neuron adalah
nulas, jadi nilai fungsi aktivasi akan menjadi nol. Dengan cara ini kita tidak bisa, misalnya, melakukan dengan
apa yang neuron belajar tentang hubungan yang relevan dengan 'atau eksklusif' dari logika. Singkatnya, kita memiliki ini
komponen dalam neuron matematis:

Gambar10–Representasi Neuron Matematika

 Sinyal input { X1, X2, …, Xn }: Merupakan sinyal eksternal yang biasanya dinormalisasi untuk meningkatkan
efisiensi komputasional dari algoritma pembelajaran. Data adalah yang memberi makan model Anda
prediktif.
Bobot sinaptik { W1, W2, …, Wn }: Adalah nilai untuk memberi bobot sinyal dari setiap masukan jaringan. Ini
nilai belajar selama pelatihan.
Combinador linear { Σ }: Menambahkan semua sinyal masukan yang telah dipertimbangkan dengan bobot yang sesuai
sinaptik untuk menghasilkan potensi aktivasi.
Ambang aktivasi { Θ }: Menentukan batas yang sesuai agar hasil yang dihasilkan oleh
kombinator linier dapat menghasilkan nilai pemicu aktivasi.
Potensi aktivasi { u }: Ini adalah hasil yang diperoleh dari selisih nilai yang dihasilkan antara penggabung linear
e ambang aktivasi. Jika nilainya positif, yaitu, jika u ≥ 0 maka neuron menghasilkan potensial
ekscitatif; jika tidak, potensinya akan bersifat inhibitor.
Fungsi aktivasi { g }: Tujuannya adalah untuk membatasi keluaran neuron dalam rentang nilai.
Sinyal keluaran { y}: Ini adalah nilai akhir keluaran yang dapat digunakan sebagai input untuk neuron lain yang sedang
berurutan terhubung.

Model-model yang berbasis pada jaringan saraf buatan adalah yang paling banyak mendapatkan perhatian dalam beberapa tahun terakhir karena
mampu menyelesaikan masalah IA di mana kemajuan yang diperoleh dengan teknik lain sangat sedikit. Sejak
konsep neuron matematis, berbagai arsitektur dan model dengan kombinasi berbeda antara ini
neuron, dan menerapkan berbagai teknik matematika dan statistik, muncul dan memfasilitasi penciptaan
arsitektur canggih Deep Learning seperti Jaringan Saraf Konvolusional, Jaringan Saraf Rekuren
Auto Enkoder, Jaringan Generatif Adversarial, Jaringan Memori, antara lain, yang akan kita pelajari pada
lama buku ini online.
Bab 5–Menggunakan Jaringan Syaraf Untuk
Mengakui Angka Tangan

Sistem penglihatan manusia adalah salah satu keajaiban dunia. Pertimbangkan urutan digit berikut
manuscritos:

Sebagian besar orang dengan mudah mengenali digit ini sebagai 504192. Kemudahan ini menipu.
setiap belahan otak kita, manusia memiliki korteks visual primer, juga dikenal
sebagai V1, yang mengandung 140 juta neuron, dengan puluhan miliar koneksi di antara mereka. Dan, di
Sementara itu, penglihatan manusia melibatkan tidak hanya V1, tetapi juga serangkaian korteks visual - V2, V3, V4 dan.
V5–melakukan pemrosesan gambar yang semakin kompleks. Kami memuat di dalam kami
kepala sebuah superkomputer, disetel melalui evolusi selama ratusan juta tahun, dan
soberbamente diadaptasi untuk memahami dunia visual. Mengenali digit yang ditulis tangan tidaklah mudah. Di
Selain itu, kita manusia sangat luar biasa, dengan mengejutkan baik, dalam memahami apa yang dilihat mata kita
Sebagian besar pekerjaan ini dilakukan tanpa disadari. Dan, oleh karena itu, kami umumnya tidak menghargai
betapa sulitnya masalah sistem visual kita.

Kesulitan dalam mengenali pola visual menjadi jelas jika Anda mencoba menulis sebuah program untuk
komputer untuk mengenali digit seperti di atas. Apa yang tampak mudah ketika kita manusia melakukannya,
tiba-tiba, menjadi sangat sulit. Intuisi sederhana tentang bagaimana kita mengenali bentuk– “sebuah 9 memiliki
um loop no topo e um curso vertical no canto inferior direito” –não é tão simples de se expressar
algoritmik. Ketika Anda mencoba membangun aturan ini dengan cara yang tepat, Anda dengan cepat tersesat di
berbagai pengecUALan, pengecUALan, dan kasus khusus. Ini cukup membuat putus asa.

Jaringan saraf menangani masalah ini dengan cara yang berbeda. Ide dasarnya adalah untuk mengambil sejumlah besar
digit tangan, dikenal sebagai contoh pelatihan, dan kemudian, mengembangkan sistem yang
Anda dapat belajar dari contoh-contoh pelatihan ini. Dengan kata lain, jaringan syaraf menggunakan contoh-contoh untuk
menyimpulkan secara otomatis aturan untuk pengenalan angka tulisan tangan. Selain itu, saat meningkatkan
jumlah contoh pelatihan, jaringan dapat belajar lebih banyak tentang tulisan tangan, dan dengan demikian meningkatkan kemampuannya
presisi. Kita bisa membangun pengenal digit tulisan tangan yang lebih baik menggunakan ribuan, jutaan atau
miliar contoh pelatihan.
Sepanjang beberapa bab berikutnya kita akan memulai perjalanan kita menuju arsitektur Deep yang lebih maju
Belajar, mengembangkan sebuah program komputer yang mengimplementasikan jaringan saraf yang belajar untuk
mengidentifikasi digit tulisan tangan. Program tidak akan menggunakan pustaka jaringan saraf khusus (kami akan menggunakan
hanya bahasa Python). Tetapi program ini dapat mengenali digit dengan akurasi lebih dari 96%,
tanpa intervensi manusia. Selain itu, dalam bab-bab selanjutnya, kita akan mengembangkan ide-ide yang dapat
meningkatkan akurasi menjadi lebih dari 99%. Sebenarnya, jaringan saraf komersial terbaik sekarang sudah sangat bagus.
yang digunakan oleh bank untuk memproses cek dan oleh kantor pos untuk mengenali alamat.

Kami sedang fokus pada pengenalan naskah karena ini adalah masalah prototipe yang sangat baik
untuk belajar tentang jaringan saraf secara umum. Sebagai prototipe, ia mencapai titik yang menarik: itu
menantang–tidak begitu sederhana untuk mengenali digit tulisan tangan–tetapi juga tidak begitu sulit dan tidak
memerlukan solusi yang sangat rumit, atau kekuatan komputasi yang luar biasa. Selain itu, ini adalah
cara yang baik untuk mengembangkan teknik yang lebih maju, seperti pembelajaran mendalam. Dan dengan demikian, seiring waktu
dari buku, kita akan kembali berulang kali ke masalah pengenalan digit tulisan tangan. Nanti, di
buku, kita akan membahas bagaimana ide-ide ini dapat diterapkan pada masalah lain dalam visi komputer, dan
juga dalam pengenalan suara, pemrosesan bahasa alami, dan bidang lainnya.

Sepanjang jalan, kita akan mengembangkan banyak ide kunci tentang jaringan saraf, termasuk dua jenis
pentingnya neuron buatan (perceptron dan neuron sigmoid) dan algoritma pembelajaran
standar untuk jaringan saraf, dikenal sebagai penurunan stokastik gradien. Kami akan menjelaskan mengapa hal-hal
dibuat dengan cara mereka dan dalam membangun intuisi jaringan saraf mereka. Ini memerlukan sebuah
diskusi yang lebih panjang daripada sekadar menyajikan mekanika dasar dari apa yang sedang terjadi, tetapi itu sepadan
untuk pemahaman yang lebih dalam yang akan Anda capai. Dan di akhir buku ini, Anda akan memiliki yang baik
pemahaman tentang apa itu pembelajaran mendalam dan bagaimana itu mengubah dunia!

Jika Anda tidak memiliki pengetahuan tentang bahasa Python, kami merekomendasikan kursus [Link] Python
Dasar-dasar untuk Analisis [Link] memberikan dasar yang hebat untuk semua yang Anda butuhkan untuk
mulailah mengembangkan jaringan saraf Anda.
Bab 6–Perceptron–Bagian 1
Apakah Anda tahu apa saja arsitektur utama dari jaringan saraf buatan? Tidak. Jadi, analisislah.
Hati-hati dengan gambar di bawah ini (pekerjaan luar biasa yang dibuat oleh tim Institut Asimov, yang
tautan yang dapat Anda temukan di bagian referensi di akhir bab ini):
Luar biasa, bukan? Ada berbagai arsitektur, yang digunakan untuk menyelesaikan berbagai jenis masalah, seperti
conto arsitektur jaringan saraf konvolusional yang digunakan dalam masalah Visi Komputer dan
jaringan saraf rekuren yang digunakan dalam masalah Pemrosesan Bahasa Alami. Kita akan mempelajari
hampir semua arsitektur ini ada di buku ini. Ya, itu benar yang Anda baca. Kami baru saja mulai!!
Jika Anda ingin belajar membangun model dan proyek menggunakan arsitektur ini dan bekerja dengan bahasa
Python dan Google TensorFlow, klik di sini.

Meskipun semua arsitektur ini adalah jaringan saraf buatan, tidak semuanya adalah Deep Learning. Apa yang
karakterisasi model pembelajaran mendalam, seperti namanya, adalah jaringan saraf tiruan dengan
banyak lapisan tersembunyi (atau perantara). Namun sebelum kita sampai di sana, kita perlu melewati arsitektur
lebih sederhana dari jaringan saraf buatan, Perceptron. Seperti pepatah mengatakan: “Setiap perjalanan besar
mulailah dengan langkah pertama.

Model Perceptron dikembangkan pada dekade 1950-an dan 1960-an oleh ilmuwan Frank Rosenblatt.
diilhami oleh pekerjaan sebelumnya Warren McCulloch dan Walter Pitts. Saat ini, lebih umum menggunakan yang lain
model neuron buatan, tetapi Perceptron memungkinkan pemahaman yang jelas tentang cara kerjanya
jaringan saraf dalam istilah matematis, menjadi pengantar yang sangat baik.

Jadi, bagaimana cara kerja Perceptron? Sebuah Perceptron adalah model matematis yang menerima beberapa
masukan, x1, x2, … dan menghasilkan satu keluaran biner:

Dalam contoh yang ditunjukkan, Perceptron memiliki tiga input: x1, x2, x3. Rosenblatt mengusulkan aturan sederhana
untuk menghitung keluaran. Dia memperkenalkan bobot, w1, w2, …, angka riil yang mengekspresikan pentingnya
masukannya masing-masing untuk keluaran. Keluaran neuron, 0 atau 1, ditentukan oleh jumlah tertimbang, Σjwjxj,
kurang dari atau lebih dari suatu nilai ambang (threshold). Sama seperti bobot, ambang adalah angka riil
apa itu parameter dari neuron. Untuk mengungkapkannya dalam istilah aljabar yang lebih tepat:
Ini adalah model matematika dasar. Satu cara untuk memikirkan tentang Perceptron adalah bahwa itu adalah perangkat yang
buat keputusan setelah membuktikan bukti. Biarkan saya memberikan contoh. Ini bukan contoh yang sangat realistis, tetapi
mudah dipahami, dan segera kita akan sampai pada contoh yang lebih realistis. Anggaplah bahwa akhir pekan akan
Datang dan Anda mendengar bahwa akan ada festival keju di kota Anda. Anda suka keju dan sedang
mencoba memutuskan apakah akan pergi ke festival atau tidak. Anda dapat membuat keputusan Anda dengan mempertimbangkan tiga faktor:

Apakah cuacanya baik?

Apakah pacar Anda ingin menemani Anda?
Apakah festival tersebut dekat dengan transportasi umum? (Anda tidak memiliki mobil)

Kita dapat mewakili ketiga faktor ini dengan variabel biner yang sesuai x1, x2, dan x3. Misalnya,
kita akan memiliki x1 = 1 jika cuacanya baik dan x1 = 0 jika cuacanya buruk. Dengan cara yang sama, x2 = 1 jika Anda
namorado atau namorada ingin pergi ke festival bersamamu, dan x2 = 0, jika tidak. Dan serupa untuk x3 dan transportasi
publik.

Sekarang, anggaplah Anda sangat menyukai keju dan bersedia pergi ke festival, meskipun pacar Anda atau
pacar tidak tertarik dan festival terletak di tempat yang sulit dijangkau dan tanpa transportasi umum
secara luas tersedia. Selain itu, Anda benar-benar membenci cuaca buruk, dan tidak ada cara untuk pergi ke festival jika
Jika cuaca buruk. Anda dapat menggunakan Perceptrons untuk memodelkan jenis pengambilan keputusan ini.

Salah satu cara untuk melakukannya adalah memilih bobot w1 = 6 untuk waktu dan w2 = 2 serta w3 = 2 untuk yang lain.
kondisi. Nilai yang lebih besar dari w1 menunjukkan bahwa waktu sangat penting bagi Anda, jauh lebih penting daripada jika Anda
pacar atau pacar akan menemani Anda atau jika festival dekat dengan transportasi publik. Akhirnya,
misalkan Anda memilih ambang batas 5 untuk Perceptron. Dengan pilihan ini, Perceptron
terapkan model pengambilan keputusan yang diinginkan, menghasilkan 1 setiap kali cuaca baik dan 0
selalu ketika cuacanya buruk. Tidak ada perbedaan untuk hasil apakah pacar Anda ingin pergi,
di mana transportasi umum dapat diakses.

Dengan memvariasikan bobot dan ambang, kita dapat memperoleh model pengambilan keputusan yang berbeda. Misalnya,
andaikan kita memilih ambang batas 3. Maka, Perceptron akan memutuskan bahwa Anda seharusnya pergi ke festival
selalu saat cuaca baik atau ketika festival dekat dengan transportasi umum dan pacar Anda atau
pacar bersedia untuk bergabung dengan Anda. Dengan kata lain, itu akan menjadi model pengambilan keputusan yang berbeda.
keputusan. Mengurangi ambang batas berarti Anda lebih cenderung untuk pergi ke festival.

Jelas, Perceptron bukanlah model lengkap untuk pengambilan keputusan manusia! Tapi apa contoh itu
ilustra adalah bagaimana sebuah Perceptron dapat memberikan bobot pada berbagai jenis bukti untuk membuat keputusan. Dan harus tampak
adalah mungkin bahwa jaringan kompleks Perceptron dapat membuat keputusan yang sangat halus.
Di jaringan ini, kolom pertama dari Perceptrons—yang akan kita sebut sebagai lapisan pertama dari Perceptrons—sedang
mengambil tiga keputusan yang sangat sederhana, mempertimbangkan bukti yang masuk. Dan bagaimana dengan Perceptrons pada yang kedua
lapisan? Masing-masing Perceptron ini membuat keputusan dengan mempertimbangkan hasil dari yang pertama
lapisan pengambilan keputusan. Dengan cara ini, sebuah Perceptron di lapisan kedua dapat mengambil keputusan dalam
sebuah tingkat yang lebih kompleks dan lebih abstrak daripada Perceptron di lapisan pertama. Dan keputusan masih
lebih kompleks dapat dilakukan oleh Perceptron di lapisan ketiga. Dengan cara ini, sebuah jaringan dari
Perceptron berlapis dapat ter keterlibatan dalam pengambilan keputusan yang canggih.

Omong-omong, ketika kita mendefinisikan Perceptron, kita mengatakan bahwa sebuah Perceptron hanya memiliki satu output. Di jaringan
Di atas, Percepton tampaknya memiliki beberapa hasil. Sebenarnya, mereka masih memiliki keluaran tunggal. Panah
keluaran ganda hanyalah cara yang berguna untuk menunjukkan bahwa keluaran dari sebuah Perceptron sedang
digunakan sebagai masukan untuk berbagai Perceptron lainnya.

Mari kita menyederhanakan cara kita mendeskripsikan Perceptron. Dalam batasan kondisi Σjwjxj >
thresholdpodemos membuat dua perubahan notasi untuk menyederhanakannya. Perubahan pertama adalah menulis
Σjwjxj sebagai produk (produk titik), w⋅x≡Σjwjxj, di mana w dan x adalah vektor yang komponen-komenpennya adalah bobot
e entradas, masing-masing. Perubahan kedua adalah memindahkan threshold ke sisi lain dari persamaan dan
menggantinya dengan apa yang dikenal sebagai bias (bias) dari Perceptron, atau b ≡-threshold. Menggunakan bias sebagai ganti
dengan ambang, aturan Perceptron dapat ditulis ulang:

Anda dapat menganggap bias sebagai ukuran seberapa mudah untuk membuat Perceptron menghasilkan 1. Atau untuk
dalam istilah yang lebih biologis, bias adalah ukuran seberapa mudahnya membuat Perceptron
dispare. Untuk sebuah Perceptron dengan bias yang sangat besar, sangat mudah bagi Perceptron untuk mengeluarkan
Namun, jika biasnya sangat negatif, maka sulit bagi Perceptron untuk mengeluarkan 1. Jelas bahwa a
introduksi bias hanyalah perubahan kecil dalam cara kita mendeskripsikan Perceptron, tetapi kita akan melihat lebih lanjut
perlu dicatat bahwa ini mengarah pada penyederhanaan notasi lainnya. Oleh karena itu, di sisa buku ini, kami tidak akan menggunakan yang
ambang, kami akan selalu menggunakan bias.

Sekarang mulai lebih mudah untuk memahami konsep di balik jaringan saraf buatan dan ini akan
sangat berguna ketika kita mempelajari arsitektur yang lebih maju! Sebuah Perceptron mengikuti model "feed-forward",
apa artinya bahwa input dikirim ke neuron, diproses, dan menghasilkan output. Di
diagrama di bawah, ini berarti bahwa jaringan (sebuah neuron) membaca dari kiri ke kanan.
Proses pelatihan model Perceptron terdiri dari membuat model belajar
nilai ideal dari bobot dan bias. Kami menyajikan kepada model data masukan dan kemungkinan keluaran, kami melatih
model dan bobot serta bias dipelajari. Dengan model yang terlatih, kita dapat menyajikan data baru dari
masukan dan model akan mampu memprediksi keluaran. Kita akan melihat ini segera ketika kita membuat yang pertama
model menggunakan bahasa Python.

Perceptron adalah jaringan saraf lapisan tunggal dan Perceptron multilapis disebut Jaringan
Neural Artificial. Perceptron adalah pengklasifikasi linier (biner). Selain itu, ia digunakan dalam pembelajaran.
terawasi dan dapat digunakan untuk mengklasifikasikan data masukan yang diberikan.

Namun Perceptron masih memiliki karakteristik penting lainnya, seperti representasi kondisi logis
(dan, atau, xor), masalah dengan data yang tidak dapat dipisahkan secara non-linear dan fungsi aktivasi. Tapi ini adalah
tema untuk bab berikutnya. Sampai jumpa!
Bab 7–Perceptron–Bagian 2

Perceptron adalah model matematis dari neuron biologis. Sementara pada neuron asli, dendrit
menerima sinyal listrik dari akson neuron lain, di Perceptron sinyal listrik ini adalah
diwakili sebagai nilai numerik. Di sinapsis antara dendrit dan akson, sinyal listrik adalah
dimodulasi dalam berbagai jumlah. Ini juga dimodelkan di Perceptron dengan mengalikan setiap nilai dari
masuk oleh suatu nilai yang disebut berat. Sebuah neuron nyata memicu sinyal keluaran hanya ketika kekuatan
total sinyal masukan melebihi ambang tertentu. Kami memodelkan fenomena ini dalam sebuah Perceptron
menghitung jumlah tertimbang dari masukan untuk merepresentasikan kekuatan total dari sinyal masuk dan menerapkan
fungsi aktivasi dalam jumlah untuk menentukan keluarnya. Seperti pada jaringan saraf biologis, keluarnya ini
diberikan kepada Perceptrons lainnya. Kita telah mempelajari semua ini di bab sebelumnya. Sekarang kita akan melanjutkan pembahasan kita.
diskusi tentang Perceptron memahami beberapa konsep lagi, yang akan menjadi dasar di kemudian hari
ketika kita mempelajari arsitektur canggih Deep Learning.

Sebelum memulai, mari kita definisikan dua konsep yang akan sering Anda lihat mulai sekarang, vektor dari
masukan dan vektor bobot:

Vektor masukan – semua nilai masukan dari setiap Perceptron secara kolektif disebut sebagai vektor dari
entrada desse Perceptron. Esses são seus dados de entrada.

Vetor bobot – dengan cara yang serupa, semua nilai bobot dari setiap Perceptron dikumpulkan secara kolektif
panggilan vektor bobot dari Perceptron ini. Kami memulai jaringan saraf buatan kami dengan nilai acak dari
peso dan selama pelatihan, jaringan saraf belajar nilai berat yang ideal. Seperti yang akan kita lihat, ada
banyak cara untuk menjalankan proses ini.

Sebagian besar pekerjaan dari jaringan saraf akan berputar di sekitar operasi aljabar antara vektor dari
masukan dan vektor bobot. Selanjutnya, kita akan menambahkan lapisan matematis atau statistik lainnya untuk
melakukan berbagai operasi, sesuai dengan masalah yang sedang kita coba selesaikan dengan model
jaringan saraf. Anda akan menyadari bahwa semuanya hanyalah Matematika, yang dapat diterapkan dengan
bahasa pemrograman, kumpulan data besar, dan pemrosesan paralel, untuk membentuk sistem dari
Kecerdasan Buatan.

Tapi apa yang sebenarnya bisa dilakukan oleh Perceptron?

Dalam bab sebelumnya, kami menggambarkan Perceptrons sebagai metode untuk memberikan bobot pada bukti agar dapat mengambil keputusan.
keputusan. Salah satu cara di mana Perceptron dapat digunakan adalah untuk menghitung fungsi logika
elemen dasar seperti DAN, ATAU dan NAND (jika Anda memiliki pertanyaan tentang operasi logika, konsultasikan dengan
referensi di akhir bab ini). Misalnya, misalkan kita memiliki sebuah Perceptron dengan dua masukan,
masing-masing dengan bobot -2 dan bias 3. Berikut adalah Perceptron kami:
Jadi kita melihat bahwa input 00 akan menghasilkan output 1, mengingat (-2) * 0 + (-2) * 0 + 3 = 3, yang merupakan positif
(hasil positif, menghasilkan keluaran 1 dari Perceptron, ingat bab sebelumnya?). Di sini, kami menyertakan simbol *
untuk membuat perkalian menjadi eksplisit. Perhitungan serupa menunjukkan bahwa entri 01 dan 10 menghasilkan
saída 1. Mas a entrada 11 produz a saída 0, uma vez que (-2) * 1 + (-2) * 1 + 3 = -1, é negativo. E assim
Perceptron kami mengimplementasikan sebuah "gerbang" NAND, atau operasi logika biner NAND.

Contoh NAND menunjukkan bahwa kita dapat menggunakan Perceptrons untuk menghitung fungsi logika sederhana. Sebenarnya,
kita bisa menggunakan jaringan Perceptron untuk menghitung fungsi logika apa pun. Alasannya adalah bahwa gerbang NAND adalah
universal untuk komputerisasi, yaitu, kita bisa membangun setiap komputasi dengan gerbang NAND.

Sebuah jaringan Perceptron dapat digunakan untuk mensimulasikan sebuah rangkaian yang mengandung banyak gerbang NAND. Dan seperti
gerbang NAND adalah universal untuk komputasi, oleh karena itu Perceptron juga bersifat universal
untuk komputasi. Mengingat bahwa Perceptron adalah model jaringan saraf yang paling sederhana, bayangkan apa yang
bisa dilakukan dengan model yang jauh lebih canggih! Anda benar jika berpikir tentang Kecerdasan Buatan.

Keterhantaran komputasi dari Perceptrons secara bersamaan menghibur dan mengecewakan. Itu adalah
menghibur karena memberi tahu kita bahwa jaringan Perceptrons bisa sekuat yang lain
perangkat komputasi. Tapi juga mengecewakan, karena tampaknya Perceptron hanyalah
sebuah jenis gerbang NAND baru. Ini bukan berita besar!

Namun, situasinya lebih baik daripada yang terlihat. Ternyata kita bisa merancang algoritma untuk
pembelajaran yang dapat secara otomatis menyesuaikan bobot dan bias dari jaringan neuron buatan.
Penyesuaian ini terjadi sebagai respons terhadap rangsangan eksternal, tanpa intervensi langsung dari seorang pemrogram.
algoritma pembelajaran memungkinkan kita menggunakan neuron buatan dengan cara yang radikal
berbeda dari gerbang logika konvensional. Alih-alih memasukkan secara eksplisit sirkuit NAND dan
port besar lainnya, jaringan saraf kita bisa belajar untuk menyelesaikan masalah, terkadang masalah
yang akan sangat sulit untuk dirancang secara langsung menggunakan sirkuit logika konvensional.

Operasi Logika dan Wilayah yang Dapat Dipisahkan Secara Linear

Sesuai yang disebutkan di atas, sebuah Perceptron menghitung jumlah tertimbang dari nilai input.
kesederhanaan, mari kita anggap ada dua nilai masukan, x dan y untuk suatu Perceptron P. Kita akan
menentukan bobot x dan y, sebagai A dan B, masing-masing. Jumlah berbobot dapat direpresentasikan
seperti: A x + B y.

Karena Perceptron hanya menghasilkan nilai tidak nol ketika jumlah tertimbang melebihi suatu batas tertentu
batas C, dapat ditulis keluaran Perceptron ini dengan cara berikut:
Mengingat bahwa A x + B y > C dan A x + B y < C adalah dua daerah di bidang xy yang dipisahkan oleh garis A x +
B y + C = 0, dan jika kita juga mempertimbangkan input (x, y) sebagai sebuah titik di bidang, maka Perceptron
benar-benar memberitahu kita wilayah mana dalam rencana yang dimiliki titik ini. Wilayah-wilayah tersebut, karena terpisah
oleh satu garis tunggal, disebut sebagai daerah yang dapat dipisahkan secara linier.

Sebuah Perceptron tunggal hanya dapat menyelesaikan fungsi yang dapat dipisahkan secara linear. Dalam fungsi yang tidak
linearmente terpisah, Perceptron tidak dapat menghasilkan hiperbidang, garis ini pada grafik di bawah,
memisahkan data. Masalahnya adalah bahwa di dunia nyata jarang sekali data dapat dipisahkan secara linier, membuat
Dengan apa yang Perceptron tidak sangat berguna untuk aktivitas praktis (tetapi sangat ideal untuk memulai studi)
di jaringan saraf buatan). Dan bagaimana kita memisahkan data yang tidak terpisahkan secara non-linier? Lanjutkan
mengikuti buku ini dan Anda akan menemukan.

Namun demikian, Perceptron memiliki kegunaannya, karena menghasilkan beberapa fungsi logika, seperti yang
operator boolean AND, OR dan NOT, yang secara linear dapat dipisahkan, yaitu, mereka dapat dilakukan
menggunakan satu Perceptron. Kita dapat mengilustrasikan mengapa mereka dapat dipisahkan secara linier dengan menggambar masing-masing
deles em um gráfico:

Pada grafik di atas, kedua sumbu adalah masukan yang dapat menghasilkan nilai 0 atau 1 dan angka-angka di grafik.
adalah keluaran yang diharapkan untuk masukan tertentu. Menggunakan vektor bobot yang sesuai untuk setiap kasus, sebuah
Perceptron tunggal dapat menjalankan semua fungsi ini.

Namun, tidak semua operator logika dapat dipisahkan secara linier. Misalnya, operator XOR
tidak dapat dipisahkan secara linier dan tidak dapat dicapai oleh satu Perceptron. Namun, masalah ini
itu bisa diatasi dengan menggunakan lebih dari satu Perceptron yang diorganisir dalam jaringan saraf feed-forward, yang akan kita lihat
tapi di depan di bab-bab berikutnya.
Karena tidak mungkin menggambar garis untuk membagi wilayah yang mengandung 1 atau 0, fungsi XOR tidak dapat
secara linier dapat dipisahkan, seperti yang dapat dilihat pada grafik di atas.

Sekarang lebih mudah untuk memahami mengapa kita memerlukan arsitektur jaringan saraf yang lebih maju
artificiais, mengingat kita memiliki masalah kompleks di dunia nyata, seperti Penglihatan Komputer,
Pemrosesan Bahasa Alami, Terjemahan, Deteksi Penipuan, Klasifikasi dan banyak lainnya. Dan
kita akan melihat arsitektur ini secara rinci. Tapi sebelum itu, kita perlu membahas tentang komponen dasar dari
jaringan saraf, Fungsi Aktivasi. Jangan lewatkan bab berikutnya. Sampai saat itu.
Bab 8–Fungsi Aktivasi

Dalam bab ini kita akan mempelajari komponen penting dari jaringan saraf buatan, Fungsi Aktivasi.
Bab ini adalah pengantar untuk tema ini dan kita akan kembali kepadanya kemudian ketika kita mempelajari arsitektur.
lanjutan dariPembelajaran MendalamBab ini mungkin sedikit menantang, karena kita akan mulai memperkenalkan
konsep-konsep yang lebih maju, yang akan sangat berguna dalam lanjutan bab-bab. Santai, bacalah dan pelajari
sedikit lebih tentang jaringan saraf buatan.

Sebelum menyelami rincian fungsi aktivasi, mari kita lakukan sedikit tinjauan tentang apa itu
jaringan saraf buatandan bagaimana cara kerjanya. Sebuah jaringan saraf adalah mekanisme pembelajaran mesin
(Pembelajaran Mesin) sangat kuat yang pada dasarnya meniru bagaimana otak manusia belajar. Otak
menerima rangsangan dari dunia luar, melakukan pemrosesan, dan menghasilkan hasil. Seiring dengan semakin sulitnya tugas
rumit, beberapa neuron membentuk jaringan kompleks, mentransmisikan informasi di antara mereka. Menggunakan sebuah
jaringan saraf buatan, kami mencoba meniru perilaku serupa. Jaringan yang Anda lihat di bawah adalah sebuah jaringan
neural artificial terdiri dari neuron yang saling terhubung.

Lingkaran hitam dalam gambar di atas adalah neuron. Setiap neuron ditandai dengan bobot, bias, dan
fungsi aktivasi. Data masukan dimasukkan ke dalam lapisan input. Neuron melakukan sebuah
transformasi linier di input oleh bobot dan bias. Transformasi non-linier dilakukan oleh fungsi
aktivasi. Informasi bergerak dari lapisan input ke lapisan tersembunyi. Lapisan tersembunyi melakukan
pemrosesan dan mengirimkan keluaran akhir ke lapisan keluaran. Ini adalah gerakan langsung informasi
dikenal sebagai propagasi langsung. Tetapi bagaimana jika hasil yang dihasilkan jauh dari nilai yang diharapkan? Dalam sebuah
jaringan saraf, kami akan memperbarui bobot dan bias neuron berdasarkan kesalahan. Proses ini dikenal sebagai
backpropagation. Setelah semua data melewati proses ini, bobot dan bias akhir digunakan
untuk ramalan.

Tenang, tenang, tenang. Banyak informasi dalam satu paragraf, saya tahu! Mari kita bagi-bagi.
Berat dan bias telah kita bahas di chapter sebelumnya. Fungsi aktivasi akan kita bahas sekarang dan
propagasi langsung dan backpropagation yang akan kita bahas di bab-bab berikutnya!
Fungsi Aktivasi

Algoritma pembelajaran sangat fantastis. Tapi bagaimana kita bisa merancang algoritma ini untuk sebuah
jaringan saraf buatan? Misalkan kita memiliki jaringan Perceptron yang ingin kita gunakan untuk
belajar untuk menyelesaikan masalah tertentu. Misalnya, input untuk jaringan bisa berupa data piksel dari
sebuah gambar yang dipindai, ditulis tangan, dari sebuah digit. Kami ingin jaringan belajar bobot dan bias untuk
agar keluaran jaringan mengklasifikasikan digit dengan benar. Untuk melihat bagaimana pembelajaran dapat berfungsi,
anggaplah kita melakukan sedikit perubahan pada salah satu bobot (atau bias) di jaringan. Apa yang kita inginkan adalah bahwa ini
perubahan kecil dalam berat hanya menyebabkan sedikit perubahan yang sesuai pada keluaran jaringan. Bagaimana
nanti kita akan melihat, sifat ini akan memungkinkan pembelajaran. Secara skematis, berikut ini adalah
apa yang kita inginkan (jelas, jaringan ini sangat sederhana untuk melakukan pengenalan tulisan, tetapi tetap
tenang saja kita akan melihat jaringan yang jauh lebih kompleks).

Jika itu benar bahwa perubahan kecil pada suatu bobot (atau bias) membuat kita hanya memiliki satu
perubahan kecil pada hasil, jadi kita bisa menggunakan fakta ini untuk memodifikasi bobot dan nilai bias
agar jaringan kami berperilaku lebih seperti yang kami inginkan. Misalnya, anggaplah jaringan
kategorikan secara salah sebuah gambar sebagai "8" ketika seharusnya adalah "9". Kita bisa menemukan bagaimana
melakukan sedikit perubahan pada bobot dan bias agar jaringan sedikit lebih mendekati klasifikasi
dari gambar sebagai "9". Dan kemudian, kita akan mengulangi ini, mengubah bobot dan nilai bias secara berkali-kali untuk
memproduksi hasil yang lebih baik dan lebih baik. Jaringan tersebut sedang belajar.

Masalahnya adalah ini bukan yang terjadi ketika jaringan kita hanya mengandung Perceptron, sesuai dengan
kita telah belajar di bab sebelumnya. Sebenarnya, perubahan kecil pada bobot dari satu Perceptron di
rede bisa, terkadang, membuat keluaran dari Perceptron ini berubah sama sekali, katakanlah dari 0 menjadi 1. Itu
perubahan dapat kemudian menyebabkan perilaku sisa jaringan berubah sepenuhnya dengan cara yang sangat
rumit. Jadi, sementara "9" Anda sekarang dapat diklasifikasikan dengan benar, perilaku jaringan
di semua gambar lainnya kemungkinan akan berubah sepenuhnya dengan cara yang sulit untuk dikendalikan. Mungkin
Ada cara cerdas untuk menyelesaikan masalah ini. Ya, ada. Dan itu dikenal sebagai fungsi aktivasi.

Kita dapat mengatasi masalah ini melalui pengenalan komponen matematis dalam neuron kita
artificial, yang disebut fungsi aktivasi. Fungsi aktivasi memungkinkan perubahan kecil pada bobot
e bias hanya menyebabkan sedikit perubahan pada output. Ini adalah fakta penting yang akan memungkinkan sebuah jaringan untuk
neuron buatan belajar.
Mari kita melihat bagaimana ini bekerja:

Fungsi aktivasi adalah elemen yang sangat penting dari jaringan saraf buatan. Mereka
Pada dasarnya memutuskan apakah neuron harus diaktifkan atau tidak. Dengan kata lain, apakah informasi yang neuron tersebut
menerima adalah relevan untuk informasi yang diberikan atau harus diabaikan. Lihat pada rumus di bawah ini bagaimana
fungsi aktivasi adalah satu lapisan matematis lagi dalam pemrosesan.

Fungsi aktivasi adalah transformasi non-linear yang kita lakukan sepanjang sinyal masukan. Keluaran ini
transformasi kemudian dikirim ke lapisan neuron berikutnya sebagai masukan. Ketika kita tidak memiliki
fungsi aktivasi, bobot dan bias hanyalah melakukan transformasi linier. Sebuah persamaan linier adalah
mudah untuk diselesaikan, tetapi terbatas dalam kemampuannya untuk menyelesaikan masalah kompleks. Sebuah jaringan saraf
tanpa fungsi aktivasi secara esensial hanyalah model regresi linier. Fungsi aktivasi membuat
transformasi non-linear pada data masukan, membuatnya mampu belajar dan melaksanakan tugas lebih
kompleks. Kami ingin jaringan saraf kami berfungsi dalam tugas-tugas rumit, seperti penerjemahan dari
bahasa (Pemrosesan Bahasa Alami) dan klasifikasi gambar (Penglihatan Komputer). Se
transformasi linear tidak akan pernah mampu melakukan tugas-tugas seperti itu.

Fungsi aktivasi memungkinkan propagasi selanjutnya selama gradien diberikan

bersama dengan kesalahan untuk memperbarui bobot dan bias. Tanpa fungsi non-linear yang dapat didiferensiasi, ini tidak akan
mungkin. Jika istilah gradien tidak familiar, tunggu bab-bab berikutnya, saat kami akan menjelaskan
konsep ini secara rinci, mengingat bahwa ia adalah intisari dari proses pembelajaran dalam jaringan saraf
buatan.

Tetapi tidak ada hanya satu jenis fungsi aktivasi. Sebenarnya ada beberapa, masing-masing untuk digunakan di
situasi yang berbeda. Mari kita lihat deskripsi singkat tentang jenis yang paling populer.
Tipos Populares de Funções de Ativação

Fungsi aktivasi adalah komponen matematis yang dimasukkan dalam struktur jaringan saraf buatan untuk tujuan
memungkinkan penyelesaian masalah kompleks. Ada berbagai jenis fungsi aktivasi dan ini adalah area
penelitian aktif, seiring dengan berkembangnya Kecerdasan Buatan (tidak luar biasa bisa berpartisipasi dalam ini
evolusi, yang akan sepenuhnya mengubah dunia?). Mari kita lihat jenis yang paling populer.

Fungsi Langkah Biner

Hal pertama yang terlintas di benak kita ketika kita memiliki fungsi aktivasi adalah sebuah pengklasifikasi
berbasis pada ambang (threshold), yaitu, apakah neuron harus diaktifkan atau tidak. Jika nilai Y berada di atas
sebuah nilai batas yang ditentukan, aktifkan neuron jika tidak biarkan dinonaktifkan. Sederhana! Itu adalah aturannya:

f(x) = 1, x>=0

f(x) = 0, x<0

Fungsi langkah biner adalah itu, sangat sederhana. Itu dapat digunakan saat membuat pengklasifikasi
biner. Ketika kita hanya perlu mengatakan ya atau tidak untuk satu kelas, fungsi langkahnya adalah
pilihan terbaik, karena akan mengaktifkan neuron atau membiarkannya nol.

Fungsi ini lebih teoretis daripada praktis, karena, dalam kebanyakan kasus, kita mengklasifikasikan data ke dalam berbagai kelas.
tidak hanya satu kelas tunggal. Fungsi langkah tidak akan mampu melakukan ini.

Selain itu, gradien dari fungsi langkah adalah nol. Ini membuat fungsi langkah tidak begitu berguna
selama backpropagation ketika gradien fungsi aktivasi dikirim untuk perhitungan kesalahan
untuk meningkatkan dan mengoptimalkan hasil. Gradien dari fungsi langkah mengurangi segalanya menjadi nol dan perbaikan dari
modelos memang tidak terjadi. Mengingat, sekali lagi, bahwa kita akan melihat dengan rinci konsep-konsep
gradien dan backpropagation lebih lanjut, di bab-bab berikutnya!

Fungsi Linear

Kami melihat masalah dengan fungsi langkah, gradien yang nol, tidak mungkin untuk memperbarui gradien selama
sebuah backpropagation. Alih-alih menggunakan fungsi langkah sederhana, kita bisa mencoba menggunakan fungsi linier.
Kita dapat mendefinisikan fungsi sebagai:

f(x) = ax

Turunan dari suatu fungsi linier adalah konstan, artinya tidak tergantung pada nilai input x. Ini berarti bahwa
Setiap kali kita melakukan backpropagation, gradien akan sama. Dan ini adalah masalah besar, bukan?
kita benar-benar memperbaiki kesalahan, karena gradiennya hampir sama. Dan tidak hanya menganggap
kita sedang mencoba melakukan tugas yang rumit di mana kita membutuhkan beberapa lapisan di dalamnya
rede. Sekarang, jika setiap lapisan memiliki transformasi linier, tidak masalah berapa banyak lapisan yang kita miliki, a
keluaran akhir tidak lain adalah transformasi linier dari masukan. Oleh karena itu, fungsi linier dapat menjadi ideal untuk
tugas-tugas sederhana, di mana interpretabilitas sangat diinginkan.
Sigmoid

Sigmóide adalah fungsi aktivasi yang banyak digunakan. Bentuknya adalah:

f (x) = 1 / (1 + e ^ -x)

Ini adalah fungsi halus dan terus dapat dibedakan. Keuntungan terbesar dibandingkan dengan fungsi langkah dan
fungsi linear adalah yang tidak linear. Ini adalah karakteristik yang sangat menarik dari fungsi sigmoid.
Ini pada dasarnya berarti bahwa ketika saya memiliki beberapa neuron dengan fungsi sigmoida sebagai fungsi dari
aktivasi–keluarnya juga tidak linear. Fungsi bervariasi dari 0 hingga 1 dengan bentuk S.

Fungsi ini pada dasarnya berusaha mendorong nilai Y ke ekstrem. Ini adalah kualitas yang sangat
diinginkan ketika kita mencoba mengklasifikasikan nilai-nilai untuk kelas tertentu.

Fungsi sigmoid masih banyak digunakan hingga saat ini, tetapi kita masih memiliki masalah yang perlu kita selesaikan.
menangani. Dengan sigmoid, kita memiliki masalah ketika gradien menjadi sangat kecil. Ini berarti
bahwa gradien mendekati nol dan jaringan tidak benar-benar belajar.

Masalah lain yang dihadapi fungsi sigmoid adalah bahwa nilai-nilainya hanya bervariasi antara 0 dan 1. Ukuran ini yang
fungsi sigmoid tidak simetris di sekitar asal dan semua nilai yang diterima adalah positif. Tidak selalu
kami ingin agar nilai yang dikirim ke neuron berikutnya semuanya memiliki sinyal yang sama. Ini bisa jadi
dihadapi oleh perluasan fungsi sigmoida. Ini adalah apa yang benar-benar terjadi pada fungsi tanh.

Tanh

Fungsi tanh sangat mirip dengan fungsi sigmoid. Sebenarnya, ini hanyalah versi berjenjang dari
fungsi sigmoid.

Tanh (x) = 2sigmoid (2x) -1

Dapat dituliskan langsung sebagai:

tanh (x) = 2 / (1 + e ^ (- 2x)) -1

Tanh berfungsi dengan cara yang mirip dengan fungsi sigmoida, tetapi simetris terhadap asal. berosilasi dari -1 ke
1.

Pada dasarnya, menyelesaikan masalah nilai kami, dengan semua memiliki tanda yang sama. Semua yang lainnya
propriedades são as mesmas da função sigmoide. É contínuo e diferenciável em todos os pontos. A função
não é linear, então podemos fazer o backpropagation facilmente nos erros.

ReLU

Fungsi ReLU adalah unit linier rektifikasi. Ini didefinisikan sebagai:

f(x) = maks (0, x)

ReLU adalah fungsi aktivasi yang paling banyak digunakan dalam merancang jaringan saraf saat ini.
Pertama-tama, fungsi ReLU bersifat non-linear, yang berarti kita dapat dengan mudah menyalin kesalahan untuk
melalui dan memiliki beberapa lapisan neuron yang diaktifkan oleh fungsi ReLU.

Keuntungan utama menggunakan fungsi ReLU dibandingkan fungsi aktivasi lainnya adalah bahwa ia tidak mengaktifkan semua
neurons pada saat yang sama. Apa artinya ini? Jika Anda melihat fungsi ReLU dan masukan adalah
negatif, itu akan diubah menjadi nol dan neuron tidak akan diaktifkan. Ini berarti bahwa, pada saat yang sama,
hanya beberapa neuron yang diaktifkan, membuat jaringan jarang dan efisien serta mudah untuk perhitungan.

Mas ReLU juga bisa mengalami masalah dengan gradien yang bergerak menuju nol. Tetapi ketika
Kita memiliki masalah, kita selalu bisa memikirkan solusi. Lagi pula, itulah yang paling sering dilakukan perusahaan.
procuram nos dias de hoje: “pemecah masalah”. Jadilah satu dan kesempatan kerja Anda akan terjamin!

Leaky ReLU

Fungsi Leaky ReLU tidak lebih dari versi yang ditingkatkan dari fungsi ReLU. Dalam fungsi ReLU, gradiennya adalah
0 untuk x < 0, yang menyebabkan neuron-neuron mati karena aktivasi di daerah ini. Leaky ReLU membantu menyelesaikan ini.
masalah. Alih-alih mendefinisikan fungsi Relu sebagai 0 untuk x kurang dari 0, kami mendefinisikannya sebagai sedikit
komponen linier dari x. Dapat didefinisikan sebagai:

f(x) = ax x < 0
f(x) = x, x >= 0

Apa yang kami lakukan di sini adalah kami hanya mengganti garis horizontal dengan garis tidak nol, bukan?
horizontal. Di sini satu adalah nilai kecil seperti 0,01 atau sesuatu yang serupa. Keuntungan utama menggantikan
garis horizontal adalah menghapus gradien nol.

Softmax

Fungsi softmax juga merupakan jenis fungsi sigmoida, tetapi berguna ketika kita mencoba menangani masalah
dari klasifikasi. Fungsi sigmoid seperti yang kita lihat sebelumnya mampu menangani hanya dua kelas. Yang
apa yang harus kita lakukan ketika mencoba menangani beberapa kelas? Hanya mengklasifikasikan ya atau tidak untuk
satu kelas tunggal tidak akan membantu. Fungsi softmax mengubah keluaran untuk setiap kelas menjadi nilai antara 0 dan
1 dan juga membagi dengan jumlah keluaran. Ini pada dasarnya memberikan probabilitas bahwa input berada di dalam sebuah
kelas tertentu. Dapat didefinisikan sebagai:

Katakanlah, misalnya, kita memiliki keluaran seperti [1.2, 0.9, 0.75], ketika kita menerapkan fungsi softmax,
kita akan mendapatkan [0.42, 0.31, 0.27]. Jadi, sekarang kita bisa menggunakannya sebagai probabilitas bahwa nilainya adalah
setiap kelas.

Fungsi softmax idealnya digunakan di lapisan keluaran klasifikasi, di mana kita benar-benar mencoba
menghasilkan probabilitas untuk menentukan kelas setiap entri.

Memilih Fungsi Aktivasi yang Tepat

Ufa! Banyak hal, ya? Dan kita belum melihat pertanyaan matematika yang terlibat dalam fungsi-fungsi ini. Tapi tidak
Mari kita terburu-buru, tidak ada jalan pintas untuk pembelajaran dan kita akan mempelajari segala sesuatu langkah demi langkah, item demi item, di
pola kursus di Data Science Academy.
Sekarang setelah kita melihat begitu banyak fungsi aktivasi, kita memerlukan beberapa logika/heuristik untuk mengetahui mana yang
fungsi aktivasi harus digunakan dalam situasi apa. Tidak ada aturan baku dan pilihan tergantung pada
masalah yang sedang Anda kerjakan.

Namun, tergantung pada sifat masalah, kita mungkin dapat membuat pilihan yang lebih baik untuk sebuah
konvergensi yang mudah dan cepat dari jaringan saraf.

Fungsi Sigmoid dan kombinasi mereka biasanya bekerja lebih baik dalam kasus pengklasifikasi.
Fungsi Sigmoid dan Tanh kadang-kadang dihindari karena masalah Gradien yang Menghilang (yang akan kita pelajari)
di bab tentang jaringan saraf berulang).
Fungsi ReLU adalah fungsi aktivasi umum dan digunakan dalam sebagian besar kasus saat ini.
Jika kita menemukan kasus neuron yang tidak berfungsi dalam jaringan kita, fungsi Leaky ReLU adalah yang terbaik.
pilih.
Selalu ingat bahwa fungsi ReLU hanya boleh digunakan di lapisan tersembunyi.
Sebagai aturan umum, Anda dapat mulai menggunakan fungsi ReLU dan kemudian beralih ke fungsi lainnya.
aktivasi dalam kasus ReLU tidak memberikan hasil yang optimal.

Apakah Anda mulai merasakan getaran dalam bekerja dengan Kecerdasan Buatan? Jadi teruslah mengikuti,
karena kita baru saja di awal! Sampai bab berikutnya!
Bab 9–AArsitektur Jaringan Saraf

Pada bab 11, kita akan mengembangkan jaringan saraf untuk klasifikasi digit tulisan tangan, menggunakan
bahasa Python (jika Anda belum tahu cara bekerja dengan bahasa ini, mulai sekarang juga dengan kursus kami
online sepenuhnya gratiske Python Fundamentos Untuk Analisis Data).Sebelum itu, mari kita pahami tentang
terminologi yang akan sangat berguna ketika kita mengembangkan model kita, mempelajari Arsitektur
jaringan saraf. Anggaplah kita memiliki jaringan di bawah ini:

Lapisan paling kiri dalam jaringan ini disebut lapisan input dan neuron-neuron di dalam lapisan tersebut adalah
disebut neuron input. Lapisan paling kanan atau output berisi neuron output atau,
seperti dalam kasus ini, satu neuron keluaran tunggal. Lapisan tengah disebut lapisan tersembunyi, mengingat bahwa yang
neuron-neuron di lapisan ini bukanlah input atau output. Istilah 'tersembunyi' mungkin terdengar sedikit misterius -
Pertama kali saya mendengar istilah itu, saya pikir pasti ada makna filosofis atau matematis yang mendalam.
- tapi itu sebenarnya tidak berarti apa-apa lebih dari 'sebuah lapisan yang bukan input atau output'. Jaringan
di atas hanya memiliki satu lapisan tersembunyi, tetapi beberapa jaringan memiliki beberapa lapisan tersembunyi. Karena
contoh, jaringan berikut dengan empat lapisan memiliki dua lapisan tersembunyi:
Jaringan lapisan ganda disebut Perceptron Multilapis atau MLP (Multilayer)
Perceptron), yaitu, jaringan saraf yang terdiri dari Perceptron (meskipun sebenarnya adalah jaringan dari
neuron sigmoid, seperti yang akan kita lihat lebih lanjut.

Desain lapisan input dan output dalam jaringan biasanya sederhana. Misalnya, anggaplah bahwa
kami sedang mencoba menentukan apakah sebuah gambar tulisan tangan mewakili angka '9' atau tidak. Salah satu cara yang alami untuk
merancang jaringan adalah mengkodekan intensitas piksel gambar ke neuron input. Jika gambar tersebut adalah
sebuah gambar dalam skala abu-abu 64 x 64, kita akan memiliki 64 × 64 = 4.096 neuron input, dengan
intensitas yang diukur dengan tepat antara 0 dan 1. Lapisan keluaran hanya akan berisi satu saja
neurónio dengan nilai di bawah 0,5 menunjukkan bahwa "gambar masukan bukanlah 9" dan nilai lebih tinggi
que 0,5 menunjukkan bahwa "gambar input adalah 9".

Meskipun desain lapisan masuk dan keluar dari jaringan saraf sering kali sederhana, mungkin ada
cukup variasi untuk desain lapisan tersembunyi. Secara khusus, tidak mungkin untuk merangkum proses
desain lapisan tersembunyi dengan sedikit aturan sederhana. Sebaliknya, peneliti jaringan saraf
mereka telah mengembangkan banyak heuristik desain untuk lapisan tersembunyi, yang membantu orang untuk mendapatkan
perilaku yang mereka inginkan dari jejaring sosial mereka. Kita akan mengenal berbagai heuristik desain jenis ini lebih lanjut.
sepanjang bab-bab berikutnya. Desain lapisan tersembunyi adalah salah satu poin krusial dalam
model-model Deep Learning.

Sejauh ini, kami telah mendiskusikan jaringan saraf di mana keluaran dari satu lapisan digunakan sebagai masukan untuk yang lainnya.
lapisan berikutnya. Jaringan ini disebut sebagai jaringan saraf feedforward. Ini berarti bahwa tidak ada loop di dalam
rede–informasi selalu dikirim ke depan, tidak pernah dikirim kembali. Jika kami memiliki
loop, kita akan menghadapi situasi di mana input untuk fungsi σ tergantung pada output. Ini akan sulit untuk
memahami dan, oleh karena itu, kami tidak mengizinkan loop seperti itu.

Namun, ada model lain dari jaringan saraf buatan di mana sirkuit umpan balik adalah
mungkin. Model-model ini disebut jaringan saraf berulang. Idenya dalam model-model ini adalah memiliki neuron
yang ditembakkan dalam periode waktu terbatas. Memicu dapat merangsang neuron lain, yang dapat
menembak sedikit lebih lambat, juga untuk durasi terbatas. Ini membuat lebih banyak neuron
menembak dan, seiring waktu, kami berhasil menciptakan rangkaian tembakan neuron. Loop tidak menyebabkan
masalah dalam model semacam itu, mengingat keluaran dari suatu neuron hanya mempengaruhi masukannya pada suatu saat
posterior, tidak secara langsung.

Umumnya, arsitektur jaringan saraf dapat dibagi menjadi 3 kategori spesifik:

1–Jaringan Saraf Feed-Forward

Ini adalah jenis jaringan saraf yang paling umum dalam aplikasi praktis. Lapisan pertama adalah input dan
lapisan terakhir adalah keluaran. Jika ada lebih dari satu lapisan tersembunyi, kami menyebutnya jaringan saraf
"profunda" (atau Deep Learning). Jenis-jenis jaringan saraf ini menghitung serangkaian transformasi yang
mengubah kesamaan antara kasus-kasus. Aktivitas neuron di setiap lapisan adalah fungsi non-
linier aktivitas di lapisan sebelumnya.

2–Jaringan Berulang

Jenis-jenis jaringan saraf ini memiliki siklus terarah dalam grafik koneksinya. Ini berarti bahwa terkadang
Anda bisa kembali ke tempat Anda mulai dengan mengikuti panah. Mereka mungkin memiliki dinamika yang rumit dan
ini bisa membuat mereka sangat sulit untuk dilatih. Namun, jenis ini lebih realistis secara biologis.

Saat ini, ada banyak minat untuk menemukan cara yang efisien dalam melatih jaringan berulang. Jaringan
jaringan saraf berulang adalah cara yang sangat alami untuk memodelkan data berurutan. Mereka setara dengan
jaringan yang sangat dalam dengan satu lapisan tersembunyi per potongan waktu; kecuali mereka menggunakan bobot yang sama
di setiap potongan waktu dan menerima input di setiap potongan. Mereka memiliki kemampuan untuk mengingat informasi di
keadaan tersembunyinya untuk jangka waktu yang lama, tetapi sangat sulit untuk melatih mereka untuk menggunakan potensi itu.

3–Jaringan Terhubung Simetris

Ini seperti jaringan berulang, tetapi koneksi antara unit-unitnya simetris (mereka memiliki bobot yang sama)
Dalam kedua arah). Jaringan simetris jauh lebih mudah dianalisis daripada jaringan berulang.
Mereka juga lebih terbatas dalam apa yang bisa mereka lakukan karena mematuhi fungsi energi. Jaringannya
terhubung secara simetris tanpa unit tersembunyi disebut "Jaringan Hopfield". Jaringan yang terhubung
simetrik dengan unit tersembunyi disebut "Mesin Boltzmann".

Dari ketiga kategori ini, kita bisa mencantumkan 10 arsitektur utama jaringan saraf:

Jaringan Multilayer Perceptron

Jaringan Syaraf Konvolusional
Jaringan Syaraf Rekuren
Memori Jangka Panjang Jangka Pendek (LSTM)
Jaringan Hopfield
Mesin Boltzmann
Jaringan Keyakinan Dalam
Auto-Enkoder Dalam
Jaringan Adversarial Generatif
Kapsul Jaringan Saraf Dalam (ini adalah jenis jaringan saraf yang sepenuhnya baru, diluncurkan pada akhir
2017)

Ingin belajar bagaimana membangun arsitektur jaringan saraf ini dengan cara yang efisien, profesional, dan sepenuhnya
praktik, dengan mini-proyek untuk solusi masalah dunia nyata, dalam visi komputer,
pemrosesan bahasa alami, deteksi penipuan, peramalan deret waktu, dan banyak lagi? Jadi
confira os únicos cursos online do Brasil, 100% em português, onde você aprende tudo sobre essas
arsitektur. Klik tautan di bawah untuk mengakses program lengkap:

Di bab berikutnya, kami akan memberi Anda gambaran umum tentang masing-masing dari 10 arsitektur ini dan sepanjang
Pada bab-bab berikutnya, kita akan mempelajari semuanya. Setiap arsitektur ini telah digunakan untuk menyelesaikan
berbagai masalah dan membuat sistem Kecerdasan Buatan. Mampu bekerja dengan IA secara efisien,
akan menjadi penentu untuk masa depan profesional Anda.
Bab 10–10 Arsitektur Teratas
Jaringan Saraf

Pembelajaran Mesin(Pembelajaran Mesin)Hal ini diperlukan untuk menyelesaikan tugas yang sangat kompleks
bagi manusia. Beberapa tugas begitu kompleks sehingga tidak praktis, jika tidak mustahil, bagi makhluk
manusia dapat menjelaskan semua nuansa yang terlibat. Jadi, alih-alih itu, kami menyediakan banyak
jumlah data untuk algoritma pembelajaran mesin dan membiarkan algoritma berfungsi,
mengeksplorasi data ini dan mencari model yang mencapai apaPara Ilmuwan DataE para insinyur dari
IA telah menentukan sebagai tujuan. Mari kita lihat dua contoh ini:

Sangat sulit untuk menulis program yang dapat menyelesaikan masalah seperti mengenali objek tiga dimensi.
mulai dari sudut pandang baru dalam kondisi pencahayaan baru di sebuah adegan yang kacau. Kami tidak
kita tahu program komputer mana yang harus ditulis karena kita tidak tahu bagaimana proses itu terjadi di dalam diri kita
otak. Mesmo se tivéssemos uma boa ideia sobre como fazê-lo, o programa poderia ser incrivelmente
rumit.

Sulit untuk menulis program untuk menghitung probabilitas suatu transaksi kartu kredit menjadi
fraudulen. Mungkin tidak ada aturan yang sederhana dan dapat diandalkan. Kami perlu menggabungkan sejumlah besar
besar aturan yang lemah. Penipuan adalah target yang bergerak, tetapi program harus terus berubah.

Di sinilah Machine Learning dapat diterapkan dengan sukses. Alih-alih menulis program secara manual untuk setiap
tarefa específica, nós coletamos muitos exemplos que especificam a saída correta para uma determinada
masukan. Sebuah algoritma pembelajaran mesin menerima contoh-contoh ini dan menghasilkan program yang melakukan
pekerjaan. Program yang dihasilkan oleh algoritma pembelajaran bisa terlihat sangat berbeda dari sebuah
program biasa yang ditulis tangan. Dapat berisi jutaan angka. Jika kita melakukannya dengan benar, programnya
bekerja untuk kasus baru (data baru). Jika datanya berubah, program juga bisa berubah saat dilatih
dalam data baru. Dan dengan pengurangan biaya komputasi (terutama menggunakan pemrosesan di
awan), jumlah besar data (Big Data) dan pemrosesan paralel di GPU, kami memiliki kondisi
sempurna untuk evolusi Machine Learning. Masalah terbesar, sungguh luar biasa, adalah kurangnya
profesional yang berkualitas dalam jumlah yang cukup untuk memenuhi permintaan pasar.

Beberapa contoh tugas yang lebih baik diselesaikan oleh pembelajaran mesin meliputi:

Pengenalan pola: objek dalam adegan nyata, identitas wajah atau ekspresi wajah, kata-kata
ditulis atau diucapkan.
Deteksi anomali: urutan transaksi kartu kredit yang tidak biasa, pola yang tidak biasa dari
pembacaan sensor di mesin industri tekstil.
Perkiraan: harga saham di masa depan atau nilai tukar, film apa yang seseorang ingin tonton, perkiraan
dari penjualan.

Machine Learning adalah bidang yang luas dalam kecerdasan buatan. Namun, ada sub-bidang dari Machine
Belajar, oPembelajaran Mendalam(atau Jaringan Saraf Dalam), telah berhasil mencapai hasil di tingkat seni
untuk tugas-tugas yang disebutkan di atas. Di bab ini Anda akan menemukan 10 Arsitektur Jaringan Teratas
Neurais, di antaranya arsitektur utama dari Deep Learning.
1- Jaringan Perceptron Multilapis

Perceptron, seperti yang kita pelajari di bab-bab sebelumnya, adalah algoritma sederhana yang ditujukan untuk melakukan
klasifikasi biner; yakni, memperkirakan apakah input termasuk dalam kategori tertentu yang menarik atau tidak:
penipuan atau tidak_penipuan, kucing atau tidak_kucing.

Sebuah Perceptron adalah pengklasifikasi linier; dengan kata lain, ini adalah algoritma yang mengklasifikasikan input dengan memisahkan dua
kategori dengan sebuah garis lurus. Masukan biasanya berupa vektor fitur x dikalikan dengan bobot w
ditambahkan ke dalam bias (atau bias) b. Berikut adalah contoh dari Perceptron: y = w * x + b. Sebuah Perceptron menghasilkan
satu output berdasarkan beberapa input nilai nyata, membentuk kombinasi linear menggunakan yang
pesos (dan kadang-kadang melewatkan keluaran melalui fungsi aktivasi non-linear).

Rosenblattmembangun sebuah Perceptron dengan satu lapisan. Artinya, algoritma Anda tidak termasuk beberapa lapisan,
yang memungkinkan jaringan saraf memodelkan hierarki sumber daya. Ini mencegah Perceptron
dapat melakukan klasifikasi non-linear, seperti fungsi XOR (sebuah pemicu operator XOR ketika
entri menampilkan satu karakteristik atau yang lain, tetapi tidak keduanya, berarti "OR eksklusif" ") sepertiMinsky e
Papert menunjukkan dalam bukunya.

Sebuah Multilayer Perceptron (MLP) adalah jaringan saraf buatan yang terdiri dari lebih dari satu Perceptron. Mereka adalah
terdiri dari lapisan input untuk menerima sinyal, lapisan output yang mengambil keputusan atau
prakiraan tentang masuknya, dan di antara keduanya, sejumlah lapisan tersembunyi yang sebenarnya
mekanisme komputasional dari MLP. MLP dengan satu lapisan tersembunyi mampu mendekati apapun
fungsi kontinu.

Multilayer Perceptron adalah semacam "Hello World" dari pembelajaran mendalam: cara yang baik untuk
mulai ketika Anda sedang belajar tentang Deep Learning.

MLP sering diterapkan pada masalah pembelajaran terawasi: melatih pada sebuah
sekumpulan pasangan masukan-keluaran dan belajar untuk memodelkan korelasi (atau ketergantungan) antara masukan ini dan
keluar. Pelatihan melibatkan penyesuaian parameter, atau bobot dan bias, dari model untuk meminimalkan kesalahan.
O backpropagation digunakan untuk melakukan penyesuaian bobot dan bias terkait dengan kesalahan, dan kesalahan itu sendiri
dapat diukur dengan berbagai cara, termasuk dengan kesalahan kuadrat rata-rata (MSE - Mean Squared Error).

Jaringan feed forward, seperti MLP, seperti tenis meja. Mereka terutama terlibat dalam dua
gerakan, suatu konstanta bolak-balik. Dalam pergerakan ke depan, aliran sinyal bergerak dari lapisan
melalui lapisan tersembunyi ke lapisan output dan keputusan dari lapisan output diukur dalam
hubungan dengan hasil yang diharapkan.

Dalam proses mundur, menggunakan backpropagation dan aturan rantai (Chain Rule), turunan parsial dari
fungsi kesalahan dari berbagai bobot dan bias direproduksi melalui MLP. Tindakan diferensiasi ini memberi kita
sebuah gradien, di sepanjang mana parameter dapat disesuaikan saat MLP bergerak satu langkah
lebih dekat dengan kesalahan minimum. Ini dapat dilakukan dengan algoritma optimasi berbasis gradien mana pun,
sebagai penurunan stokastik gradien. Jaringan terus bermain permainan ping-pong itu hingga kesalahan tidak
tidak bisa lagi dikurangi (sudah mencapai minimum yang mungkin). Keadaan ini dikenal sebagai konvergensi.

Terlihat seperti banyak hal? Ya, memang. Kita akan melihat proses ini lebih rinci di sini dalam buku ini dan jika Anda mau
belajar membangun model MLP untuk aplikasi praktis, melalui video dalam bahasa Portugis, klik di sini.

2- Jaringan Saraf Konvolusional

Pada tahun 1998, Yann LeCun dan rekan-rekannya mengembangkan sebuah pengenalan, yang sangat baik, untuk digit
naskah yang [Link] menggunakan backpropagation dalam jaringan feed forward dengan banyak lapisan
tersembunyi, banyak peta unit yang direplikasi di setiap lapisan, mengelompokkan keluaran unit yang berdekatan,
membentuk jaringan luas yang dapat menangani berbagai karakter sekaligus, bahkan jika mereka
menumpuk dan merupakan cara yang cerdas untuk melatih sistem secara keseluruhan, bukan hanya pengenalan.
Sore, arsitektur ini telah dipformalisasi dengan nama jaringan saraf konvolusional.

Jaringan Saraf Konvolusional (ConvNets atau CNNs) adalah jaringan saraf buatan dalam yang dapat
digunakan untuk mengklasifikasikan gambar, mengelompokkannya berdasarkan kesamaan (pencarian foto) dan melakukan pengenalan
objek dalam adegan. Ini adalah algoritma yang dapat mengidentifikasi wajah, individu, tanda jalan, wortel,
ornitorinkos dan banyak aspek lainnya dari data visual.

Jaringan konvolusional melakukan pengenalan karakter optik (OCR) untuk mendigitalkan teks dan
membuat pemrosesan bahasa alami menjadi mungkin dalam dokumen analog dan manuskrip, di mana
gambar adalah simbol yang harus ditranskripsi. CNN juga dapat diterapkan pada file audio ketika
ini diwakili secara visual sebagai spektrum. Baru-baru ini, jaringan konvolusional
diterapkan secara langsung pada analisis teks, serta data grafik.

Efektivitas jaringan konvolusional dalam pengenalan gambar adalah salah satu alasan utama mengapa
dunia menyaksikan efektivitas pembelajaran mendalam. Jenis jaringan ini mendorong besar
kemajuan dalamVisi Komputeryang memiliki aplikasi yang jelas pada mobil otonom, robotika, drone,
keamanan, diagnosis medis dan pengobatan untuk penyandang disabilitas visual.

Jaringan konvolusional mengonsumsi dan memproses gambar sebagai tensor dan tensor adalah matriks angka
dengan berbagai dimensi. Mereka mungkin sulit untuk divisualisasikan, jadi mari kita mendekatinya dengan analogi. Sebuah
skalar hanyalah sebuah angka, seperti 7; sebuah vektor adalah daftar angka (misalnya, [7,8,9]); dan sebuah matriks
itu adalah kisi persegi panjang angka yang mengisi beberapa baris dan kolom seperti dalam tabel.
Secara geometris, jika skalar adalah titik berdimensi nol, maka vektor adalah garis berdimensi satu,
sebuah matriks adalah bidang dua dimensi, tumpukan matriks adalah kubus tiga dimensi dan ketika setiap
elemento dessas matrizes tem uma pilha de mapas de recursos ligados a ele, você entra na quarta dimensão.
Tenang, jangan panik (belum). Kita akan melihat ini lebih lanjut dengan tenang, ketika kita belajar secara eksklusif.
arsitektur ini. Dalam kursus kami di Data Science Academy, kami menyertakan pelajaran lengkap tentang Aljabar
Linear, di mana skalar, vektor, matriks, dan tensor dipelajari dalam teori dan praktik, karena pengetahuan ini
ini adalah fundamental dalam pembangunan jaringan saraf dalam.

Hal pertama yang perlu diketahui tentang jaringan konvolusional adalah bahwa mereka tidak memproses gambar seperti manusia.
Portanto, você terá que pensar de uma maneira diferente sobre o que uma imagem significa quando é
diberikan dan diproses oleh jaringan konvolusional.

Jaringan konvolusional memahami gambar sebagai volume; yaitu, objek tiga dimensi, bukan
struktur datar yang akan diukur hanya oleh lebar dan tinggi. Ini karena gambar berwarna digital memiliki
kode merah-hijau-biru (RGB–Merah-Hijau-Biru), mencampurkan ketiga warna ini untuk menghasilkan
spektum warna yang dapat dilihat oleh manusia. Sebuah jaring konvolusional menerima gambar sebagai tiga
estratos terpisah berwarna ditumpuk satu di atas yang lain.

Dengan demikian, jaringan konvolusional menerima gambar sebagai kotak persegi panjang yang memiliki lebar dan tinggi yang
diukur oleh jumlah piksel sepanjang dimensi ini dan yang memiliki kedalaman tiga lapisan dalam,
satu untuk setiap huruf dalam RGB. Lapisan kedalaman ini disebut sebagai saluran.

Seiring gambar bergerak melalui jaringan konvolusional, kami menggambarkan dalam istilah
volume masuk dan keluar, mengekspresikannya secara matematis sebagai matriks multi-dimensi dari itu
bentuk: 30x30x3. Dari lapisan ke lapisan, dimensinya berubah saat melewati jaringan saraf
konvolusional hingga menghasilkan serangkaian probabilitas di lapisan keluaran, dengan satu probabilitas untuk setiap
kelas output yang mungkin. Kelas dengan probabilitas tertinggi akan menjadi kelas yang ditentukan untuk gambar masukan,
sebuah burung misalnya.

Anda perlu memberi perhatian penuh pada ukuran setiap dimensi volume gambar, karena mereka adalah
dasar-dasar operasi aljabar linier yang digunakan untuk memproses gambar. Kita bisa mendedikasikan dua bab
hanya untuk arsitektur ini. Sesungguhnya, itulah yang akan kita lakukan lebih lanjut di sini dalam buku dan apa yang sudah kita lakukan di
praktek di sini.

3- Jaringan Syaraf Berulang

Jaringan berulang adalah seperangkat algoritma jaringan saraf buatan yang sangat berguna.
untuk pemrosesan data berurutan, seperti suara, data deret waktu, atau bahasa alami.
Sebuah versi dari jaringan berulang telah digunakan olehDeepMindtidak ada proyek videogame dengan agen
mandiri.

Jaringan berulang berbeda dari jaringan umpan maju karena mencakup loop umpan balik, di mana keluaran
do passo n-1 adalah dipasang kembali ke jaringan untuk mempengaruhi hasil dari langkah n, dan seterusnya untuk setiap
etapa subsequente. Por exemplo, se uma rede é exposta a uma palavra letra por letra, dan diminta untuk
menebak setiap huruf berikut, huruf pertama dari sebuah kata akan membantu menentukan apa itu jaringan berulang
pikirkan huruf kedua bisa jadi.

Ini berbeda dari jaringan feed forward, yang belajar untuk mengklasifikasikan setiap angka tulisan tangan sebagai contoh,
secara independen, dan sesuai dengan piksel yang terpapar dari satu contoh tunggal, tanpa merujuk
seperti contoh sebelumnya untuk menyesuaikan perkiraannya. Jaringan feed forward menerima satu entri setiap kali dan
kami menghasilkan keluaran. Jaringan berulang tidak menghadapi batasan satu-untuk-satu yang sama.

Meskipun beberapa bentuk data, seperti gambar, tidak tampak seperti urutan, mereka dapat dipahami
sebagai urutan ketika diberi makan ke dalam jaringan berulang. Pertimbangkan sebuah gambar dari sebuah kata
manuscrita. Assim como as redes recorrentes processam a escrita manual, convertendo cada imagem em
satu huruf dan menggunakan awal sebuah kata untuk menebak bagaimana kata itu akan berakhir, jadi jaringan
dapat memperlakukan bagian dari gambar mana pun sebagai huruf dalam sebuah urutan. Sebuah jaringan saraf yang melintasi sebuah
Citra besar dapat belajar dari setiap wilayah, apa yang mungkin menjadi wilayah tetangga.

Jaringan berulang dan jaringan umpan maju "mengingat" sesuatu tentang dunia, memodelkan data yang ada
terpapar. Tapi mereka mengingat dengan cara yang sangat berbeda. Setelah pelatihan, jaringan feed forward
memproduksi model statis dari data dan model ini kemudian dapat menerima contoh baru dan mengklasifikasikannya atau
mengelompokkan mereka dengan tepat.

Sebaliknya, jaringan berulang menghasilkan model dinamis—yaitu, model yang berubah seiring waktu.
tempo–dari bentuk yang menghasilkan klasifikasi yang tepat tergantung pada konteks contoh yang ada
terbuka.

Untuk lebih tepat, model berulang mencakup keadaan tersembunyi yang menentukan klasifikasi sebelumnya di
sebuah seri. Pada setiap tahap berikutnya, keadaan tersembunyi ini digabungkan dengan data masukan dari yang baru
langkah untuk menghasilkan a) suatu keadaan tersembunyi yang baru dan, kemudian b) suatu klasifikasi baru. Setiap keadaan tersembunyi adalah
reciclado para produzir seu sucessor modificado.

Memori manusia juga sadar akan konteks, mendaur ulang kesadaran dari keadaan sebelumnya
untuk menginterpretasikan data baru dengan benar. Misalnya, mari kita pertimbangkan dua individu. Salah satunya menyadari
bahwa dia dekat dengan rumah Bob. Yang lainnya menyadari bahwa mereka telah naik pesawat. Mereka akan menginterpretasikan
putra “Oi Bob!” dengan dua cara yang sangat berbeda, tepatnya karena mempertahankan keadaan tersembunyi yang dipengaruhi oleh
ingatan jangka pendek dan sensasi sebelumnya.

Berbagai kenangan jangka pendek harus diceritakan pada waktu yang berbeda, dengan tujuan untuk memberikan
makna tepat di pintu masuk saat ini. Beberapa dari ingatan ini mungkin baru saja dibentuk dan yang lainnya
kenangan akan membentuk banyak langkah sebelum diperlukan. Jaringan berulang yang secara efektif
asosiasi memori dan input jarak jauh dalam waktu disebut Memori Jangka Panjang (LSTM), yang
kita akan melihatnya segera.

4- Memori Jangka Panjang Jangka Pendek (LSTM)

Pada pertengahan tahun 90-an, usulan para peneliti Jerman Sepp Hochreiter dan Juergen Schmidhuber
memperkenalkan variasi dari jaringan syaraf berulang dengan yang disebut unit Memori Jangka Panjang dan Pendek, seperti
solusi untuk masalah gradien yang menghilang, masalah umum dalam jaringan syaraf berulang.

LSTM membantu mempertahankan kesalahan yang dapat disalin melalui waktu dan lapisan. Dengan mempertahankan kesalahan yang lebih
konstanta, mereka memungkinkan jaringan berulang untuk terus belajar selama beberapa langkah waktu
(lebih dari 1000), sehingga membuka saluran untuk menghubungkan penyebab dan efek dari jarak jauh. Ini adalah salah satu tantangan
pusat untuk pembelajaran mesin dan IA, karena algoritma sering kali
dihadapkan oleh lingkungan di mana sinyal penghargaan langka dan terlambat, seperti kehidupan itu sendiri.
pemikir religius telah membahas masalah yang sama dengan ide karma atau imbalan ilahi,
teorizing konsekuensi yang tidak terlihat dan jauh untuk tindakan kita).

LSTMs mengandung informasi di luar aliran normal jaringan berulang dalam sel tertutup. Sebagai
informasi dapat disimpan, ditulis, atau dibaca dari sebuah sel, seperti data dalam memori sebuah
komputer. Sel mengambil keputusan tentang apa yang disimpan, dan kapan mengizinkan pembacaan, penulisan dan
eksklusi, melalui gerbang terbuka dan tertutup. Berbeda dengan penyimpanan digital di komputer,
Namun, gerbang-gerbang ini bersifat analog, diimplementasikan dengan perkalian elemen melalui sigmoid.
yang berada dalam rentang 0-1. Analog memiliki keunggulan dibandingkan digital karena dapat dibedakan dan, oleh karena itu,
memadai untuk backpropagation.

Pintu-pintu ini berfungsi atas sinyal yang mereka terima dan, dengan cara yang mirip dengan simpul jaringan saraf, mereka
memblokir atau mentransmisikan informasi berdasarkan kekuatan dan kepentingannya, yang mereka saring dengan
berat set mereka sendiri. Berat ini, seperti berat yang memodulasi input dan keadaan tersembunyi, adalah
disesuaikan melalui proses pembelajaran jaringan berulang. Artinya, sel-sel belajar ketika
memungkinkan data masuk, keluar, atau dihapus melalui proses iteratif membuat asumsi,
menghitung kesalahan selama backpropagation dan menyesuaikan bobot melalui penurunan gradien.

Diagram di bawah ini mengilustrasikan bagaimana data mengalir melalui sebuah sel memori dan dikendalikan oleh
seus portões.
LSTM memiliki banyak aplikasi praktis, termasuk pemrosesan bahasa alami, generasi
automatisasi teks dan analisis deret waktu. Jika Anda ingin melihat contoh-contoh ini dalam praktik, klik di sini.
Kami akan memiliki satu bab penuh yang didedikasikan untuk LSTM di sini dalam buku.

5- Jaringan Hopfield

Jaringan berulang unit non-linear biasanya sangat sulit untuk dianalisis. Mereka dapat se
berperilaku dengan berbagai cara yang berbeda: menetap dalam keadaan stabil, berosilasi atau mengikuti jalur
chaotik yang tidak dapat diprediksi di masa depan. Jaringan Hopfield terdiri dari unit batas
biner dengan koneksi rekursif antara mereka. Pada tahun 1982, John Hopfield menyadari bahwa, jika koneksinya adalah
simetris, ada fungsi energi global. Setiap "konfigurasi" biner dari seluruh jaringan memiliki energi,
sementara aturan keputusan dari batas biner membuat jaringan mematuhi minimum dari fungsi ini
energi. Cara yang sangat baik untuk menggunakan jenis komputasi ini adalah dengan menggunakan memori sebagai energi minimum
untuk jaringan saraf. Menggunakan energi minimum untuk merepresentasikan memori menghasilkan sebuah memori
endereçável ao conteúdo. Um item pode ser acessado por apenas conhecer parte do seu conteúdo. É robusto
melawan kerusakan pada perangkat keras.
Setiap kali kita mengingat sebuah konfigurasi, kita berharap untuk menciptakan minimum energi yang baru. Tetapi bagaimana jika dua
minimum mendatang berada di lokasi perantara? Ini membatasi kemampuan Jaringan Hopfield. Jadi,
bagaimana kita meningkatkan kapasitas Jaringan Hopfield? Para fisikawan menyukai gagasan bahwa matematika yang
mereka sudah mengenal dapat menjelaskan bagaimana otak berfungsi. Banyak artikel telah diterbitkan di majalah
fisika tentang Jaringan Hopfield dan kapasitas penyimpanannya. Akhirnya,Elizabeth Gardner
mengetahui bahwa ada aturan penyimpanan yang jauh lebih baik yang menggunakan kapasitas total dari beban.
Alih-alih mencoba menyimpan vektor sekaligus, dia telah melewati set pelatihan berkali-kali dan menggunakan
prosedur konvergensi Perceptron untuk melatih setiap unit agar memiliki keadaan yang benar, mengingat
status dari semua unit lain dalam vektor ini. Para ahli statistik menyebut teknik ini sebagai "pseudo-
probabilitas

Ada peran komputasional lain untuk Jaringan Hopfield. Alih-alih menggunakan jaringan untuk menyimpan memori,
kami gunakan untuk membangun interpretasi dari input sensorik. Input tersebut diwakili oleh unit yang terlihat, a
interpretasi diwakili oleh keadaan unit tersembunyi dan kesalahan interpretasi diwakili oleh
energi.

Máquinas Boltzmann

Sebuah Mesin Boltzmann adalah sejenis jaringan saraf rekursif stokastik. Itu dapat dilihat sebagai
kontrapartida stokastik dan generatif dari Jaringan Hopfield. Itu adalah salah satu jaringan saraf yang mampu
mempelajari representasi internal dan mampu mewakili serta menyelesaikan masalah kombinatorial yang sulit.

Tujuan dari pembelajaran algoritma Mesin Boltzmann adalah memaksimalkan produk dari
probabilitas yang diberikan oleh Mesin Boltzmann kepada vektor biner dalam kumpulan pelatihan. Itu
setara dengan memaksimalkan jumlah probabilitas log yang diberikan oleh Mesin Boltzmann kepada vektor
pelatihan. Ini juga setara dengan memaksimalkan kemungkinan kita mendapatkan tepat N kasus dari
pelatihan jika kita melakukan yang berikut: 1) Biarkan jaringan menetap dalam distribusi stasionernya di
tempo N berbeda, tanpa input eksternal dan 2) Mengubah vektor yang terlihat sekali di setiap langkah.
Sebuah prosedur efisien untuk pembelajaran mini-batch telah diusulkan untuk Mesin Boltzmann oleh
Salakhutdinov dan Hinton pada tahun 2012.

Dalam Mesin Boltzmann umum, pembaruan stokastik unit perlu dilakukan secara berurutan.
Ada arsitektur khusus yang memungkinkan pergantian pembaruan paralel yang jauh lebih efisien
(tanpa koneksi di dalam satu lapisan, tanpa koneksi dari lapisan yang diabaikan). Prosedur mini-batch ini
kembali memperbarui Mesin Boltzmann yang lebih paralel. Ini disebut Deep Boltzmann
Mesin (DBM), sebuah Mesin Boltzmann umum, tetapi dengan banyak hubungan yang hilang.

Pada tahun 2014, Salakhutdinov dan Hinton memperkenalkan pembaruan lain untuk model mereka, menyebutnya
Mesin Boltzmann Terbatas. Mereka membatasi konektivitas untuk mempermudah inferensi dan pembelajaran
(hanya satu lapisan unit tersembunyi dan tanpa koneksi antara unit tersembunyi). Dalam RBM, adalah
saya hanya perlu satu langkah untuk mencapai keseimbangan.

7- Jaringan Keyakinan Dalam

Backpropagation dianggap sebagai metode standar dalam jaringan saraf buatan untuk menghitung kontribusi
de kesalahan setiap neuron setelah memproses satu batch data (kita akan memiliki satu bab penuh tentang itu). Di
Sementara itu, ada beberapa masalah penting dalam backpropagation. Pertama, ini memerlukan data dari
pelatihan berlabel; sementara hampir semua data tidak berlabel. Kedua, waktu
pembelajaran tidak skala dengan baik, yang berarti bahwa itu sangat lambat di jaringan dengan banyak lapisan tersembunyi.
Ketiga, dapat terjebak di 'lokasi optimal'. Jadi, untuk jaringan dalam,
backpropagation jauh dari sempurna.

Untuk mengatasi keterbatasan backpropagation, para peneliti mempertimbangkan penggunaan pendekatan

pembelajaran tanpa pengawasan. Ini membantu menjaga efisiensi dan kesederhanaan dalam menggunakan suatu metode
gradien untuk menyesuaikan bobot, tetapi juga menggunakannya untuk memodelkan struktur input sensorik. Di
secara khusus, mereka menyesuaikan bobot untuk memaksimalkan probabilitas bahwa model penghasil telah menghasilkan masukan
sensorial. Pertanyaannya adalah jenis model generatif apa yang harus kita pelajari? Bisa berupa model yang didasarkan pada
energia seperti Mesin Boltzmann? Atau model kausal yang terbuat dari neuron? Atau hibrida dari keduanya?
dua?
Sebuah Jaringan Kepercayaan Mendalam dapat didefinisikan sebagai tumpukan Mesin Boltzmann Terbatas (RBM–
Restricted Boltzmann Machines), di mana setiap lapisan RBM berkomunikasi dengan lapisan sebelumnya dan
posterior. Simpul dari lapisan tunggal mana pun tidak berkomunikasi secara lateral.

Tumpukan RBM ini bisa diakhiri dengan lapisan Softmax untuk membuat pengklasifikasi, atau sekadar
bisakah membantu mengelompokkan data yang tidak direkam dalam skenario pembelajaran tanpa supervisi.

Kecuali lapisan awal dan akhir, setiap lapisan dalam Deep Belief Network memiliki fungsi
dupla: ia berfungsi sebagai lapisan tersembunyi untuk nod yang datang sebelumnya, dan sebagai lapisan masukan (atau
"terlihat") untuk kami yang datang setelahnya. Ini adalah jaringan yang dibangun dari jaringan lapisan tunggal.

Jaringan Keyakinan Mendalam digunakan untuk mengenali, mengelompokkan, dan menghasilkan gambar, urutan video dan
data penangkapan gerakan. Aplikasi lain dari Jaringan Keyakinan Mendalam adalah diPengolahan dari
Bahasa Alami. Jenis jaringan ini diperkenalkan oleh Geoff Hinton dan mahasiswanya pada tahun 2006.

8- Auto-Encoder Dalam

Um Deep Auto-Encoder terdiri dari dua jaringan simetris Deep Belief yang biasanya memiliki empat atau
lima lapisan dangkal yang mewakili setengah dari pengkodean (encoder) jaringan dan set kedua dari
empat atau lima lapisan yang membentuk setengah dari dekode (decoder).

Sebagai lapisan adalah Restricted Boltzmann Machines, blok bangunan dari Deep Belief Networks, dengan
berbagai keanehan yang akan kita bahas di bawah ini. Berikut adalah skema sederhana dari struktur sebuah Deep
Auto-Encoder:
Deep Auto-Encoders adalah cara yang sangat menyenangkan untuk mengurangi dimensionalitas non-linear karena
beberapa alasan: mereka menyediakan pemetaan yang fleksibel dalam kedua arah. Waktu pembelajaran adalah
linier (atau lebih baik) dalam jumlah kasus pelatihan. Dan model pengkodean akhir cukup kompak
e cepat. Namun, bisa sangat sulit untuk mengoptimalkan Deep Auto-Encoders menggunakan backpropagation. Dengan
berat awal yang kecil, gradien dari backpropagation mati. Tapi kita memiliki cara untuk mengoptimalkannya, menggunakan
pra-pelatihan lapisan-demi-lapisan tanpa pengawasan atau hanya menginisialisasi bobot dengan hati-hati.

Deep Auto-Encoders berguna dalam pemodelan topik atau pemodelan statistik topik abstrak
yang didistribusikan dalam koleksi dokumen. Ini, pada gilirannya, adalah langkah penting dalam sistem
tentang pertanyaan dan jawaban seperti IBM Watson.

Singkatnya, setiap dokumen dalam sebuah koleksi diubah menjadi Bag-of-Words (yaitu, sekumpulan
penghitungan kata) dan penghitungan kata ini diukur dalam desimal antara 0 dan 1, yang
dapat dipikirkan sebagai probabilitas suatu kata muncul dalam dokumen.

Penghitungan kata dalam skala kemudian dimasukkan ke dalam Jaringan Kepercayaan Mendalam, tumpukan dari
Mesin Boltzmann Terbatas, yang sebenarnya hanyalah sebagian dari Autoencoder. Ini
Deep Belief Networks, atau DBN, mengompres setiap dokumen menjadi satu set 10 angka melalui
serangkaian transformasi sigmoida yang memetakan Anda ke dalam ruang fitur.

Kumpulan angka dari setiap dokumen, atau vektor, kemudian dimasukkan ke dalam ruang vektorial yang sama, dan
jarak dari vektor dokumen lainnya yang diukur. Dalam istilah kasar, vektor dokumen
yang berikutnya termasuk dalam topik yang sama. Misalnya, sebuah dokumen bisa menjadi "pertanyaan" dan lainnya
itu bisa menjadi "jawaban", kombinasi yang akan dilakukan perangkat lunak menggunakan ukuran ruang vektorial.

Singkatnya, sekarang ada banyak cara berbeda untuk melakukan pra-pelatihan lapisan demi lapisan.
recursos. Para conjuntos de dados que não possuem um grande número de casos rotulados, o pré-
pendidikan membantu pembelajaran diskriminatif selanjutnya. Untuk kumpulan data yang sangat besar dan
diberi label, tidak perlu menginisialisasi bobot yang digunakan dalam pembelajaran terawasi menggunakan pra-
pelatihan tidak terawasi, bahkan untuk jaringan dalam. Pra-pelatihan adalah yang pertama baik
jalan untuk menginisialisasi bobot untuk jaringan dalam, tetapi sekarang ada cara lain. Tetapi jika
Kami membangun jaringan yang jauh lebih besar, kami akan memerlukan pra-pelatihan lagi! Jika Anda ingin belajar tentang
membangun Deep Auto-Encoders di Python, klik di sini.

9- Jaringan Generatif Adversarial

Jaringan Adversarial Generatif (GANs) adalah arsitektur jaringan saraf dalam yang terdiri dari
dua jaringan, meletakkan satu melawan yang lain (dari situ nama, "lawan").

GAN diperkenalkan dalam sebuah artikel oleh Ian Goodfellow dan peneliti lainnya dari Universitas
Montreal di Kanada, termasuk Yoshua Bengio, pada tahun 2014. Merujuk pada GAN, direktur penelitian dari
IA dari Facebook, Yann LeCun, menyebut pelatihan adversarial sebagai "ide paling menarik dalam 10 tahun terakhir".
tahun dalam Pembelajaran Mesin.

Potensi GAN sangat besar, karena mereka dapat belajar meniru distribusi data mana pun.
Oleh karena itu, GAN dapat diajarkan untuk menciptakan dunia yang anehnya mirip dengan dunia kita di mana saja
domain: gambar, musik, ucapan, prosa. Mereka adalah seniman robot dalam pengertian tertentu, dan produksi mereka adalah
mengesankan – bahkan menyentuh.

Untuk memahami GAN, Anda harus tahu bagaimana algoritma generator bekerja, dan untuk itu, membandingkannya
algoritma diskriminatif itu berguna. Algoritma diskriminatif berusaha untuk mengklasifikasikan data masukan;
artinya, mengingat sumber daya dari sebuah instansi data, mereka memprediksi sebuah label atau kategori yang mana data tersebut
pertencem.

Sebagai contoh, dengan mempertimbangkan semua kata dalam sebuah email, sebuah algoritma diskriminatif dapat memprediksi apakah
pesan adalah spam atau tidak_spam. Spam adalah salah satu label, dan kantong kata (Bag of Words) yang dikumpulkan dari
e-mail adalah sumber daya yang membentuk data masukan. Ketika masalah ini dinyatakan
Secara matematis, label disebut y dan sumber daya disebut x. Formulasi p (y | x) digunakan
probabilitas y diberikan x
email adalah spam dengan kata-kata yang terkandung.

Oleh karena itu, algoritme diskriminatif memetakan fitur ke label. Mereka hanya peduli dengan
korelasi ini. Salah satu cara untuk memikirkan tentang algoritma generatif adalah bahwa mereka melakukan kebalikannya. Alih-alih
memprediksi sebuah label dengan sumber daya tertentu, mereka mencoba memprediksi sumber daya dengan label tertentu.

Pertanyaan yang coba dijawab oleh algoritma generator adalah: anggap bahwa email ini adalah spam, berapa probabilitasnya
dari sumber daya? Sementara model diskriminatif memperhatikan hubungan antara y dan x, model
generatif memperhatikan "bagaimana Anda mendapatkan x". Mereka memungkinkan Anda untuk menangkap p (x | y), a
probabilitas x diberikan y, atau probabilitas karakteristik yang ditawarkan dalam sebuah kelas. (Dengan demikian, para
Algoritma generator juga dapat digunakan sebagai pengklasifikasi, meskipun mereka dapat melakukan lebih dari itu
mengategorikan data masukan.)

Cara lain untuk memikirkan tentang ini adalah membedakan diskriminatif dari generatif seperti ini:

Model diskriminatif belajar batas antara kelas

Model generatif memodelkan distribusi kelas individu
Sebuah jaringan saraf, yang disebut generator, menghasilkan instansi data baru, sementara yang lainnya, discriminator, mengidentifikasikannya.
menilai keaslian; yaitu, diskriminator memutuskan apakah setiap instansi data yang ditinjau termasuk ke dalam
kumpulan data pelatihan nyata atau tidak.

Katakanlah kita sedang mencoba melakukan sesuatu yang lebih sepele daripada meniru Mona Lisa. Mari kita menghasilkan angka.
tulisan tangan seperti yang ditemukan dalam kumpulan dados MNISTyang diambil dari dunia nyata. Tujuannya
discriminador, ketika ditunjukkan sebuah instansi dari set data asli MNIST, mengenalinya
sebagai yang otentik.

Sementara itu, generator sedang membuat gambar baru yang dikirimkan ke diskriminator. Ini terjadi dengan
harapan bahwa mereka, juga, dianggap otentik, meskipun mereka palsu. Tujuan dari generator
adalah menghasilkan angka yang ditulis tangan oleh diri sendiri. Tujuan dari diskriminator adalah untuk mengidentifikasi gambar
berasal dari generator sebagai palsu.

Berikut adalah langkah-langkah yang dilakukan oleh GAN:

Generator menerima angka acak dan mengembalikan gambar.

Gambar yang dihasilkan ini diberikan ke diskriminator di samping aliran gambar yang diambil dari kumpulan
data nyata.
Discriminador mengambil gambar nyata dan palsu dan mengembalikan probabilitas, sebuah angka antara 0 dan 1, dengan 1
mewakili perkiraan keaslian dan 0 mewakili kebohongan.

Jadi, Anda memiliki umpan balik ganda:

Discriminador berada dalam lingkaran umpan balik dengan gambar-gambar nyata yang kita ketahui.
Generator berada dalam loop umpan balik dengan diskriminator.

Ingin belajar bagaimana membangun GAN, salah satu arsitektur yang paling luar biasa dalam Deep Learning, 100% di
português dan 100% online, untuk menghasilkan gambar secara otomatis? Klik sini.
10- Kapsul Jaringan Saraf Dalam

Pada akhir tahun 2017, Geoffrey Hinton dan timnya menerbitkan dua artikel yang memperkenalkan jenis baru dari
jaringan saraf yang disebut Kapsul. Selain itu, tim menerbitkan sebuah algoritma, yang disebut perutean
dinamis antara kapsul, yang memungkinkan untuk melatih jaringan ini.

Untuk semua orang di komunitas Deep Learning, ini adalah berita besar, dan karena berbagai alasan. Pertama
Hinton adalah salah satu pendiri Deep Learning dan seorang penemu berbagai model dan algoritma yang
hari ini sangat luas digunakan. Kedua, artikel-artikel ini menyajikan sesuatu yang benar-benar baru, dan
ini sangat emosional karena kemungkinan akan mendorong gelombang tambahan penelitian dan aplikasi
sangat inovatif.

SebagaiCapsules memperkenalkan blok bangunan baru yang dapat digunakan dalam pembelajaran mendalam untuk
memodelkan dengan lebih baik hubungan hierarkis dalam representasi pengetahuan internal suatu jaringan
neural. Intuisi di balik mereka sangat sederhana dan elegan.

Hinton dan timnya mengusulkan cara untuk melatih jaringan yang terdiri dari kapsul ini dan melatihnya dengan
Keberhasilan dalam sekumpulan data yang sederhana, mencapai kinerja puncak. Ini sangat menggembirakan. Di
Sementara itu, ada tantangan. Implementasi saat ini jauh lebih lambat daripada model modern lainnya.
pembelajaran mendalam. Waktu akan menunjukkan apakah jaringan Capsule dapat dilatih dengan cepat dan
efisien. Selain itu, kita perlu melihat apakah mereka bekerja dengan baik di kumpulan data yang lebih sulit dan di
berbagai domain.

Dalam hal apapun, jaringan Capsule adalah model yang sangat menarik dan sudah berfungsi, yang pasti akan
akan berkembang seiring waktu dan akan berkontribusi pada perluasan aplikasi pembelajaran yang lebih besar
mendalam.

Kami memasukkan Capsules di antara 10 arsitektur jaringan saraf teratas, karena mereka mewakili inovasi.
dan kemajuan di bidang Deep Learning yang luar biasa dan penuh warna serta sistem Kecerdasan Buatan. Profesional
yang benar-benar ingin merangkul AI sebagai karir, harus memperhatikan pergerakan dan inovasi di bidang ini.

Esta não é uma lista definitiva de arquiteturas e existem outras, tais como Word2Vec, Doc2vec, Neural
Embeddings dan variasi arsitektur yang disajikan di sini, seperti Denoising Autoencoders, Variational
Autoencoder, selain kategori lainnya seperti Pembelajaran Penguatan Dalam. Persis untuk membantu
mereka yang mencari pengetahuan terdepan 100% dalam bahasa Portugal dan 100% online, yang kami ciptakan
Pelatihan Kecerdasan Buatansatu-satunya program di Brasil yang lengkap, dengan semua alat yang
siswa perlu untuk belajar bekerja dengan IA secara efisien. Siswa belajar pemrograman paralel
em GPU, Deep Learning dan kerangkanya, mempelajari arsitektur utama dengan aplikasi praktis dan
mengembangkan aplikasi Visio Komputer dan Pemrosesan Bahasa Alami. Klikdisinidan lihat
lebih banyak rincian tentang program.

Ini menyimpulkan bagian pertama dari buku ini, dengan pengantar ke dunia Deep Learning. Di berikutnya
di bab ini kita akan mulai melihat jaringan saraf dalam aksi. Sampai saat itu.
Bab 11–Desain Jaringan Saraf Untuk
Pengenalan Angka

Di bagian pertama buku online ini, selama 10 bab pertama, kami mendefinisikan dan mempelajari alam semesta
jaringan saraf buatan. Pada titik ini Anda harus sudah memiliki pemahaman yang baik tentang apa itu.
algoritma dan bagaimana mereka dapat digunakan, selain pentingnya jaringan saraf untuk pembangunan sistem
Kecerdasan Buatan. Kami siap untuk memulai pembangunan jaringan saraf dan selanjutnya
Kami akan mempelajari arsitektur yang paling canggih. Mari kita mulai dengan mendefinisikan Desain Jaringan Saraf Untuk
Pengenalan Digit.

Tugas pertama kita adalah membangun jaringan saraf untuk mengenali tulisan tangan, yaitu, digit yang ditulis.
tangan yang telah dipindai menjadi gambar di komputer. Mengapa kita akan mulai dengan jenis tugas ini?
Karena ia memungkinkan untuk menelusuri semua tahapan dan prosedur matematis dari jaringan saraf, menjadi
Oleh karena itu, merupakan pengantar yang sangat baik. Mari kita mulai?

Jika Anda mengikuti kursus diAkademi Data Sciencesudah tahu bahwa: sebelum berpikir untuk menulis Anda
Baris pertama kode, perlu untuk mendefinisikan dengan jelas masalah yang harus diselesaikan. Teknologi ada untuk
menyelesaikan masalah dan definisi yang jelas tentang tujuan adalah titik awal dari setiap proyek yang sukses! Di sini
Pada bab ini, kita akan mendefinisikan masalah yang harus diselesaikan, dalam hal ini pengenalan digit tulisan tangan.

Kita bisa membagi masalah pengenalan digit tulisan tangan menjadi dua sub-masalah. Pertama,
kita perlu menemukan cara untuk memecah gambar yang mengandung banyak digit dalam satu urutan
gambar terpisah, masing-masing berisi satu digit. Misalnya, kami ingin memecah gambar:

dalam enam gambar terpisah:

Nós, humanos, resolvemos esse problema de segmentação com facilidade, mas é um desafio para um
program komputer membagi gambar dengan benar. Setelah gambar tersegmentasi,
program perlu mengklasifikasikan setiap digit secara individu. Jadi, misalnya, kami ingin program kami
secara otomatis mengenali bahwa digit pertama di atas adalah 5.
Mari kita fokus untuk menulis program untuk menyelesaikan masalah kedua, yaitu, mengklasifikasikan digit.
individu. Masalah segmentasi tidak begitu sulit untuk dipecahkan, asalkan Anda memiliki yang baik
cara untuk mengklasifikasikan digit individu. Ada banyak pendekatan untuk menyelesaikan masalah
segmentasi. Satu pendekatan adalah menguji banyak cara berbeda untuk mengsegmentasi gambar, menggunakan
pengklasifikasi digit individual untuk menandai setiap segmentasi uji. Sebuah segmentasi uji memperoleh
skor tinggi jika pengklasifikasi digit individu yakin tentang klasifikasinya di semua
Segmen-segmen dan skor rendah jika pengklasifikasi memiliki banyak masalah di satu atau lebih segmen.
ideanya adalah, jika classifier mengalami masalah di suatu tempat, kemungkinan besar ia mengalami masalah
karena segmentasi dipilih secara tidak tepat. Ide ini dan variasi lainnya dapat digunakan untuk
menyelesaikan masalah segmentasi. Jadi, alih-alih khawatir tentang segmentasi, kami
kita akan fokus pada pengembangan jaringan saraf yang dapat menyelesaikan masalah yang paling menarik dan
sulit, yaitu, mengenali digit individu yang ditulis tangan.

Untuk mengenali angka individual, kita akan menggunakan jaringan saraf tiga lapis:

Lapisan input jaringan mengandung neuron yang mengkodekan nilai-nilai dari piksel input. Sesuai
Kami akan membahas di bab berikutnya, data pelatihan kami untuk jaringan akan terdiri dari banyak gambar
28 x 28 piksel dari digit yang ditulis tangan yang dipindai dan, oleh karena itu, lapisan input berisi 28 × 28 =
784 neuron (Catatan: sebuah gambar tidak lebih dari sekadar matriks, dalam hal ini dengan dimensi 28×28, yang
kami akan mengonversi menjadi vektor yang ukurannya akan 784, di mana setiap item mewakili satu piksel dalam gambar).
piksel masukan berwarna abu-abu, dengan nilai 0.0 mewakili putih dan nilai 1.0
mewakili hitam. Nilai-nilai perantara mewakili nuansa abu-abu yang secara bertahap semakin gelap.
Lapisan kedua jaringan adalah lapisan tersembunyi. Kami akan mewakili jumlah neuron di lapisan ini.
tersembunyi oleh n, dan mari kita bereksperimen dengan nilai-nilai berbeda untuk n. Contoh yang ditunjukkan di atas menggambarkan sebuah
lapisan kecil tersembunyi, yang hanya mengandung n = 15 neuron.

Lapisan output dari jaringan berisi 10 neuron. Jika neuron pertama "menembak" (diaktifkan), yaitu,
jika output mendekati 1, maka ini menunjukkan bahwa jaringan menganggap digit tersebut adalah 0. Jika neuron kedua 'menembak'
(untuk aktif), ini akan menunjukkan bahwa jaringan berpikir bahwa digitnya adalah 1. Dan seterusnya. Singkatnya, kita akan
menomori neuron keluaran dari 0 hingga 9 dan mencari tahu neuron mana yang memiliki nilai aktivasi tertinggi. Jika
neuron ini adalah, katakanlah, neuron nomor 6, jadi jaringan kita akan menebak bahwa digit input adalah 6.
Dan seterusnya untuk neuron keluaran lainnya.

Anda mungkin bertanya-tanya mengapa kami menggunakan 10 neuron keluaran. Setelah semua, tujuan dari jaringan adalah memberi tahu kami mana
digit (0,1,2, …, 9) sesuai dengan gambar input. Salah satu cara yang tampaknya alami untuk melakukannya adalah
menggunakan hanya 4 neuron keluaran, memperlakukan setiap neuron seolah-olah mengambil nilai biner, tergantung pada apakah
keluaran neuron lebih dekat ke 0 atau 1. Empat neuron cukup untuk mengkodekan respons,
Sejak 2ˆ4 = 16 lebih dari 10 nilai yang mungkin untuk digit input. Mengapa jaringan kita harus
gunakan 10 neuron sebagai gantinya? Bukankah ini tidak efisien? Justifikasi akhirnya adalah empiris: kita bisa
bereksperimen dengan kedua proyek jaringan, dan memeriksa bahwa, untuk masalah spesifik ini, jaringan dengan 10
neuron keluar belajar mengenali digit lebih baik daripada jaringan dengan 4 neuron keluar. Tapi ini
mas masih meninggalkan pertanyaan mengapa penggunaan 10 neuron keluaran berfungsi lebih baik. Apakah ada heuristik
yang memberi tahu kita sebelumnya bahwa kita harus menggunakan pengkodean 10 output alih-alih pengkodean 4
saídas?

Memahami mengapa kita melakukan ini, membantu berpikir tentang apa yang sebenarnya dilakukan oleh jaringan saraf. Pertimbangkan
Pertama, kasus di mana kita menggunakan 10 neuron keluaran. Mari kita fokus pada neuron keluaran pertama,
dia yang mencoba memutuskan apakah digit itu 0 atau tidak. Dia melakukan ini dengan menimbang bukti dari lapisan tersembunyi yang
neuron. Apa yang dilakukan neuron-neuron tersembunyi ini? Mari kita anggap bahwa neuron pertama di
lapisan tersembunyi mendeteksi atau tidak sebuah gambar seperti berikut:

Ini dapat dilakukan dengan memberikan bobot yang kuat pada piksel input yang tumpang tindih dengan gambar dan hanya memperhatikan bobot tersebut.
sedikit lebih dari entri lainnya. Dengan cara yang sama, mari kita anggap bahwa yang kedua, ketiga, dan keempat
neurons in the hidden layer detect whether the following images are present or not:
Como você pode ter adivinhado, essas quatro imagens juntas compõem a imagem 0 que vimos na linha de
digit ditampilkan sebelumnya:

Jadi, jika keempat neuron tersembunyi aktif, kita dapat menyimpulkan bahwa digit tersebut adalah 0. Tentu saja,
ini bukan satu-satunya jenis bukti yang dapat kita gunakan untuk menyimpulkan bahwa gambar itu adalah 0–kita bisa
secara sah mendapatkan 0 dengan banyak cara lain (misalnya, melalui terjemahan gambar di atas,
atau distorsi kecil). Tetapi tampaknya aman untuk mengatakan bahwa, setidaknya dalam kasus ini, kita akan menyimpulkan bahwa masuknya
era um 0.

Menganggap bahwa jaringan saraf berfungsi seperti ini, kita dapat memberikan penjelasan yang masuk akal mengapa lebih baik memiliki
10 keluaran dari jaringan, alih-alih 4. Jika kita memiliki 4 keluaran, neuron keluaran pertama akan mencoba memutuskan apa yang
namun satu bit signifikan dari digit mewakili. Dan tidak ada cara mudah untuk mengaitkan bit ini lebih
signifikan dengan bentuk sederhana, seperti yang ditunjukkan di atas. Bentuk komponen dari digit akan
secara intim berkaitan dengan (katakanlah) bit paling signifikan pada keluaran.

Semua ini hanyalah sebuah heuristik. Tidak ada yang mengatakan bahwa jaringan saraf tiga lapis harus beroperasi dengan cara yang
yang kita deskripsikan, dengan neuron tersembunyi mendeteksi bentuk komponen sederhana. Mungkin sebuah
algoritma pembelajaran cerdas temukan beberapa penugasan bobot yang memungkinkan kita menggunakan hanya 4
neuron yang keluar. Namun, menggunakan heuristik yang baik dapat menghemat banyak waktu dalam merancang yang baik
arsitektur jaringan saraf.

Kami sudah memiliki desain untuk jaringan saraf kami. Sekarang kita perlu menentukan bagaimana prosesnya akan berlangsung.
pembelajaran algoritme, sebelum mulai mengkode jaringan kita dalam bahasa Python. Kami akan menggunakan
pelatihan dengan Gradien Menurun, topik bab berikutnya, yang memang tidak akan saya lewatkan dengan cara apa pun,
jika saya adalah Anda, karena di sana ada 'sihir' di balik jaringan saraf. Sampai jumpa!

Untuk mengikuti bab-bab berikutnya dan menjalankan contoh-contohnya, Anda harus memiliki Anaconda Python.
diinstal di komputer Anda dengan versi Python 3.6.x. Akses bab 1 dari kursus gratisPython
Dasar-Dasar Untuk Analisis Data, untuk belajar cara menginstal Anaconda.
Bab 12–Pembelajaran Dengan Penurunan
Gradien

Di bab sebelumnya, kami mendefinisikan desain untuk jaringan saraf kami dan sekarang kami dapat memulai proses
aprendizado de máquina. Neste capítulo você vai compreender o que é o Aprendizado Com a Descida do
Gradien.

Hal pertama yang kita butuhkan adalah satu set data untuk pelatihan jaringan. Kami akan menggunakan set tersebut
dataMNISTyang berisi puluhan ribu gambar digital dari angka tulisan tangan,
bersama dengan klasifikasi yang benar. Nama MNIST berasal dari fakta bahwa ini adalah subset
dimodifikasi dari dua set data yang dikumpulkan oleh NIST, Institut Nasional Standar dan Teknologi
dari Amerika Serikat. Berikut adalah beberapa gambar dari MNIST:

MNIST memiliki dua bagian. Bagian pertama berisi 60.000 gambar yang digunakan sebagai data untuk
pelatihan. Gambar-gambar ini adalah sampel dari manuskrip yang dipindai dari 250 orang, setengah dari mereka
pegawai Biro Sensus AS dan setengah dari siswa sekolah menengah. Gambar-gambar tersebut ada di
skala abu-abu dan berukuran 28 x 28 piksel. Bagian kedua dari kumpulan data MNIST memiliki 10.000
gambar yang akan digunakan sebagai data uji, juga 28 kali 28 piksel dalam skala abu-abu. Kita akan menggunakan
data tes untuk mengevaluasi seberapa baik jaringan saraf kami belajar mengenali digit. Untuk membuat ini
sebuah uji coba kinerja yang baik, data uji diambil dari kumpulan yang berbeda dari 250 orang di
mengenai data pelatihan asli (meskipun masih menjadi kelompok yang terpisah antara karyawan dari
Biro Sensus dan siswa sekolah menengah). Ini membantu kami percaya bahwa sistem kami dapat mengenali
angka orang yang tulisannya tidak terlihat selama pelatihan.

Kami akan menggunakan notasi x untuk menunjukkan sebuah masukan (input) pelatihan. Akan lebih nyaman untuk mempertimbangkan setiap
entrada pelatihan x (setiap gambar) sebagai vektor 784 posisi (28 x 28 piksel). Gambar di bawah ini
representasikan bagaimana vektor ini dibangun:
Setiap entri dalam vektor mewakili nilai abu-abu untuk satu piksel dalam gambar. Mari kita tunjukkan keluarnya
correspondente desejada por y = y(x), onde y é um vetor com dimensão 10. Por exemplo, se uma imagem de
pelatihan pribadi, x, mewakili 3, maka y(x) = (0,0,0,1,0,0,0,0,0,0)T adalah keluaran yang diinginkan dari jaringan.
Perhatikan bahwa T di sini adalah operasi transposisi, mengubah vektor baris menjadi vektor biasa.
(kolom). Mari kita jelaskan ini lebih jelas. Perhatikan gambar di bawah ini:

Mari kita menggunakan piksel gambar yang sesuai dengan seluruh aliran yang disebut "fitur". Labelnya adalah Satu-
Hot Encoded 1-hot. Reseptor yang mewakili kelas keluaran gambar dengan digit 3 menjadi
"0001000000" sekali kita memiliki 10 kelas untuk 10 digit yang mungkin, di mana indeks pertama
corresponds to the digit "0" and the last corresponds to the digit "9".

Apa yang kami inginkan adalah algoritme yang memungkinkan kami menemukan bobot dan bias agar keluaran dari jaringan mendekati
de y(x) untuk semua input pelatihan x. Untuk mengukur seberapa baik kita mencapai ini
tujuan, kami mendefinisikan sebuah fungsi biaya:

Fungsi Biaya Kuadratik

Dalam rumus di atas, w menunjukkan pengumpulan semua bobot dalam jaringan, b semua bias, n adalah jumlah total dari
entri pelatihan, a adalah vektor keluaran dari jaringan (saat x adalah input) dan jumlahnya adalah tentang semua
entri pelatihan x. Tentu saja, keluaran a bergantung pada x, w, dan b, tetapi untuk menjaga notasi tetap sederhana, saya tidak
saya secara eksplisit menunjukkan ketergantungan ini. Notasi ‖v‖ hanya menunjukkan fungsi panjang yang biasa untuk
sebuah vektor v. Kita akan menyebut C sebagai fungsi biaya kuadrat, yang juga dikenal sebagai kesalahan kuadrat
rata-rata atau hanya MSE (Mean Squared Error). Memeriksa bentuk fungsi biaya kuadrat,
kami melihat bahwa C (w, b) tidak negatif, karena setiap istilah dalam jumlah tersebut tidak negatif. Selain itu, biaya C (w, b)
menjadi kecil, yaitu, C (w, b) ≈ 0, tepatnya ketika y(x) kira-kira sama dengan keluaran, a, untuk
todas as entradas de treinamento x.

Oleh karena itu, algoritma pelatihan kami melakukan pekerjaan yang baik jika ia dapat menemukan bobot dan bias agar C
(w, b) ≈ 0. Ini pada dasarnya berarti bahwa model kami membuat prediksi yang benar, yaitu setiap kali
kami memperkenalkan model dengan gambar digit 3, ia mampu mengenali bahwa itu adalah angka 3.

Sebaliknya, algoritma tidak akan memiliki kinerja yang baik, ketika C (w, b) adalah nilai yang lebih besar dari 0–ini
itu berarti algoritma kami tidak dapat membuat prediksi, yaitu, ketika disajikan kepada
gambar dengan digit 3, ia tidak mampu memperkirakan bahwa itu adalah angka 3. Ini terjadi, karena a
perbedaan antara nilai nyata dari keluaran dan nilai yang diprediksi oleh model, sangat tinggi. Dengan demikian, tujuan kami dari
algoritma pelatihan akan meminimalkan biaya C(w, b) berdasarkan bobot dan bias. Dalam kata lain
kata-kata, kami ingin menemukan sekumpulan bobot dan bias yang membuat biaya sekecil mungkin. Mari kita
lakukan ini menggunakan algoritma yang dikenal sebagai Penurunan Gradien (Gradient Descent).

Tapi sebelumnya, satu pertanyaan. Mengapa memperkenalkan biaya kuadratik? Lagipula, kita tidak tertarik
terutama oleh jumlah gambar yang diklasifikasikan dengan benar oleh jaringan? Mengapa tidak mencoba memaksimalkan
angka ini langsung, alih-alih meminimalkan ukuran, seperti biaya kuadrat? Masalahnya dengan ini
yaitu bahwa jumlah gambar yang diklasifikasikan dengan benar bukanlah fungsi "smooth" dari bobot dan bias di
bias. Secara umum, melakukan perubahan kecil pada bobot dan bias tidak akan mengubah jumlah
gambar pelatihan yang diklasifikasikan dengan benar. Ini membuat sulit untuk menemukan cara mengubah bobot dan
bias untuk meningkatkan kinerja. Jika, alih-alih, kita menggunakan "fungsi biaya yang halus", seperti biaya
kuadratik, akan mudah untuk menemukan cara membuat sedikit perubahan pada bobot dan bias untuk mendapatkan sebuah
perbaikan biaya. Itulah sebabnya kami memfokuskan diri terlebih dahulu pada peminimalan biaya kuadratik dan hanya
setelah itu kita akan memeriksa akurasi klasifikasi.

Bahkan mempertimbangkan bahwa kita ingin menggunakan "fungsi biaya yang halus", Anda masih bisa bertanya mengapa
kami memilih fungsi kuadratik. Mungkin jika kami memilih fungsi biaya yang berbeda, kami akan mendapatkan sebuah
kumpulan bobot dan bias yang benar-benar berbeda? Ini adalah kekhawatiran yang valid dan, nanti, kita akan membahas kembali
fungsi biaya dan kita akan melakukan beberapa modifikasi. Namun, fungsi biaya kuadratik yang ditampilkan
anteriormente funciona perfeitamente para entender os conceitos básicos de aprendizagem em redes neurais,
jadi kita akan tetap dengan ini untuk sementara waktu.

Mencatat, tujuan kita dalam membangun jaringan syaraf adalah menemukan bobot dan bias yang meminimalkan
fungsi biaya kuadratik C (w, b).

Penurunan Gradien

Sebagian besar tugas dalam Machine Learning sebenarnya adalah masalah optimasi dan salah satu algoritma
yang paling sering digunakan untuk ini adalah Algoritma Penurunan Gradien. Untuk pemula, nama Algoritma
Penurunan Gradien mungkin terlihat menakutkan, tetapi saya harap setelah membaca apa yang ada tepat di bawah ini, ini
jangan biarkan itu menjadi misteri bagi Anda.
Penurunan Gradien adalah alat standar untuk mengoptimalkan fungsi kompleks secara iteratif di dalam
sebuah program komputer. Tujuannya adalah: mengingat fungsi arbitrari, menemukan minimum. Untuk
beberapa subset kecil dari fungsi - yang cembung - hanya memiliki satu minimum
juga terjadi bahwa itu global. Untuk fungsi yang lebih realistis, bisa ada banyak minimum, jadi sebagian besar
Dua minimum adalah lokal. Pastikan bahwa optimasi menemukan "minimum" yang "terbaik" dan tidak terjebak.
dalam minimum sub-optimis (masalah umum selama pelatihan algoritma).

Untuk memahami intuisi dari Penurunan Gradien, mari kita menyederhanakan sedikit hal-hal. Mari kita
membayangkan bahwa kita hanya menerima sebuah fungsi dengan banyak variabel dan ingin meminimalkan fungsi itu.
Mari kita mengembangkan teknik yang disebut Turunan Gradien yang dapat digunakan untuk menyelesaikan hal-hal seperti itu.
masalah minimisasi. Jadi, kita akan kembali ke fungsi spesifik yang ingin kita minimalkan untuk
jaringan saraf.

Oke, anggaplah kita mencoba meminimalkan suatu fungsi, C(v). Ini bisa menjadi fungsi apa pun dari
nilai nyata dari banyak variabel, di mana v = v1, v2, …. Perhatikan bahwa saya mengganti notasi w dan b dengan v untuk
menekankan bahwa ini bisa jadi fungsi apa saja – kita tidak lagi berpikir secara spesifik dalam konteks
hanya jaringan saraf. Untuk meminimalkan C (v), mari kita bayangkan C sebagai fungsi dari hanya dua
variabel, yang akan kita sebut v1 dan v2, seperti yang dapat dilihat pada gambar di bawah:

Apa yang kami inginkan adalah menemukan di mana C mencapai minimum globalnya. Jelas, bahwa untuk fungsi yang digambar pada
grafik di atas, kita dapat dengan mudah mengamati grafik dan menemukan minima. Tapi fungsi umum, C, dapat
menjadi fungsi yang rumit dengan banyak variabel, dan umumnya tidak mungkin hanya mengamati grafik
untuk menemukan yang minimum.

Salah satu cara untuk menyerang masalah ini adalah dengan menggunakan Kalkulus (secara spesifik Aljabar Linier) untuk mencoba menemukan
minimum secara analitik. Kami dapat menghitungr turunane depois tentar usá-las para encontrar lugares onde C
ini adalah ekstremum. Ini dapat berfungsi ketika C adalah fungsi dari hanya satu atau beberapa variabel. Tapi akan
se menjadi mimpi buruk ketika kita memiliki banyak variabel lainnya. Dan untuk jaringan saraf, banyak
kali kita menginginkan lebih banyak variabel–jaringan saraf terbesar memiliki fungsi biaya yang bergantung pada
miliar peso dan bias dengan cara yang sangat rumit. Menggunakan "hanya" Kalkulus untuk
meminimalkan ini, tidak akan berhasil dan kita membutuhkan sesuatu yang lebih! Kita membutuhkan algoritma optimisasi yang mampu
untuk meminimalkan C (v).

Untungnya, ada sebuah analogi yang membantu kita memahami bagaimana menemukan solusi. Kita mulai dengan
memikirkan tentang fungsi kita sebagai semacam lembah dan membayangkan sebuah bola berguling di lereng lembah,
sebagaimana bisa dilihat pada gambar di bawah. Pengalaman keseharian kita memberi tahu bahwa bola pada akhirnya akan bergulir ke
dasar lembah. Mungkin kita bisa menggunakan ide ini sebagai cara untuk menemukan minimum untuk fungsi?
Kami akan secara acak memilih titik awal untuk sebuah bola (imajiner), dan kemudian kami akan mensimulasikan
gerakan bola saat ia bergulir hingga ke dasar lembah. Kita bisa melakukan simulasi ini dengan sederhana
melalui turunan komputasi fungsi C – turunan ini akan memberi tahu kita segala yang perlu kita ketahui tentang
"forma" lokal dari lembah, dan, oleh karena itu, bagaimana bola kita harus bergulir.

Representasi Penurunan Gradien (dengan tujuan untuk meminimalkan fungsi biaya)

Dengan kata lain, Penurunan Gradien adalah algoritma optimisasi yang digunakan untuk menemukan nilai-nilai dari
parameter (koefisien atau lebih suka sebut w dan b–berat dan bias) dari fungsi yang meminimalkan sebuah fungsi dari
custo. Penurunan Gradien lebih baik digunakan ketika parameter tidak dapat dihitung
analitik (misalnya, menggunakan aljabar linier) dan harus dicari oleh algoritma untuk
optimasi.

Prosedur dimulai dengan nilai awal untuk koefisien atau koefisien fungsi. Ini bisa
ser 0.0 atau nilai acak kecil (inisiatif koefisien adalah bagian penting dari proses dan berbagai
teknik dapat digunakan, dengan pilihan di tanganseorang Ilmuwan Datadan masalah yang harus diselesaikan
dengan model). Kita bisa memulai dengan koefisien kita (nilai w dan b):
 coeficiente = 0,0

Biaya koefisien dievaluasi dengan menghubungkannya dengan fungsi dan menghitung biayanya.

custo = f (koefisien)

kamu

custo = menilai (f (koefisien))

Turunan biaya dihitung. Turunan adalah konsep dalam Kalkulus dan mengacu pada kemiringan fungsi pada
suatu titik tertentu. Kita perlu mengetahui kemiringan agar kita bisa mengetahui arah (tanda) untuk
memindahkan nilai koefisien untuk mendapatkan biaya yang lebih rendah pada iterasi berikutnya.

delta = turunan (biaya)

Sekarang kita tahu tentang turunan di arah mana itu menurun, kita bisa memperbarui nilai-nilai dari
koefisien. Sebuah parameter laju pembelajaran (alpha) harus ditentukan dan mengontrol seberapa banyak
koefisien dapat berubah dalam setiap pembaruan.

koefisien = koefisien - (alfa * delta)

Proses ini diulang hingga biaya koefisien (fungsi biaya) adalah 0,0 atau cukup mendekati.
dari nol, menunjukkan bahwa keluaran jaringan semakin dekat dengan nilai nyata (keluaran yang diinginkan).

Penurunan Gradien itu sederhana, tetapi memerlukan perhitungan gradien dari fungsi biaya atau fungsi
yang Anda optimalkan, tetapi selain itu, sangat langsung. Singkatnya:

Anda membagi data Anda menjadi sampel dan pada setiap sampel, Anda menjalankan input melalui jaringan, mengalikan
pelos bobot, jumlah, dan pada akhirnya Anda akan memiliki keluaran Anda (perkiraan dari jaringan). Anda kemudian membandingkan keluaran dari Anda
berbicara dengan jawaban yang benar, menghitung kesalahan, dan kemudian membelakangi kesalahan ini (backpropagation), menyesuaikan bobot
dari setiap neuron di setiap lapisan. Ketika Anda selesai melakukan pembaruan bobot, sampel baru adalah
introduzida e ela será multiplicada pelos pesos já atualizados. Esse processo de atualizar os pesos é que é
disebut sebagai "pembelajaran".

Jika Anda memperhatikan algoritma-algoritma terbaru, semuanya bekerja dalam konsep yang agak baru
panggilan mini-lot (mini-batch). Untuk mengoptimalkan kinerja, yang dilakukan adalah melewati jaringan beberapa kali
contoh (misalnya 128 contoh), hitung rata-rata kesalahannya dan kemudian lakukan backpropagation dan
pembaruan bobot. Dari sudut pandang pembaruan bobot, 1 sampel = 128 sampel. Ini adalah sebuah
konsep terbaru, yang terutama diperlukan dalam pelatihan model Deep Learning yang besar.

Selanjutnya, kita akan melihat bagaimana kita dapat menggunakan ini dalam algoritma pembelajaran mesin.

Batch Gradient Descent dalam Pembelajaran Mesin

Tujuan dari semua algoritma pembelajaran mesin yang diawasi adalah untuk memperkirakan suatu fungsi dari
destino (f) yang memetakan data masukan (X) ke variabel keluaran (Y). Ini menjelaskan semua masalah
pengklasifikasian dan regresi (pembelajaran terawasi).

Beberapa algoritma pembelajaran mesin memiliki koefisien yang menggambarkan perkiraan dari
algoritma untuk fungsi target (f). Algoritma yang berbeda memiliki representasi yang berbeda dan berbeda
koefisien, tetapi banyak di antaranya membutuhkan proses optimasi untuk menemukan kumpulan dari
koefisien yang menghasilkan estimasi terbaik dari fungsi target. Contoh umum dari algoritma dengan
coeficientes que podem ser otimizados usando descida do gradiente são Regressão linear e Regressão
logistik.

Evaluasi seberapa dekat model pembelajaran mesin memperkirakan fungsi tujuan dapat menjadi
dihitung dengan berbagai cara, sering kali spesifik untuk algoritma pembelajaran mesin. A
fungsi biaya melibatkan evaluasi koefisien dalam model pembelajaran mesin dengan menghitung
sebuah prediksi untuk model untuk setiap instance pelatihan di set data dan membandingkan
ramalan dengan nilai keluaran yang sebenarnya dan menghitung jumlah atau kesalahan rata-rata (seperti Jumlah Residu)
Kuadrat atau SSR dalam kasus regresi linier.

Berdasarkan fungsi biaya, sebuah turunan dapat dihitung untuk setiap koefisien agar dapat
diperbarui menggunakan tepatnya persamaan pembaruan yang dijelaskan di atas.

Biaya dihitung untuk algoritma pembelajaran mesin di seluruh kumpulan data

pelatihan untuk setiap iterasi dari algoritma penurunan gradien. Satu iterasi dari algoritma disebut
dari sebuah batch dan bentuk penurunan gradien ini disebut sebagai penurunan gradien batch
Penurunan Gradien.

Penurunan gradien dalam batch adalah bentuk yang paling umum dari penurunan gradien dalam Pembelajaran Mesin.

Stochastic Gradient Descent dalam Pembelajaran Mesin

Turunan Gradien dapat berjalan lambat pada dataset yang sangat besar. Sebagai sebuah
iterasi dari algoritma penurunan gradien memerlukan prediksi untuk setiap instansi dalam kumpulan data
pelatihan, bisa memakan waktu lama ketika Anda memiliki banyak juta instansi.

Dalam situasi di mana Anda memiliki sejumlah besar data, Anda dapat menggunakan variasi dari penurunan
gradien disebut Penurunan Gradien Stokastik.

Dalam variasi ini, prosedur penurunan gradien yang dijelaskan di atas dilaksanakan, tetapi pembaruan untuk
koefisien dilakukan untuk setiap instansi pelatihan, bukan di akhir batch instansi.

Langkah pertama dari prosedur ini mengharuskan urutan kumpulan data pelatihan adalah
acak. Maksudnya, mengacak urutan pembaruan yang dilakukan untuk koefisien. Seperti yang
koefisien diperbarui setelah setiap instansi pelatihan, pembaruan akan berisik melompat
di mana-mana, dan dengan cara ini biaya yang sesuai akan berfungsi. Dengan mencampur urutan untuk pembaruan dari
koefisien, dia memanfaatkan perjalanan acak ini dan menghindari agar tidak menjadi "teralihkan" atau terjebak.
Prosedur pembaruan untuk koefisien adalah sama seperti sebelumnya, kecuali bahwa biayanya tidak
dijumlahkan dalam semua pola pelatihan, tetapi dihitung untuk satu pola pelatihan.

Pembelajaran bisa jauh lebih cepat dengan penurunan gradien stokastik untuk kumpulan data
pelatihan yang sangat besar dan seringkali Anda hanya membutuhkan sejumlah kecil pass melalui
do kumpulan data untuk mencapai kumpulan koefisien yang cukup baik.

Ufa, kamu masih di sana? Sekarang mengerti mengapa Ilmuwan Data dan Insinyur IA harus sangat
bem remunerados? Eles são os “magos” que estão ajudando a transformar o mundo com Machine Learning.
Dan bab ini hanyalah pengantar singkat! Kita akan kembali ke topik ini lebih lanjut di buku ini, ketika
kita mempelajari algoritma lain. Tetapi jika Anda ingin mempelajari dengan rinci bagaimana semua ini berfungsi dan membuat
model Anda menggunakan bahasa R, Python, Scala, atau Java, untuk aplikasi komersial, periksa:Mesin
PembelajaranPembelajaran Mesin dengan Scala dan SparkPembelajaran MendalamAnalisis Prediktif dengan Pembelajaran Mesin
di Java.

Saya yakin Anda sangat tidak sabar untuk membuat dan melatih jaringan saraf pertama Anda. Jadi, jangan lewatkan
bab selanjutnya!
Bab 13–Membangun Jaringan Syaraf Dengan
Bahasa Python

Oke. Saatnya tiba. Mari kita menulis program dalam bahasa Python yang belajar bagaimana mengenali
digit tulisan tangan, menggunakan Stochastic Gradient Descent dan dataset pelatihan MNIST. Jika Anda telah tiba
sampai sini tanpa membaca bab-bab sebelumnya, jadi berhenti segera, baca 12 bab terakhir dan kemudian kembali
di sini! Jangan terburu-buru! Tidak ada jalan pintas untuk belajar!

******************************** Perhatian ********************************

Bab ini menganggap bahwa Anda sudah memiliki interpreter Python (versi 3.6.x) terpasang di komputer Anda,
apakah itu dengan sistem operasi Windows, MacOS, atau Linux. Kami merekomendasikan Anda untuk menginstalAnakonda
dan yang sudah memiliki pengetahuan tentang bahasa Python. Jika itu bukan kasus Anda, sebelum membaca bab ini dan
Untuk menjalankan contoh-contoh yang diberikan di sini, akses kursus gratis Python Fundamentos Para Análise de Dados.

Kami akan menggunakan Python 3 dan skrip dapat ditemukan di repositori buku diGitHubAyo
começar!

*************************************************************************

Ketika kami menjelaskan dataset MNIST sebelumnya, kami mengatakan bahwa ia dibagi menjadi 60.000 gambar.
dari pelatihan dan 10.000 gambar uji. Ini adalah deskripsi resmi dari MNIST. Tapi mari kita bagi datanya
dengan cara yang sedikit berbeda. Kami akan membiarkan gambar uji tetap seperti adanya, tetapi kami akan membagi kumpulan
pelatihan MNIST dari 60.000 gambar dalam dua bagian: satu set 50.000 gambar, yang akan kami gunakan untuk
melatih jaringan saraf kami dan satu set terpisah untuk validasi dari 10.000 gambar. Kami tidak akan menggunakan
data validasi dalam bab ini, namun kemudian, di sini juga di buku ini, kita akan menggunakan dataset ini ketika
kami sedang mengonfigurasi beberapa hiperparametrik dari jaringan saraf, seperti laju pembelajaran misalnya.
Meskipun data validasi tidak termasuk dalam spesifikasi MNIST asli, banyak orang menggunakan
MNIST dengan cara ini dan penggunaan data validasi adalah umum dalam jaringan saraf. Ketika saya merujuk pada
"data pelatihan MNIST" mulai sekarang, saya akan merujuk pada kumpulan data kami yang berjumlah 50.000
gambar, dan bukan pada kumpulan data 60.000 gambar. Waspadalah!

Selain data MNIST, kita juga memerlukan perpustakaan Python bernama Numpy, untuk aljabar
linier. Jika Anda telah menginstal Anaconda, Anda tidak perlu khawatir, karena Numpy sudah terinstal. Jika tidak
Sebaliknya, akan diperlukan untuk melakukan instalasi paket.

Sebelum memuat dan membagi data, mari kita memahami fitur utama dari kode kita untuk
pembangunan jaringan saraf. Bagian sentral adalah kelas yang disebut Network, yang kami gunakan untuk mewakili
sebuah jaringan saraf. Di bawah ini adalah kelas Jaringan dan konstruktornya:
Dalam kode ini, parameter sizes berisi jumlah neuron di masing-masing lapisan, yaitu sebuah objek
do tipo lista em Python. Então, por exemplo, se queremos criar um objeto da classe Network com 2
neuron di lapisan pertama, 3 neuron di lapisan kedua dan 1 neuron di lapisan akhir, ini dia
kode yang kami gunakan untuk menginstansiasi objek dari kelas Jaringan::

rede1 = Jaringan([2, 3, 1])

Os bias e pesos no objeto rede1 são todos inicializados aleatoriamente, usando a função Numpy
[Link] untuk menghasilkan distribusi gaussian dengan rata-rata 0 dan deviasi standar 1. Inisialisasi ini
acak memberikan algoritma penurunan gradien stokastik kita sebuah tempat untuk memulai. Dalam bab
posteriores, kita akan menemukan cara yang lebih baik untuk menginisialisasi bobot dan bias. Perhatikan bahwa kode dari
inisialisasi jaringan mengasumsikan bahwa lapisan pertama dari neuron adalah lapisan input dan mengabaikan
definisi dari bias apapun untuk neuron-neuron ini, sejak bias hanya digunakan untuk menghitung
keluaran lapisan-lapisan belakang.

Perhatikan juga bahwa bias dan bobot disimpan sebagai daftar matriks Numpy. Jadi, misalnya,
[Link][1] adalah matriks Numpy yang menyimpan bobot yang menghubungkan lapisan kedua dan ketiga dari
neuron. (Ini bukan lapisan pertama dan kedua, karena pengindeksan daftar di Python dimulai dari
0.) Mengingat bahwa [Link][1] sangat rinci, kita hanya akan menunjukkan matriks w ini. Ini adalah sebuah matriks
di mana wjk adalah bobot untuk koneksi antara neuron kth di lapisan kedua dan neuron jth di lapisan ketiga
camada. Pengurutan indeks j dan k ini mungkin terlihat aneh - pastinya akan lebih masuk akal untuk menukar yang
indeks j e k? Keuntungan besar menggunakan pengurutan ini adalah bahwa itu berarti vektor aktivasi dari
lapisan ketiga neuron adalah:

Persamaan 1

Onde, adalah vektor aktivasi dari lapisan kedua neuron. Untuk mendapatkannya, kita mengalikan dengan
matriks bobot, dan kami menambahkan vektor dengan bias (jika Anda telah membaca bab-bab sebelumnya, ini seharusnya tidak menjadi
novidade agora). Em seguida, aplicamos a função σ de forma elementar a cada entrada no vetor wa + b.
(Ini disebut memvectorisasi fungsi σ.)

Dengan semua itu dalam pikiran, mudah untuk menulis kode yang menghitung output dari suatu instance jaringan. Kami mulai
mendefinisikan fungsi sigmoid:
Perhatikan bahwa ketika input z adalah vektor atau matriks Numpy, Numpy secara otomatis menerapkan fungsi
sigmoid elemen-atas, yaitu dalam bentuk vektorisasi.

Selanjutnya, kami menambahkan metode feedforward ke kelas Network, yang, diberikan input a untuk jaringan,
mengembalikan keluaran yang sesuai. Pada dasarnya metode feedforward menerapkan Persamaan 1 yang ditunjukkan di atas, untuk
setiap lapisan:

Aktivitas utama yang kami ingin objek dari kelas Network lakukan adalah belajar. Untuk tujuan ini,
kami akan membuat metode SGD (Stochastic Gradient Descent). Berikut adalah kodenya. Ini sedikit misterius di
beberapa tempat, tetapi kami akan menjelaskan secara rinci di bawah ini:
Otraining_data adalah daftar tupel (x, y) yang mewakili input pelatihan dan
korespondensi keluaran yang diinginkan. Variabel epoch dan ukuran mini_batch adalah apa yang Anda harapkan–
jumlah epoch untuk melatih dan ukuran mini-batch yang akan digunakan selama pengambilan sampel,
sementara itu adalah laju pembelajaran, η. Jika argumen opsional test_data diberikan, program
akan mengevaluasi jaringan setelah setiap periode pelatihan dan mencetak kemajuan sementara. Ini berguna untuk melacak
progresso, tetapi secara substansial memperlambat segalanya.

Kode berfungsi sebagai berikut. Setiap epoch, ia mulai dengan secara acak menyeret data dari
pelatihan dan kemudian membaginya menjadi mini-batch dengan ukuran yang sesuai. Ini adalah cara yang mudah untuk
pengambilan sampel acak dari data pelatihan. Jadi, untuk setiap mini_batch, kami menerapkan satu langkah dari
penurunan gradien. Ini dilakukan oleh kode self.update_mini_batch (mini_batch, eta), yang memperbarui
berat dan bias dari jaringan sesuai dengan satu iterasi penurunan gradien, menggunakan hanya data
pelatihan dalam mini_batch. Berikut adalah kode untuk metode update_mini_batch:
Sebagian besar pekerjaan dilakukan oleh baris delta_nabla_b, delta_nabla_w = [Link] (x, y). Ini memanggil
sebuah algoritma yang disebut algoritma backpropagation, yang merupakan cara cepat untuk menghitung gradien dari fungsi
Oleh karena itu, update_mini_batch berfungsi hanya dengan menghitung gradien ini untuk setiap contoh.
dari pelatihan di mini_batch dan kemudian memperbarui [Link] dan [Link] dengan tepat.

Di bawah ini Anda akan menemukan kode untuk [Link], tetapi kami tidak akan mempelajarinya sekarang. Kami akan mempelajarinya di
detail bagaimana backpropagation bekerja di bab berikutnya, termasuk kode untuk [Link].
sudah, cukup anggap bahwa ia berperilaku seperti yang ditunjukkan, mengembalikan gradien yang sesuai untuk biaya
terkait dengan contoh pelatihan x.
Tidak ada program lengkap yang tersedia diGithubanda akan menemukan komentar yang menjelaskan bagaimana seluruhnya terjadi
proses. Selain [Link], program ini bersifat otomatis menjelaskan—semua pekerjaan berat dilakukan di
[Link] dan self.update_mini_batch, yang sudah kita bahas. Metode [Link] menggunakan beberapa fungsi
ekstra untuk membantu dalam perhitungan gradien, khususnya sigmoid_prime, yang menghitung turunan dari fungsi
σ e self.cost_derivative.

Kelas Network pada dasarnya adalah algoritma jaringan saraf kami. Dari situ kami membuat sebuah instansi (seperti
rede1), kami memberi makan dengan data pelatihan dan melakukan pelatihan. Kami kemudian mengevaluasi
kinerja jaringan dengan data uji dan kami mengulangi seluruh proses hingga mencapai tingkat akurasi
diinginkan dalam proyek kami. Ketika model akhir siap, kami menggunakannya untuk melakukan prediksi untuk
model apa yang dibuat, memperkenalkan padanya set data baru dan mengekstrak prediksi. Perhatikan
bahwa ini adalah algoritma jaringan saraf yang sangat sederhana, tetapi memungkinkan untuk memahami bagaimana cara kerjanya
jaringan saraf dan kemudian, di sini juga dalam buku, jaringan saraf mendalam atau Deep Learning.

Di bab berikutnya kita akan melanjutkan bekerja dengan algoritma ini dan memahami cara kerjanya
Backpropagation. Selanjutnya, kita akan memuat data, melatih dan menguji jaringan saraf kita dan kemudian menggunakannya
untuk mengenali digit tulisan tangan. Sampai jumpa.
Bab 14–Algoritma Backpropagation Bagian 1
–Grafos Komputasional dan Aturan Rantai

Di chapter terakhir, kita melihat bagaimana jaringan saraf dapat belajar bobot dan bias-nya menggunakan algoritma
gradien menurun. Namun, ada kekurangan dalam penjelasan kami: kami tidak membahas cara menghitung
gradien fungsi biaya. Dalam bab ini, kami akan menjelaskan tentang algoritma yang digunakan untuk menghitung ini
gradien, sebuah algoritma yang dikenal sebagai backpropagation. Karena tema ini adalah inti dari pelatihan
jaringan saraf, mari kita bagi menjadi dua bab. Mari kita mulai dengan Algoritma Backpropagation Bagian 1–
Grafos Komputasional dan Aturan Rantai.

Backpropagation adalah algoritma yang tidak dapat disangkal paling penting dalam sejarah jaringan saraf–tanpa
backpropagation, akan hampir mustahil untuk melatih jaringan pembelajaran mendalam seperti yang kita lihat hari ini.
Backpropagation dapat dianggap sebagai batu penjuru dari jaringan saraf modern dan akibatnya dari
Pembelajaran Mendalam.

Algoritma backpropagation pertama kali diperkenalkan pada tahun 1970-an, tetapi pentingnya tidak diperhatikan.
sepenuhnya dihargai hingga seorang yang terkenalartikel
tahun 1986 oleh David Rumelhart, Geoffrey Hinton, dan Ronald
[Link] ini menjelaskan berbagai jaringan saraf di mana backpropagation berfungsi jauh lebih baik.
secara cepat dibandingkan pendekatan pembelajaran sebelumnya, memungkinkan penggunaan jaringan syaraf untuk
menyelesaikan masalah yang sebelumnya tidak dapat dipecahkan.

Backpropagation adalah algoritma kunci yang membuat pelatihan model mendalam sesuatu
komputasi yang dapat ditangani. Untuk jaringan saraf modern, ia dapat membuat pelatihan dengan gradien
descendente até dez milhões de vezes mais rápido, em relação a uma implementação ingênua. Essa é a
perbedaan antara model yang membutuhkan beberapa jam atau hari untuk dilatih dan yang lain yang bisa memakan waktu bertahun-tahun (tanpa
berlebihan).

Selain penggunaannya dalam Deep Learning, backpropagation adalah alat komputasi yang kuat dalam
banyak area lainnya, mulai dari ramalan cuaca hingga analisis stabilitas numerik. Faktanya, algoritma tersebut telah
direinventado setidaknya puluhan kali di berbagai bidang. Nama umum, terlepas dari aplikasi, adalah
diferenciação no modo reverso

Fundamentalmente, backpropagation adalah teknik untuk menghitung turunan dengan cepat (tidak tahu apa itu
derivatif? Konsultasikan tautan untuk video luar biasa dalam bahasa Portugis yang menjelaskan konsep ini secara rinci di
referensi di akhir bab ini). Dan itu adalah trik penting, tidak hanya dalam Deep Learning, tetapi dalam sebuah
varias situasi komputasi numerik. Dan untuk memahami backpropagation dengan cara
efektif, mari kita pertama-tama memahami konsep grafo komputasional dan aturan rantai.

Grafo Komputasional

Grafos komputasi adalah cara yang baik untuk memikirkan ekspresi matematis. Konsep graf telah
diperkenalkanoleh Leonhard Eulerpada tahun 1736 untuk mencoba menyelesaikan masalah daris Pontes de Konigsberg. Grafos
adalah model matematika untuk menyelesaikan masalah praktis sehari-hari, dengan berbagai aplikasi di dunia
nyata seperti: rangkaian listrik, jaringan distribusi, hubungan kekerabatan antar orang, analisis dari
media sosial, logistik, jaringan jalan, jaringan komputer dan masih banyak lagi. Graf adalah sangat sering digunakan
untuk memodelkan masalah dalam komputasi.
Sebuah Graf adalah model matematis yang mewakili hubungan antara objek. Sebuah graf G = (V, E) terdiri dari
sekelompok simpul V (juga disebut sebagai node), yang dihubungkan oleh sekelompok tepi atau sisi E. Untuk
belajar tentang graf lebih detail, klik di sini.

Sebagai contoh, pertimbangkan ekspresi:

e = (a + b)∗ (b + 1)

Ada tiga operasi: dua penjumlahan dan satu perkalian. Untuk mempermudah pemahaman tentang hal ini, mari kita ...
memperkenalkan dua variabel perantara c dan d agar output dari setiap fungsi memiliki satu variabel. Kami sekarang
kita memiliki:

c=a+b
d=b+1
e = c∗d

Untuk membuat graf komputasional, kita melakukan masing-masing operasi ini pada simpul, bersama dengan
variabel masukan. Ketika nilai dari sebuah simpul adalah masukan untuk simpul lain, sebuah panah akan mengarah dari satu ke yang lain dan
kami memiliki graf terarah dalam kasus ini.
Jenis graf ini muncul sepanjang waktu dalam Ilmu Komputer, terutama saat membicarakan tentang
programa fungsional. Mereka sangat terkait dengan konsep graf ketergantungan dan
graf grafis. Mereka juga merupakan abstraksi utama di balik kerangka kerja Deep yang populer
Belajar, o TensorFlow.

Kita dapat mengevaluasi ekspresi dengan mendefinisikan variabel input untuk nilai tertentu dan menghitungnya.
kita melalui graph. Misalnya, mari kita definisikan a = 2 dan b = 1:

Ekspresi, dalam contoh ini, dinilai sebagai 6.

Turunan dalam Graf Komputasional

Jika seseorang ingin memahami turunan dalam graf komputer, kuncinya adalah memahami turunan di
bordas (sisi yang menghubungkan simpul di graf). Ini memengaruhi secara langsung, jadi kita ingin tahu bagaimana ini
afetac. Seamuda um pouco, comocmuda? Chamamos isso de derivada parcial decem relação aa.

Untuk mengevaluasi turunan parsial di grafik ini, kita memerlukan aturan penjumlahan dan aturan produk:
Di bawah, graf memiliki turunan di setiap tepi (sisi) yang dilabeli.

Dan jika kita ingin memahami bagaimana simpul yang tidak terhubung langsung mempengaruhi satu sama lain? Mari kita
pertimbangkan bagaimana dia terkena. Jika mereka bergerak dengan kecepatan 1, ia juga bergerak dengan kecepatan.
dari 1. Sebagai gantinya, mengubah dengan kecepatan 1 membuatnya berubah dengan kecepatan 2. Jadi dan
muda dengan laju 1∗ 2 dalam hubungan aa (analisis diagram di atas untuk melihat ini).

Aturan umumnya adalah menjumlahkan semua jalur yang mungkin dari satu simpul ke simpul lainnya, mengalikan turunan di
setiap sisi jalannya. Misalnya, untuk mendapatkan turunan dalam hubungan ab, kita peroleh:

Ini menjelaskan bagaimana itu mempengaruhi melalui ini juga bagaimana itu terpengaruh.

Aturan umum "jumlah di atas jalur" hanyalah cara berbeda untuk memikirkan tentang aturan dari
rantai multivariabel atau aturan rantai.
Memfaktorkan Jalan

Masalah dengan hanya "menjumlahkan jalur" adalah bahwa sangat mudah untuk mendapatkan ledakan kombinatorial di
jumlah jalur yang mungkin.

Dalam diagram di atas, ada tiga jalan dari X ke Y, dan tiga jalan lagi dari Y ke Z. Jika kita ingin mendapatkan
turunan ∂Z/∂X menjumlahkan semua jalur, kita perlu menghitung 3∗ 3 = 9 jalan:

Contoh di atas hanya memiliki sembilan jalur, tetapi akan mudah jumlah jalur meningkat secara eksponensial.
ukuran graf menjadi lebih rumit. Alih-alih hanya secara naif menjumlahkan jalur, akan
jauh lebih baik untuk memfaktorkan mereka:

Di situlah muncul "diferensiasi mode kemajuan" (differensiasi mode maju atau forward pass) dan a
"diferensiasi mode terbalik" (diferensiasi mode terbalik atau backpropagation). Mereka adalah algoritma
untuk menghitung jumlah dengan efisien dengan memfaktorkan jalur. Alih-alih menjumlahkan semua jalur
secara eksplisit, mereka menghitung jumlah yang sama dengan cara yang lebih efisien, menggabungkan jalur-jalur bersama
sekali lagi di setiap simpul. Sebenarnya, kedua algoritma menyentuh setiap tepi tepat sekali!

Pembedaan cara maju dimulai dari sebuah masukan untuk graf dan bergerak menuju akhir.
setiap simpul, jumlahkan semua jalan yang memberi makan. Masing-masing jalan ini mewakili cara dalam
apa inputnya mempengaruhi simpul ini. Dengan menambahkannya, kita mendapatkan cara total di mana simpul dipengaruhi oleh input,
ini adalah turunan.
Meskipun Anda mungkin tidak memikirkannya dalam istilah graf, diferensiasi dalam cara
kemajuan sangat mirip dengan apa yang Anda pelajari secara implisit jika Anda telah melakukan pengantar kepada
Perhitungan.

Diferensiasi secara invers, di sisi lain, dimulai dari keluaran graf dan bergerak menuju awal
(yaitu, jika meregressi atau backpropagation). Di setiap simpul, ia mencampur semua jalur yang berasal dari itu
tidak.

Diferensiasi cara maju melacak bagaimana sebuah entri memengaruhi semua simpul. Diferensiasi dalam mode
Reverso melacak bagaimana setiap simpul mempengaruhi keluaran. Dengan kata lain, diferensiasi cara kemajuan menerapkan
operator ∂/∂X ke setiap nodus, sementara diferensiasi modus terbalik menerapkan operator ∂Z/∂ ke setiap nodus. Jika
ini tampaknya konsep pemrograman dinamis, karena memang seperti itu! (akses materi tentang
pemrograman dinamis dalam referensi di akhir bab)

Pada titik ini, Anda mungkin bertanya-tanya mengapa seseorang peduli dengan diferensiasi dalam mode terbalik.
Sepertinya cara yang aneh untuk melakukan hal yang sama seperti mode maju. Apakah ada keuntungan?
Mari kita pertimbangkan contoh asli kita lagi:
Kita bisa menggunakan diferensiasi mode kemajuan ke atas. Ini memberi kita turunan dari setiap simpul di
hubungan ab.

Kami menghitung ∂e/∂b, turunan keluaran kami terhadap salah satu input kami. Dan bagaimana jika kita melakukan itu
diferensiasi mode terbalik dari atas ke bawah? Ini memberi kita turunan berhubungan dengan semua simpul:
Ketika saya mengatakan bahwa diferensiasi dalam mode terbalik memberi kita turunan terkait dengan setiap simpul, saya benar-benar
saya ingin mengatakan setiap simpul. Kita memiliki baik ∂e/∂a maupun ∂e/∂b, turunan terkait dengan kedua masukan.
diferensiasi dalam cara kemajuan memberi kita turunan dari output kita terhadap satu input tunggal, tetapi
diferensiasi dalam mode terbalik memberi kita semua mereka.

Untuk graf ini, ini hanya faktor dari dua kecepatan, tetapi bayangkan sebuah fungsi dengan satu juta dari
masuk dan satu keluar. Diferensiasi dalam cara maju akan membutuhkan kita untuk melewati graf satu juta
kali untuk mendapatkan turunan. Diferensiasi dalam mode terbalik bisa melakukan ini dalam sekali jalan! Sebuah
percepatan dari suatu faktor sejuta sangat keren dan menjelaskan mengapa kita bisa melatih model jaringan
neural profunda dalam waktu yang wajar.

Saat melatih jaringan syaraf, kita memikirkan biaya (nilai yang menggambarkan seberapa buruk jaringan syaraf itu)
fungsi dari parameter (angka yang menggambarkan bagaimana jaringan berperilaku). Kami ingin menghitung turunan
dari biaya sehubungan dengan semua parameter, untuk penggunaan dalam penurunan gradien. Namun seringkali, ada
jutaan atau bahkan puluhan juta parameter dalam jaringan saraf. Jadi, diferensiasi dalam cara
reverso, yang disebut backpropagation dalam konteks jaringan saraf, memberi kita kecepatan yang luar biasa!

Apakah ada kasus di mana diferensiasi cara kemajuan lebih masuk akal? Ya, ada! Di mana cara
reverso menyediakan turunan dari satu keluaran terkait dengan semua masukan, mode maju memberikan kita
turunan dari semua keluaran sehubungan dengan satu masukan. Jika ada fungsi dengan banyak keluaran, maka
diferensiasi dalam cara kemajuan bisa menjadi sangat, sangat lebih cepat.

Sekarang sudah masuk akal?

Ketika kita pertama kali belajar apa itu backpropagation, reaksinya adalah: "Oh, ini hanya aturan dari
rantai (aturan rantai)! Mengapa kita menghabiskan begitu banyak waktu untuk menemukannya?
Pada saat backpropagation ditemukan, orang-orang tidak terlalu fokus pada jaringan saraf
Feedforward. Juga tidak jelas bahwa turunan adalah jalan yang tepat untuk melatihnya. Ini adalah
hanya jelas ketika Anda menyadari bahwa Anda dapat menghitung turunan dengan cepat. Ada ketergantungan
sirkuler.

Melatih jaringan saraf dengan turunan? Tentu saja Anda akan terjebak di minimum lokal. Dan tentunya itu akan
saya harus menghitung semua turunan ini. Faktanya adalah bahwa hanya karena kita tahu bahwa pendekatan ini bekerja adalah bahwa
kita tidak langsung mulai mencantumkan alasan mengapa itu mungkin tidak berfungsi. Kita sudah tahu bahwa
berfungsi, tetapi pendekatan baru telah diusulkan dalam kemajuan penelitian di Deep Learning dan
Kecerdasan Buatan.

Conclusão da Parte 1

O backpropagation juga berguna untuk memahami bagaimana turunan mengalir melalui sebuah model. Ini bisa
ser sangat berguna dalam pemikiran tentang mengapa beberapa model sulit untuk dioptimalkan. Contohnya
Klasik dari ini adalah masalah hilangnya gradien dalam jaringan saraf berulang, yang
kita akan membahas lebih lanjut di dalam buku ini.

Akhirnya, ada pelajaran algoritmik yang luas yang dapat diambil dari teknik-teknik ini. Backpropagation dan mode maju
diferensiasi menggunakan sepasang trik yang ampuh (linearisasi dan pemrograman dinamis) untuk menghitung
turunan dengan cara yang lebih efisien daripada yang bisa dibayangkan. Jika Anda benar-benar memahami teknik ini,
Anda dapat menggunakannya untuk menghitung dengan efisien berbagai ekspresi menarik yang melibatkan turunan.

Namun, bab ini bertujuan hanya untuk membantumu memahami algoritma, karena hampir tidak ada
ada dokumentasi tentang ini dalam bahasa Portugis. Masih perlu memahami bagaimana backpropagation diterapkan
dalam pelatihan jaringan neural. Tidak sabar menunggu itu? Maka ikuti bab berikutnya!

Akademi Data Science menawarkan program lengkap, di mana konsep ini dan berbagai konsep lainnya adalah
dipelajari secara mendetail dan dengan berbagai aplikasi praktis serta menggunakan TensorFlow. Pelatihan Kecerdasan
Artificial terdiri dari 9 kursus, semuanya 100% online dan 100% dalam bahasa Portugis, yang menggabungkan teori dan praktik dalam
ukuran yang tepat, dengan aplikasi nyata dari Kecerdasan Buatan. Lihat program lengkap dari
cursos: Formação Inteligência Artificial.
Bab 15–Algoritma Backpropagation Bagian 2
Pelatihan Jaringan Saraf

Backpropagation secara jelas adalah algoritma yang paling penting dalam sejarah jaringan saraf.
backpropagation (efisien), akan mustahil untuk melatih jaringan pembelajaran mendalam dengan cara yang kita lihat
Hari ini. Backpropagation dapat dianggap sebagai batu penjuru dari jaringan syaraf modern dan pembelajaran
profunda. Dalam bab ini, kita akan memahami bagaimana backpropagation digunakan dalam pelatihan jaringan
neural: Algoritma Backpropagation Bagian 2–Pelatihan Jaringan Saraf.

Algoritma backpropagation terdiri dari dua fase:

1. Langkah ke depan (forward pass), di mana masukan kita dilewatkan melalui jaringan dan prediksi
hasil yang diperoleh (tahapan ini juga dikenal sebagai fase propagasi).

2. O langkah mundur (backward pass), di mana kita menghitung gradien fungsi kehilangan di lapisan terakhir (atau
seja, lapisan prediksi) dari jaringan dan kami menggunakan gradien ini untuk menerapkan secara rekursif aturan rantai
(aturan rantai) untuk memperbarui bobot di jaringan kami (tahap yang juga dikenal sebagai fase pembaruan)
pesos atau retro-propagasi).

Mari kita menganalisis setiap fase ini dan memahami bagaimana backpropagation berfungsi dalam pelatihan di
jaringan saraf. Di bab berikutnya, kita akan kembali ke skrip dalam Python untuk memahami bagaimana itu adalah
implementasi algoritma. Mari kita mulai!

Lulus Maju

Tujuan langkah ke depan adalah untuk menyebarkan input kami (data input) melalui jaringan dengan menerapkan
sebuah rangkaian produk dedot (perkalian antara vektor) dan aktivasi sampai kita mencapai lapisan keluaran dari
rede (atau dengan kata lain, prediksi kita). Untuk memvisualisasikan proses ini, mari kita pertimbangkan terlebih dahulu tabel di bawah ini.
Kita dapat melihat bahwa setiap entri X dalam matriks adalah 2-dim (2 dimensi), di mana setiap titik data diwakili
oleh dua angka. Misalnya, titik data pertama diwakili oleh vektor fitur (0, 0),
titik kedua diberikan oleh (0, 1), dll. Selanjutnya, kita memiliki nilai keluaran Y kita sebagai kolom dari
kanan. Nilai keluaran kami adalah label kelas. Diberikan sebuah input dari matriks, tujuan kami adalah
memperkirakan dengan benar nilai keluaran yang diinginkan. Singkatnya, X mewakili masukan dan Y keluaran.
Untuk mencapai presisi klasifikasi yang sempurna dalam masalah ini, kita memerlukan jaringan saraf.
feedforward dengan setidaknya satu lapisan tersembunyi. Kita kemudian bisa mulai dengan arsitektur 2-2-1
sesuai dengan gambar di bawah ini.

Ini adalah awal yang baik, namun, kita sedang melupakan untuk memasukkan bias. Ada dua cara untuk memasukkan
o bias b em nossa rede. Nós podemos:

1. Menggunakan uma variabel terpisah.

2. Menganggap bias sebagai parameter yang dapat dilatih di dalam matriks, dengan memasukkan kolom dari vektor-vektor.
sumber daya.
Menyisipkan kolom 1 di vektor fitur kita dilakukan secara programatik, tetapi untuk memastikan bahwa
didaktik, mari kita perbarui matriks kita untuk melihatnya secara eksplisit, sesuai dengan tabel di bawah. Bagaimana Anda
anda bisa melihat, sebuah kolom telah ditambahkan ke vektor fitur kami. Dalam praktiknya, Anda dapat memasukkan ini
kolom di mana saja yang Anda inginkan, tetapi biasanya kami menempatkannya sebagai entri pertama dalam vektor
sumber daya atau entri terakhir dalam vektor sumber daya.

Bagaimana kami mengubah ukuran vektor fitur input kami (biasanya yang dilakukan
dalam implementasi jaringan itu sendiri, agar tidak perlu mengubah secara eksplisit kita
matriks), ini mengubah arsitektur jaringan kita dari 2-2-1 menjadi arsitektur 3-3-1, sesuai gambar
di bawah. Kami masih merujuk pada arsitektur jaringan ini sebagai 2-2-1, tetapi ketika berbicara tentang implementasi,
sebenarnya, itu 3-3-1 karena penambahan istilah bias yang dimasukkan dalam matriks.
Akhirnya, ingatlah bahwa baik lapisan input kita maupun semua lapisan tersembunyi memerlukan sebuah
termo bias. Namun, lapisan keluaran akhir tidak memerlukan bias. Bias sekarang adalah parameter
dapat dilatih dalam matriks bobot, menjadikan pelatihan lebih efisien dan secara substansial lebih mudah untuk
mengimplementasikan. Untuk melihat forward pass dalam aksi, pertama-tama kita menginisialisasi bobot di jaringan kita, sesuai
figura di bawah. Perhatikan bagaimana setiap panah dalam matriks bobot memiliki nilai yang terkait dengannya - ini adalah nilai dari
berat saat ini untuk sebuah simpul tertentu dan berarti nilai di mana suatu entri tertentu diperbesar atau
diminui. Nilai bobot ini kemudian akan diperbarui selama fase backpropagation (ingat bahwa masih
Kami tidak dalam forward pass). Ada berbagai cara untuk menginisialisasi vektor bobot dan ini dapat memengaruhi
langsung dalam pelatihan jaringan, seperti yang akan kita lihat di bawah ini.

Di sebelah kiri ekstrem gambar di bawah, kami menyajikan vektor sumber daya (0, 1, 1) dan juga nilai keluaran
1 untuk jaringan, karena setelah itu kita perlu menghitung kesalahan prediksi. Di sini kita bisa melihat bahwa 0,1 dan 1 telah
ditugaskan kepada tiga simpul masuk di jaringan. Untuk menyebarkan nilai-nilai melalui jaringan dan mendapatkan klasifikasi
akhirnya, kita perlu mengalikan produk antara input dan nilai bobot, diikuti oleh penerapan sebuah
fungsi aktivasi (dalam hal ini, fungsi sigmoida s). Mari kita hitung input untuk ketiga node di
lapisan tersembunyi:

1. s ((0 x 0.351) + (1 x 1.076) + (1 x 1.116)) = 0.899

2. s ((0x 0.097) + (1 x 0.165)+(1x 0.542)) = 0.593

3. s ((0x 0,457) + (1 x 0,165)+(1x 0,331)) = 0,378

Mengamati nilai-nilai dari node lapisan tersembunyi (lapisan tengah), kita dapat melihat bahwa node-node tersebut telah
atualizados para refletir nossa computação. Agora temos nossas entradas para os nós da camada oculta. Para
menghitung prediksi keluaran, sekali lagi kami menggunakan produk odot diikuti oleh aktivasi sigmoid:

s ((0.899 x 0.383) + (0.593 x -0.327) + (0.378 x -0.329)) = 0.506

Keluaran jaringan adalah, oleh karena itu, 0,506. Kita dapat menerapkan fungsi langkah (step function) untuk menentukan apakah a
keluarnya adalah klasifikasi yang benar atau tidak:
Menerapkan fungsi langkah dengan keluaran = 0.506, kita melihat bahwa jaringan kita memprediksi 1 yang sebenarnya adalah label kelas.
Benar. Namun, jaringan kami tidak terlalu yakin dengan label kelas ini. Nilai yang diprediksi 0.506 sedang
sangat dekat dengan batas tahap. Idealnya, perkiraan ini harus lebih mendekati 0,98 atau 0,99.
yang menunjukkan bahwa jaringan kami benar-benar mempelajari pola dalam kumpulan data. Agar jaringan kami
Sebenarnya "belajar", kita perlu menerapkan backpropagation.

Backpropagation

Untuk setiap masalah pembelajaran terawasi, kami memilih bobot yang memberikan
estimasi optimal dari sebuah fungsi yang memodelkan data pelatihan kami. Dengan kata lain, kami ingin
menemukan sekumpulan bobot W yang meminimalkan keluaran J(W), di mana J(W) adalah fungsi kerugian, atau kesalahan
di jaringan. Dalam bab-bab sebelumnya, kami membahas algoritma penurunan gradien, di mana kami memperbarui
setiap peso untuk beberapa pengurangan skalar negatif dari turunan kesalahan terkait dengan peso ini. Jika kita memilih untuk
untuk menggunakan gradien menurun (atau hampir semua algoritma optimisasi konveks lainnya), kita perlu
menemukan turunan dalam bentuk numerik.

Tujuan dari backpropagation adalah untuk mengoptimalkan bobot agar jaringan saraf dapat belajar memetakan
menyesuaikan masukan untuk keluaran dengan benar.

Untuk algoritma pembelajaran mesin lainnya, seperti regresi logistik atau regresi linier, perhitungan
Das derivadas adalah aplikasi elementer dari diferensiasi. Ini terjadi karena keluaran dari model-model ini adalah
hanya input yang dikalikan dengan beberapa bobot yang dipilih dan, paling banyak, diberi makan oleh satu saja
fungsi aktivasi (fungsi sigmoida dalam regresi logistik). Namun, hal yang sama tidak dapat dikatakan untuk
jaringan saraf. Untuk mendemonstrasikan ini, berikut adalah diagram dari jaringan saraf dua lapis:

Seperti yang Anda lihat, setiap neuron adalah fungsi dari neuron sebelumnya yang terhubung dengannya. Dengan kata lain, jika
Jika seseorang mengubah nilai w1, neuron 'hidden 1' dan 'hidden 2' (dan akhirnya, keluaran) akan berubah.
Karena pengertian ketergantungan fungsional ini, kita dapat merumuskan keluaran secara matematis sebagai sebuah
função composta extensiva:
Anda hanya:

Untuk menerapkan algoritma backpropagation, fungsi aktivasi kita harus dapat didiferensialkan, sehingga
kita bisa menghitung turunan parsial dari kesalahan terhadap bobot tertentu wi,j, loss(E), keluaran node oj dan keluaran
de rede j.

Di sini, keluaran adalah fungsi komposit dari bobot, masukan, dan fungsi (atau fungsi-fungsi) aktivasi. Penting untuk
menyadari bahwa unit / simpul tersembunyi hanyalah kalkulasi sementara yang, pada kenyataannya, dapat
ser dikurangi menjadi perhitungan dari lapisan input. Jika kita kemudian mengambil turunan dari fungsi sehubungan dengan
berat arbitraris (misalnya, w1), kita akan menerapkan secara iteratif aturan rantai (yang saya miliki
pastikan bahwa Anda ingat tentang bab sebelumnya). Hasilnya akan mirip dengan yang berikut:

Sekarang, mari kita tambahkan satu operasi lagi ke akhir jaringan saraf kita. Operasi ini akan menghitung dan mengembalikan
kesalahan–menggunakan fungsi biaya–dari keluaran kami:
Semua yang kami lakukan adalah menambahkan satu lagi ketergantungan fungsional; kesalahan kami sekarang adalah fungsi dari keluaran dan,
Oleh karena itu, sebuah fungsi dari input, berat, dan fungsi aktivasi. Jika kita menghitung turunan dari kesalahan dengan
setiap bobot arbitrer (sekali lagi, kita akan memilih w1), hasilnya adalah:

Setiap turunan ini dapat disederhanakan, setelah kita memilih fungsi aktivasi dan kesalahan,
sehingga semua hasil mewakili nilai numerik. Pada titik ini, semua abstraksi telah dihilangkan dan
turunan dari kesalahan dapat digunakan dalam penurunan gradien (seperti dibahas sebelumnya di sini di buku)
meningkatkan bobot secara iteratif. Kami menghitung derivatif kesalahan w.r.t. untuk semua bobot lainnya di jaringan dan
kami menerapkan gradien turun dengan cara yang sama. Ini adalah backpropagation–hanya perhitungan dari
turunan yang diberikan untuk algoritma optimasi konveks. Kita menyebut ini sebagai
"retropropagasi" karena kita menggunakan kesalahan keluaran untuk memperbarui bobot, dengan mengambil langkah-langkah iteratif
menggunakan aturan rantai sampai kita mencapai nilai berat ideal.

Setelah memahami cara kerja algoritma backpropagation, Anda menyadari kesederhanaannya.

Tentu saja, aritmetika/perhitungan nyata bisa sulit, tetapi proses ini ditangani oleh komputer kami.
Pada kenyataannya, backpropagation hanyalah penerapan dari aturan rantai (chain rule). Seperti jaringan
jaringan saraf adalah struktur model pembelajaran mesin multilapis yang rumit, setiap bobot
"kontribusi" terhadap kesalahan umum dengan cara yang lebih kompleks dan, oleh karena itu, turunan nyata memerlukan banyak
upaya untuk diproduksi. Namun, setelah kita melewati perhitungan, backpropagation dari
jaringan saraf setara dengan penurunan gradien tipikal untuk regresi logistik / linier.

Dengan demikian, sebagai aturan umum untuk pembaruan bobot, kita dapat menggunakan Aturan Delta (Delta Rule):

Novo Peso = Peso Lama–Derivada * Tingkat Pembelajaran

Tingkat pembelajaran (learning rate) diperkenalkan sebagai sebuah konstanta (biasanya sangat kecil),
akhir untuk memaksa bobot diperbarui dengan cara yang halus dan lambat (untuk menghindari langkah besar dan perilaku
kaotik).

Untuk memvalidasi persamaan ini:

Jika Turunan positif, itu berarti bahwa peningkatan berat badan akan meningkatkan kesalahan, jadi berat baru
harus lebih kecil.
Jika Turunan negatif, itu berarti bahwa peningkatan berat akan mengurangi kesalahan, jadi kita perlu
meningkatkan berat.
Jika Turunan adalah 0, itu berarti kita berada di minimum stabil. Jadi, tidak ada pembaruan pada bobot yang
perlu -> kami telah mencapai keadaan yang stabil.

Ada berbagai metode pembaruan berat. Metode ini sering disebut sebagai
otorisasi. Aturan delta adalah yang paling sederhana dan intuitif, namun memiliki beberapa kelemahan. Periksa di
referensi di akhir bab, sebuah artikel yang sangat baik tentang pengoptimal.
Karena kita memperbarui bobot dengan langkah delta kecil satu per satu, akan diperlukan beberapa iterasi
para terjadi pembelajaran. Dalam jaringan saraf, setelah setiap iterasi, kekuatan penurunan gradien memperbarui
berat untuk nilai yang semakin kecil dari fungsi kehilangan global. Pembaruan berat di jaringan saraf adalah
dipandu oleh kekuatan gradien menurun terhadap kesalahan.

Berapa banyak iterasi yang diperlukan untuk konvergen (yaitu, mencapai fungsi kehilangan minimum global)?
Ini akan tergantung pada berbagai faktor:

Tergantung pada seberapa kuat laju pembelajaran yang kita terapkan. Laju pembelajaran yang tinggi berarti
pembelajaran yang lebih cepat, tetapi dengan peluang ketidakstabilan yang lebih besar.
Juga tergantung pada hiperparameter jaringan (berapa banyak lapisan, seberapa kompleks fungsi non-
linier, dll..). Semakin banyak variabel, semakin lama waktu yang dibutuhkan untuk berkonvergensi, tetapi akurasinya cenderung lebih tinggi.
Tergantung pada penggunaan metode optimisasi, karena beberapa aturan pembaruan bobot adalah
terbukti lebih cepat daripada yang lain.
Bergantung pada inisialisasi acak jaringan. Mungkin dengan sedikit keberuntungan Anda memulai jaringan dengan bobot hampir
ideais e esteja a apenas um passo da solução ideal. Mas o contrário também pode ocorrer.
Bergantung pada kualitas kumpulan pelatihan. Jika input dan output tidak memiliki korelasi satu sama lain, maka
jaringan saraf tidak akan melakukan sihir dan tidak bisa belajar korelasi acak.

Dengan kata lain, melatih jaringan saraf bukanlah tugas yang sederhana. Bayangkan sekarang melatih jaringan dalam, dengan berbagai
lapisan perantara dan jutaan atau bahkan miliaran titik data dan Anda memahami seberapa
Ini bisa menjadi melelahkan dan berapa banyak keputusan yang harus diambil oleh Ilmuwan Data atau Insinyur.
IA. Dan belajar untuk bekerja secara profesional, membutuhkan waktu, dedikasi, dan persiapan dan lebih baik lagi jika itu
Anda bisa 100% dalam bahasa Portugis untuk mempercepat pembelajaran Anda. Membangun aplikasi AI adalah keterampilan
dengan permintaan yang semakin meningkat di pasar.

Mempertimbangkan hal itu, Data Science Academy menawarkan program lengkap, di mana ini dan berbagai lainnya
konsep-konsep dipelajari secara rinci dan dengan berbagai aplikasi praktis, menggunakan TensorFlow. Pelatihan
Kecerdasan Buatan terdiri dari 9 kursus, semuanya 100% online dan 100% dalam bahasa Portugis, yang menggabungkan teori dan
praktek yang tepat, dengan aplikasi nyata dari Kecerdasan Buatan. Lihat program lengkap dari
cursos: Pembelajaran Kecerdasan Buatan. Vários perusahaan di seluruh Brasil sudah melatih karyawan mereka
profesional bersama kami! Ayo bergabung dalam revolusi AI.

Sekarang Anda sudah memahami cara kerja backpropagation, kita bisa kembali ke kode Python dan melihat
semua ini berfungsi dalam praktik. Tapi itu adalah topik untuk bab berikutnya!
Bab 16–Algoritma Backpropagation di
Python

Setelah memahami bagaimana cara kerja backpropagation, kita sekarang dapat memahami kode yang digunakan dalam
beberapa bab sebelumnya untuk menerapkan algoritma (yang akan kita reproduksi di sini). File dengan
kode lengkap dapat ditemukan di repositori buku di Github.

Dalam kode kami, kami memiliki metode update_mini_batchebackprop dari kelas Network. Secara khusus,
metodoupdate_mini_batch memperbarui bobot dan bias dari jaringan dengan menghitung gradien untuk mini_batch
contoh terkini (data) pelatihan:

Sebagian besar pekerjaan dilakukan oleh jalur:

delta_nabla_b, delta_nabla_w = [Link] (x, y)

yang menggunakan metode backprop untuk menemukan turunan parsial ∂Cx / ∂blj dan ∂Cx / ∂wljk. Ini memicu
algoritma backpropagation, yang merupakan cara cepat untuk menghitung gradien dari fungsi biaya.
Oleh karena itu, update_mini_batch berfungsi hanya dengan menghitung gradien ini untuk setiap contoh dari
pelatihan pada mini_batch dan kemudian memperbarui [Link] dan [Link] dengan tepat. Ada sebuah
perubahan kecil - kami menggunakan pendekatan yang sedikit berbeda untuk mengindeks lapisan. Perubahan ini
dilakukan untuk memanfaatkan sumber daya Python, yaitu penggunaan indeks daftar negatif untuk menghitung ke belakang
dari akhir daftar, misalnya, lst[-3] adalah entri ketiga terakhir dalam daftar yang disebut lst. O
kode untuk backprop ada di bawah, bersama dengan beberapa fungsi pembantu, yang digunakan untuk menghitung
fungsi σ, turunan σ′ dan turunan fungsi biaya. Dengan tambahan ini, Anda harus dapat
memahami kode secara mandiri:
Amati metode backprop. Kami mulai dengan menginisialisasi matriks bobot (nabla_w) dan bias (nabla_b) dengan
nol. Matriks ini akan diisi dengan nilai selama proses pelatihan. Ini adalah apa yang jaringan
neural buatan secara efektif belajar. Setelah menginisialisasi beberapa objek, kita memiliki loop for untuk setiap
nilai b dan w (yang pada titik ini kamu sudah tahu adalah bias dan bobot, masing-masing). Di dalam loop ini, kami menggunakan
fungsi [Link] dari Numpy untuk perkalian antara matriks dan penambahan bias, kita letakkan hasilnya dalam daftar
z dan kita melakukan panggilan ke fungsi aktivasi Sigmoid. Di akhir loop ini, kita akan memiliki daftar dengan semua
aktivasi dan kami menyelesaikan langkah ke depan.

Di langkah mundur (Backward Pass) kita menghitung turunan dan melakukan perkalian matriks lebih lanjut
sekali (fungsi jaringan saraf buatan didasarkan pada konsep dasar Aljabar
Linear, perkalian matriks). Perhatikan bahwa kami memanggil metode Transpose() untuk menghasilkan transpos dari
matriks dan menyesuaikan dimensi sebelum melakukan perhitungan. Akhirnya, kami mengembalikan bias dan bobot.
Dalam arti apa backpropagation adalah algoritma yang cepat?

Untuk menjawab pertanyaan ini, mari kita pertimbangkan pendekatan lain untuk menghitung gradiennya. Bayangkan bahwa itu adalah
awal penelitian jaringan saraf. Mungkin itu dekade 1950 atau 1960, dan Anda adalah orang pertama di
dunia berpikir untuk menggunakan gradien menurun untuk pembelajaran! Tapi, agar ide tersebut berfungsi, Anda
Anda memerlukan cara untuk menghitung gradien dari fungsi biaya. Anda kembali ke pengetahuan Anda tentang
perhitungan dan memutuskan apakah dapat menggunakan aturan rantai (chain rule) untuk menghitung gradien. Tetapi setelah bermain
Sedikit, aljabar terlihat rumit dan Anda merasa putus asa. Jadi Anda mencoba mencari yang lain.
pendekatan. Anda memutuskan untuk mempertimbangkan biaya sebagai fungsi hanya dari berat C = C(w) (kita akan kembali ke
bias em um momento). Anda menomori bobot w1, w2,… dan ingin menghitung ∂C / ∂wj untuk sebuah bobot
spesifik. Salah satu cara yang jelas untuk melakukannya adalah dengan menggunakan pendekatan

di mana ϵ> 0 adalah angka kecil positif dan ej adalah vektor unit dalam arah j. Dengan kata lain, kita dapat
mengestimasi ∂C / ∂wj dengan menghitung biaya C untuk dua nilai yang sedikit berbeda dari wj dan, kemudian,
mengaplikasikan persamaan. Ide yang sama akan memungkinkan kita untuk menghitung turunan parsial ∂C / ∂b sehubungan dengan
vieses (bias).

Pendekatan ini tampak sangat menjanjikan. Ini secara konseptual sederhana dan sangat mudah diimplementasikan,
menggunakan hanya beberapa baris kode. Tentu saja, tampak jauh lebih menjanjikan daripada ide menggunakan
aturan rantai untuk menghitung gradien!

Sayangnya, meskipun pendekatan ini tampak menjanjikan, ketika Anda menerapkan kode, itu menjadi
sangat lambat. Untuk memahami mengapa, bayangkan kita memiliki satu juta peso di jaringan kita. Jadi,
Untuk setiap bobot yang berbeda wj, kita perlu menghitung C (w + ϵej) untuk menghitung ∂C / ∂wj. Ini berarti bahwa, untuk
Untuk menghitung gradien, kita perlu menghitung fungsi biaya satu juta kali berbeda, yang memerlukan sebuah
juta langkah maju melalui jaringan (misalnya, pelatihan). Kita juga perlu menghitung C(w) di juga
sejumlah satu juta kali dan dalam satu kali perjalanan melalui jaringan.

Apa yang cerdas tentang backpropagation adalah bahwa itu memungkinkan kita untuk menghitung secara bersamaan semua
derivatif parsial ∂C / ∂wj menggunakan hanya satu lewat langsung di jaringan, diikuti oleh satu lewat untuk
Secara umum, biaya komputasi untuk operan ke belakang hampir sama dengan operan ke depan.
Ini harus masuk akal, tetapi memerlukan beberapa analisis untuk membuat pernyataan yang hati-hati. Ini masuk akal.
karena biaya komputasi yang dominan dalam metode propagasi maju dikalikan dengan matriks bobot,
sementara pada langkah mundur dikalikan dengan transpos dari matriks bobot. Jelas bahwa ini
operasi memiliki biaya komputasi yang serupa. Dan dengan demikian, total biaya dari backpropagation
itu hampir sama dengan melakukan hanya dua kali lintasan di jaringan. Bandingkan ini dengan sejuta satu
lakukan langkah maju yang kami butuhkan untuk pendekatan yang saya jelaskan sebelumnya. Dan begitu, meskipun a
retropropagasi tampak secara superfisial lebih kompleks daripada pendekatan sebelumnya, sebenarnya sangat,
jauh lebih cepat.

Akselerasi ini sangat dihargai pada tahun 1986 dan secara besar-besaran memperluas jangkauan masalah yang
jaringan saraf bisa menyelesaikan. Ini, pada gilirannya, menyebabkan gelombang orang-orang yang menggunakan jaringan saraf. Tentu saja,
retropropagasi bukanlah obat mujarab. Bahkan di akhir tahun 1980-an, orang-orang menghadapi batasan,
terutama ketika mereka mencoba menggunakan backpropagation untuk melatih jaringan saraf dalam, yaitu jaringan
dengan banyak lapisan tersembunyi. Lebih lanjut, di buku ini, kita akan melihat bagaimana komputer modern dan beberapa
ide-ide cerdas baru memungkinkan penggunaan backpropagation untuk melatih jaringan saraf yang sangat dalam.
Tugas Anda sekarang adalah mempelajari dan memahami setiap baris kode yang digunakan dalam jaringan sampel kami. Ini
kode ini cukup sederhana dan tujuannya adalah untuk menunjukkan kepada Anda bagaimana segalanya berfungsi secara programatik.
mari kita latih jaringan kita, evaluasi kinerjanya, optimalkan beberapa operasi dan pahami yang lainnya
konsep dasar. Kami masih memiliki banyak yang akan datang! Sampai bab berikutnya!
Bab 17–Fungsi Biaya Entropi Silang

Ketika seorang pemain tenis sedang belajar berlatih olahraga, dia biasanya menghabiskan sebagian besar waktu
tempo mengembangkan gerakan tubuh. Hanya secara bertahap dia mengembangkan ayunan, belajar untuk
menggerakkan bola dengan tepat ke lapangan lawan dan dengan itu membangun tekniknya, yang
meningkat seiring ia berlatih. Dengan cara yang sama, hingga saat ini kita telah fokus pada pemahaman tentang
algoritma backpropagation, dasar untuk mempelajari sebagian besar kegiatan di jaringan
Neural. Mulai sekarang, kita akan mempelajari serangkaian teknik yang dapat digunakan untuk meningkatkan kita
implementasi backpropagation dan, dengan demikian, meningkatkan cara jaringan kita belajar.

Teknik yang akan kami kembangkan mencakup: pemilihan fungsi biaya yang lebih baik, yang dikenal sebagai fungsi
dari biaya entropi silang (atau Fungsi Biaya Entropi Silang); empat metode 'regulasi'
(regularisasi L1 dan L2, dropout dan perluasan artifisial data pelatihan), yang meningkatkan kami
jaringan untuk menggeneralisasi di luar data pelatihan; metode yang lebih baik untuk menginisialisasi bobot di jaringan; dan
seperangkat heuristik untuk membantu memilih hyperparameter yang baik untuk jaringan. Kami juga akan
menganalisis berbagai teknik lain dengan lebih sedikit kedalaman. Diskusi sebagian besar independen
satu sama lain dan, oleh karena itu, Anda bisa melanjutkan jika mau. Kami juga akan menerapkan banyak dari teknik tersebut di
kode kami dan kami akan menggunakannya untuk meningkatkan hasil yang diperoleh dalam masalah klasifikasi digit
manuskrip yang dipelajari di bab-bab sebelumnya.

Secara alami, kami hanya mencakup beberapa dari banyak teknik yang telah dikembangkan untuk digunakan di
jaringan saraf. Filosofinya adalah bahwa akses terbaik ke berbagai teknik yang tersedia adalah studi
memperdalam beberapa yang paling penting. Menguasai teknik-teknik penting ini tidak hanya berguna dengan sendirinya
saja, tetapi juga akan memperdalam pemahaman Anda tentang masalah apa yang dapat muncul ketika Anda menggunakan jaringan
neural. Ini akan membuat Anda siap untuk dengan cepat belajar teknik-teknik lain, jika perlu.

Fungsi Biaya

Kebanyakan dari kita merasa tidak nyaman jika salah. Segera setelah mulai belajar piano, putri saya membuat
penampilan pertamanya di depan penonton. Dia merasa gugup dan mulai memainkan lagu dengan sebuah
itu sangat rendah. Dia kebingungan dan tidak bisa melanjutkan sampai seseorang menunjukkan kesalahan tersebut. Dia sangat
malu. Meskipun tidak menyenangkan, kita juga cepat belajar ketika kita secara tegas
salah. Anda bisa bertaruh bahwa lain kali dia tampil di depan penonton, dia mulai di
oitava yang benar! Sebaliknya, kita belajar lebih lambat ketika kesalahan kita kurang terdefinisi.

Idealnya, kami berharap bahwa jaringan saraf kami belajar dengan cepat dari kesalahan mereka. Tetapi inilah yang
apa yang terjadi dalam praktik? Untuk menjawab pertanyaan itu, mari kita lihat contoh sederhana. O
conto melibatkan sebuah neuron dengan hanya satu input:
Kami akan melatih neuron ini untuk melakukan sesuatu yang sangat mudah: mendapatkan input 1 dan menghasilkan output 0.
Tentu, ini adalah tugas yang begitu sepele sehingga kita bisa dengan mudah menemukan bobot yang sesuai dan bias.
secara manual, tanpa menggunakan algoritma pembelajaran. Namun, ini akan membantu kita memahami dengan lebih baik
proses menggunakan gradien turun untuk mencoba mempelajari bobot dan bias. Jadi, mari kita lihat
dan bagaimana neuron belajar.

Untuk membuat segala sesuatu menjadi definitif, kami memilih bobot awal sebagai 0.6 dan bias awal sebagai 0.9. Ini adalah
pilihan umum yang digunakan sebagai tempat untuk mulai belajar, saya tidak memilihnya untuk menjadi istimewa
Entah bagaimana. Keluaran awal neuron adalah 0,82, jadi sedikit pembelajaran akan diperlukan sebelum
agar neuron kita mendekati keluaran yang diinginkan 0,0.

Pada grafik di bawah ini, kita dapat melihat bagaimana neuron belajar menghasilkan keluaran yang jauh lebih dekat ke 0.0. Selama
pelatihan, model benar-benar menghitung gradien, dan menggunakan gradien untuk memperbarui bobot dan
o bias, dan menampilkan hasilnya. Tingkat pembelajaran adalah η = 0.15, yang ternyata cukup lambat agar
kita dapat mengikuti apa yang sedang terjadi, tetapi cukup cepat agar kita dapat memperoleh sebuah
pembelajaran substansial hanya dalam beberapa detik. Biaya adalah fungsi biaya kuadratik, C, yang disajikan
di bab-bab sebelumnya. Saya akan mengingatkan Anda tentang bentuk tepat dari fungsi biaya segera.

Seperti yang Anda lihat, neuron belajar bobot dan bias yang mengurangi biaya dan memberikan keluaran dari neuron
de cerca de 0.09 (Epoch, atau Epoch dalam bahasa Portugis, adalah jumlah langkah yang dilakukan model kami melalui
data. Setiap langkah, bobot diperbarui, pembelajaran terjadi dan biayanya, atau tingkat kesalahan,
diminui). Ini bukan hasil yang diinginkan, 0.0, tetapi sangat baik.

Namun, anggaplah kita memilih bobot awal dan bias awal sebagai 2.0. Dalam hal ini, a
keluaran awal adalah 0,98, yang sangat buruk. Mari kita lihat bagaimana neuron belajar menghasilkan 0 dalam kasus ini:
Meskipun contoh ini menggunakan laju pembelajaran yang sama (η = 0,15), kita dapat melihat bahwa pembelajaran
mulai jauh lebih lambat. Sebenarnya, dalam 150 epoch pembelajaran pertama, bobot dan bias tidak
mudah banyak. Jadi pembelajaran mulai beraksi dan, seperti dalam contoh pertama kita, keluaran neuron
dekat dengan 0.0.

Perilaku ini aneh jika dibandingkan dengan pembelajaran manusia. Seperti yang saya katakan di awal
di bab ini, kita sering belajar lebih cepat ketika kita sangat salah tentang sesuatu. Tapi
kami baru saja melihat bahwa neuron buatan kami sangat kesulitan untuk belajar ketika sangat salah
–jauh lebih sulit daripada ketika hanya sedikit salah. Selain itu, terdeteksi bahwa itu
perilaku tidak hanya terjadi dalam contoh ini, tetapi dalam jaringan yang lebih umum. Mengapa belajar begitu lambat?
Dan bisakah kita menemukan cara untuk menghindari perlambatan ini?

Untuk memahami asal usul masalah, pertimbangkan bahwa neuron kita belajar dengan mengubah bobot dan bias.
tarif yang ditentukan oleh turunan parsial dari fungsi biaya, ∂C/∂w dan ∂C/∂b. Jadi, mengatakan "belajar itu lambat" adalah
sebenarnya sama dengan mengatakan bahwa turunan parsial ini kecil. Tantangannya adalah memahami mengapa mereka
itu kecil. Untuk memahami ini, mari kita hitung turunan parsial. Ingatlah bahwa kita sedang menggunakan
fungsi biaya kuadrat, yang diberikan oleh:

apa keluaran dari neuron ketika input pelatihan x = 1 digunakan, dan y = 0 adalah keluaran yang diinginkan
koresponden. Untuk menuliskannya lebih eksplisit dalam istilah bobot dan bias, ingat bahwa a = σ(z),
di mana z = wx + b. Menggunakan aturan rantai untuk membejakan sehubungan dengan bobot dan bias, kami mendapatkan:
di mana x = 1 dan y = 0. Untuk memahami perilaku ekspresi ini, mari kita lihat lebih dekat.
termo σ ′ (z) di sisi kanan. Ingat bentuk dari fungsi σ:

Kita dapat melihat di grafik ini bahwa ketika keluaran neuron mendekati 1, kurva menjadi sangat datar, dan kemudian
σ ′ (z) fica muito pequeno. As equações acima então nos dizem que ∂C/∂w e ∂C/∂b ficam muito pequenos.
Ini adalah asal mula perlambatan pembelajaran. Selain itu, seperti yang akan kita lihat lebih jauh, a
desacelerasi pembelajaran terjadi pada dasarnya karena alasan yang sama pada jaringan saraf yang lebih umum, tidak
hanya dalam contoh sederhana ini.

Fungsi Biaya Entropi Silang

Bagaimana kita bisa mengatasi perlambatan pembelajaran? Ternyata kita bisa menyelesaikan masalah ini.
mengganti biaya kuadrat dengan fungsi biaya yang berbeda, dikenal sebagai entropi silang. Untuk
Untuk memahami entropi silang, mari kita menjauh sedikit dari model super-sederhana kita. Mari kita anggap bahwa
kami sedang mencoba melatih sebuah neuron dengan berbagai variabel input, x1, x2,…, bobot yang sesuai
w1, w2,… dan sebuah bias, b:
Keluaran neuron adalah, secara alami, a = σ(z), di mana z = ∑jwjxj + bé adalah jumlah tertimbang dari masukan.
kami mendefinisikan fungsi biaya dari entropi silang untuk neuron ini sebagai berikut:

Itulah jumlah total item data pelatihan, jumlahnya adalah tentang semua masukan pelatihan.
mata keluar yang diinginkan sesuai. Tidak jelas bahwa ekspresi sebelumnya menyelesaikan masalah dari
perlambatan pembelajaran. Sebenarnya, sejujurnya, tidak jelas apakah itu masuk akal untuk menyebut ini sebagai sebuah
fungsi biaya! Sebelum membahas perlambatan pembelajaran, mari kita lihat dalam arti mana entropi
cruzada dapat diartikan sebagai fungsi biaya.

Dua sifat khusus membuat wajar untuk menginterpretasikan entropi silang sebagai fungsi biaya.
Pertama, itu tidak negatif, yaitu, C > 0. Untuk melihat ini, perhatikan pada rumus sebelumnya bahwa: (a) semua
termos individuasi dalam jumlah adalah negatif, karena kedua logaritma adalah dari angka dalam rentang 0 hingga 1;
e (b) ada tanda minus di depan jumlah.

Kedua, jika keluaran nyata neuron mendekati keluaran yang diinginkan untuk semua input pelatihan
x, jadi entropi silang akan mendekati nol. Untuk melihat ini, anggaplah, misalnya, bahwa y = 0 dan a ≈ 0 untuk
sebuah masukan x. Ini adalah kasus ketika neuron melakukan pekerjaan yang baik pada masukan ini. Kita melihat
bahwa istilah pertama (dalam rumus di atas) untuk biaya, menghilang, selama y = 0, sementara yang kedua
termo adalah hanya −ln (1 − a) ≈ 0. Analisis yang sama berlaku ketika y = 1 dan a ≈ 1. Dan demikian, a
kontribusi untuk biaya akan rendah, selama keluaran nyata mendekati keluaran yang diinginkan.

Singkatnya, entropi silang bersifat positif dan cenderung menuju nol, seiring dengan perbaikan neuron.
perhitungan keluaran yang diinginkan, y, untuk semua input pelatihan, x.

Ini adalah dua properti yang kami harapkan secara intuitif untuk sebuah fungsi biaya. Sebenarnya, keduanya
properti juga dipenuhi oleh biaya kuadratik. Oleh karena itu, ini adalah kabar baik untuk entropi
cross-entropy. Tetapi fungsi biaya entropi silang memiliki keuntungan bahwa, tidak seperti biaya kuadratik,
hindari masalah perlambatan pembelajaran. Untuk melihat ini, mari kita hitung turunan parsial dari biaya
dari entropi silang terkait dengan bobot. Kami mengganti a = σ (z) dalam rumus di atas dan menerapkan aturan dari
rantai dua kali, menghasilkan:
Menempatkan semuanya dalam penyebut yang sama dan menyederhanakan, ini menjadi:

Dengan menggunakan definisi fungsi sigmoid, σ (z) = 1 / (1 + ez), dan sedikit aljabar, kita dapat menunjukkan bahwa σ
(z) = σ (z) (1 − σ (z)). Kita melihat bahwa istilah σ′ (z) dan σ (z) (1 − σ (z)) saling membatalkan dalam persamaan di atas, dan
menyederhanakan menjadi:

Ini adalah ungkapan yang indah. Dia memberi tahu kita bahwa tingkat di mana bobot belajar dikendalikan oleh σ (z) −y, yaitu
karena kesalahan dalam keluaran. Semakin besar kesalahan, semakin cepat neuron akan belajar. Ini adalah tepat apa yang kami
kami berharap secara intuitif. Secara khusus, menghindari lambatnya pembelajaran yang disebabkan oleh istilah σ′ (z) di
persamaan analog untuk biaya kuadratik. Ketika kita menggunakan entropi silang, istilah σ′ (z) dibatalkan dan
kita tidak perlu lagi khawatir menjadi kecil. Pembatalan ini adalah keajaiban khusus yang dijamin oleh
fungsi biaya entropi silang. Sebenarnya, itu tidak benar-benar sebuah keajaiban. Seperti yang akan kita lihat kemudian,
entropi silang dipilih khusus karena hanya memiliki sifat ini.

Dengan cara yang sama, kita bisa menghitung turunan parsial untuk bias. Saya tidak akan menjelaskan semua
rincian lagi, tetapi Anda dapat dengan mudah memeriksa bahwa:
Sekali lagi, ini menghindari lambatnya pembelajaran yang disebabkan oleh istilah σ′ (z) dalam persamaan yang setara untuk biaya.
kuadratik.

Sekarang kita akan kembali ke contoh di awal bab ini, dan mengeksplorasi apa yang terjadi ketika kita menggunakan
entropi silang daripada biaya kuadrat. Untuk menyelaraskan diri, kita akan mulai dengan kasus di mana
custo kuadratik itu baik, dengan bobot awal 0.6 dan bias awal 0.9. Lihat apa yang terjadi ketika
kami mengganti biaya kuadratik dengan entropi silang:

Seperti yang diharapkan, neuron belajar dengan sangat baik dalam kasus ini, sama seperti yang dilakukan sebelumnya. Dan
sekarang mari kita lihat kasus di mana neuron kita terjebak sebelumnya, dengan berat dan bias keduanya
memulai di 2.0:

Sukses! Kali ini, neuron belajar dengan cepat, persis seperti yang kami harapkan. Jika Anda memperhatikan
Dengan hormat, anda dapat melihat bahwa kemiringan kurva biaya jauh lebih curam pada awalnya dibandingkan dengan yang lain.
wilayah datar awal pada kurva yang sesuai untuk biaya kuadrat. Ini adalah kemiringan yang entropi
Kruza membantu kita untuk menyelesaikan, mencegah kita terjebak tepat ketika kita berharap bahwa kita
neurón aprender lebih cepat, yaitu, ketika neuron mulai salah.

Saya tidak mengatakan tingkat pembelajaran apa yang digunakan dalam contoh yang baru saja saya ilustrasikan. Sebelumnya, dengan
biaya kuadratik, kita menggunakan η = 0,15. Seharusnya kita menggunakan tingkat pembelajaran yang sama pada yang baru
contoh? Sebenarnya, dengan perubahan dalam fungsi biaya, tidak mungkin untuk mengatakan secara tepat apa artinya
menggunakan tarif pembelajaran yang "sama"; ini adalah perbandingan antara apel dan jeruk. Untuk kedua fungsi dari
biaya, saya hanya mencoba untuk menemukan tingkat pembelajaran yang memungkinkan untuk melihat apa yang ada
sedang berlangsung. Jika Anda masih penasaran, berikut adalah ringkasan: saya menggunakan η = 0,005 pada contoh yang baru saja saya
menyediakan.

Anda dapat mempertanyakan bahwa perubahan dalam tingkat pembelajaran membuat grafik di atas menjadi tidak masuk akal. Siapa yang
mengimpor dengan kecepatan neuron belajar, ketika pilihan laju pembelajaran kami telah
sewenang-wenang, untuk memulai ?! Tapi keberatan ini tidak berlaku. Poin dari grafik bukan tentang kecepatan
absoluta dari pembelajaran. Ini tentang bagaimana kecepatan pembelajaran berubah. Secara khusus, ketika kita menggunakan
o custo quadrático, a aprendizagem é mais lenta quando o neurônio está inequivocamente errado do que é
lebih kemudian selama pelatihan, saat neuron mendekati output yang benar; sementara
Pembelajaran entropi silang lebih cepat ketika neuron jelas salah. Ini
deklarasi tidak bergantung pada bagaimana tingkat pembelajaran ditentukan.

Kami sedang mempelajari entropi silang untuk satu neuron. Namun, mudah untuk menggeneralisasi entropi.
crusada untuk jaringan multilapis dengan banyak neuron. Khususnya, anggap bahwa y = y1, y2,… adalah
nilai yang diinginkan di neuron keluaran, yaitu neuron di lapisan akhir, sementara aL1, aL2,… adalah
nilai output yang sebenarnya. Jadi, kami mendefinisikan entropi silang sebagai:

Ini adalah sama dengan ekspresi kita sebelumnya, kecuali sekarang kita memiliki ∑j yang menjumlahkan semua neuron.
de saída. Não vou explicitamente trabalhar com uma derivação, mas deve ser plausível que o uso da
ekspresi sebelumnya mencegah perlambatan dalam pembelajaran di banyak jaringan saraf.

Ngomong-ngomong, saya menggunakan istilah "entropi silang" dengan cara yang membingungkan beberapa orang pada awalnya.
pembaca, karena tampaknya secara superficialis bertentangan dengan sumber lain. Secara khusus, adalah umum untuk mendefinisikan
entropi silang untuk dua distribusi probabilitas, pj dan qj, seperti ∑jpjlnqj. Definisi ini bisa jadi
terhubung dengan rumus entropi untuk sebuah neuron yang ditunjukkan sebelumnya, jika kita memperlakukan satu neuron tunggal
sigmoid sebagai output dari distribusi probabilitas yang terdiri dari aktivasi a dari neuron ae
complemento 1 − a.

Namun, ketika kita memiliki banyak neuron sigmoid di lapisan akhir, vektor aLj dari aktivasi tidak
costuma membentuk distribusi probabilitas. Sebagai hasilnya, definisi seperti ∑jpjlnqj tidak membuat
arti, karena kita tidak sedang bekerja dengan distribusi probabilitas. Sebagai gantinya, Anda bisa berpikir
dalam rumus entropi untuk beberapa neuron sebagai kumpulan dijumlahkan dari entropi silang
neuron, dengan aktivasi setiap neuron diinterpretasikan sebagai bagian dari sebuah distribusi
probabilitas dua elemen. Ya, saya tahu bahwa ini tidaklah sederhana.

Dalam pengertian ini, rumus entropi untuk beberapa neuron adalah generalisasi dari entropi silang untuk
distribusi probabilitas.
Kapan kita harus menggunakan entropi silang daripada biaya kuadrat? Faktanya, entropi silang hampir
selalu pilihan terbaik, selama neuron keluaran adalah neuron sigmoida. Untuk memahami mengapa
ketika, pertimbangkan bahwa, ketika kami mengonfigurasi jaringan, biasanya kami menginisialisasi bobot dan bias
menggunakan semacam kebetulan. Mungkin saja pilihan awal ini menyebabkan jaringan menjadi
secara tegas salah untuk beberapa input pelatihan - yaitu, sebuah neuron keluaran akan jenuh
dekat 1, ketika seharusnya 0, atau sebaliknya. Jika kita menggunakan biaya kuadrat yang akan memperlambat
pembelajaran, dia tidak akan berhenti belajar sepenuhnya, karena bobot akan terus belajar dengan
mas tentunya tidak diinginkan.

Membangun aplikasi AI adalah keterampilan yang semakin dicari di pasar.

Mempertimbangkan hal itu, Data Science Academy menawarkan program lengkap, di mana ini dan berbagai lainnya
konsep-konsep dipelajari secara rinci dan dengan berbagai aplikasi praktis, menggunakan TensorFlow. Pelatihan
Kecerdasan Buatanterdiri dari 9 kursus, semuanya 100% online dan 100% dalam bahasa Portugis, yang menggabungkan teori dan
praktik sesuai porsi, dengan aplikasi nyata dari Kecerdasan Buatan. Cek program lengkap dari
cursos: Pendidikan Kecerdasan Buatan. Banyak perusahaan di seluruh Brasil sudah melatih karyawan mereka
profesional bersama kami! Ayo bergabung dalam revolusi AI.

Sampai bab berikutnya!

Bab 18–Entropi Silang Untuk Mengkuantifikasi
Perbedaan Antara Dua Distribusi
Probabilitas

Cross-Entropy (atau entropi silang, jika Anda lebih suka istilah dalam bahasa Indonesia) mudah diimplementasikan sebagai
bagian dari program yang belajar menggunakan gradien menurun dan backpropagation. Kami akan melakukan ini di
bab selanjutnya ketika kita melatih jaringan lengkap, mengembangkan versi yang lebih baik dari kami
program sebelumnya untuk mengklasifikasikan digit tulisan tangan dari dataset MNIST. Program baru ini disebut
[Link] dan menggabungkan tidak hanya entropi silang, tetapi juga berbagai teknik lain yang akan kita pelajari
tetapi lebih lanjut. Sekarang, mari kita lihat bagaimana menggunakan Entropi Silang untuk Mengkuantifikasi Perbedaan Antara Dua
Distribusi Probabilitas.

Sementara itu, mari kita lihat bagaimana program baru kita mengklasifikasikan digit MNIST. Kita akan menggunakan jaringan dengan
30 neuron tersembunyi, dan kita akan menggunakan ukuran mini-batch sebesar 10. Kami menetapkan laju pembelajaran menjadi η =
0,5 dan kami melatih selama 30 epoch. Antarmuka untuk [Link] akan sedikit berbeda dari [Link],
tetapi masih harus jelas apa yang sedang terjadi. Di bab-bab berikutnya, kami menyajikan kode lengkap
di repositori buku di Github.

Perhatikan bahwa perintah net.large_weight_initializer() digunakan untuk menginisialisasi bobot dan bias yang sama
cara yang telah kami jelaskan sebelumnya. Kami perlu menjalankan perintah ini karena di kemudian hari kami akan
mengubah berat standar untuk inisialisasi di jaringan kami. Hasil dari pelaksanaan rangkaian perintah
di atas adalah jaringan dengan akurasi 95,49%.

Mari kita lihat juga kasus di mana kita menggunakan 100 neuron tersembunyi, entropi silang, dan kita mempertahankan
parameter yang sama. Dalam hal ini, kita mendapatkan akurasi sebesar 96,82%. Ini adalah peningkatan
substansial sehubungan dengan hasil yang kami peroleh dicapítulos anteriores, onde a precisão de
klasifikasi adalah 96,59%, menggunakan biaya kuadrat. Ini mungkin tampak sebagai perubahan kecil, tetapi
pertimbangkan bahwa tingkat kesalahan turun dari 3,41% menjadi 3,18%. Artinya, kami menghilangkan sekitar satu dari empat belas dari
kesalahan asli. Ini adalah peningkatan yang cukup berguna.

Kita didorong bahwa biaya entropi silang memberi kita hasil yang serupa atau lebih baik daripada biaya
kuadratik. Namun, hasil ini tidak membuktikan secara meyakinkan bahwa entropi silang adalah pilihan
lebih baik. Alasananya adalah bahwa kami hanya melakukan sedikit usaha dalam memilih hyperparameter seperti laju
dari pembelajaran, ukuran mini-lot dan sebagainya. Agar perbaikan benar-benar meyakinkan,
kita perlu melakukan pekerjaan lengkap untuk mengoptimalkan hyperparameter ini. Meskipun demikian, hasilnya
mereka memperkuat dan memperkuat argumen teoretis kami sebelumnya bahwa entropi silang adalah sebuah pilihan
lebih baik daripada biaya kuadratik.
Ini, omong-omong, adalah bagian dari pola umum yang akan kita lihat di bab-bab berikutnya dan, sebenarnya, dalam skala besar
bagian dari sisa buku. Mari kita kembangkan teknik baru, kita akan mencobanya dan kita akan mendapatkan
hasil "ditingkatkan". Jelas bahwa baik untuk melihat perbaikan ini, tetapi interpretasi perbaikan tersebut
selalu menjadi masalah. Mereka hanya benar-benar meyakinkan jika kita melihat perbaikan setelah kita
berusaha untuk mengoptimalkan semua hyperparameter lainnya. Ini adalah sejumlah besar pekerjaan,
memerlukan banyak daya komputasi, dan biasanya kita tidak akan melakukan penyelidikan yang begitu mendalam. Di
Selain itu, kami akan bertindak berdasarkan pengujian informal seperti yang telah dilakukan sejauh ini.

Hingga saat ini, kita telah membahas entropi silang dengan sangat rinci. Mengapa begitu banyak usaha ketika entropi
cruzada hanya memberikan sedikit peningkatan pada hasil kami dengan dataset MNIST? Lebih lanjut
kita akan melihat teknik-teknik lain, terutama regularisasi, yang memberikan perbaikan yang jauh lebih besar. Jadi, mengapa
Mengapa begitu fokus pada entropi silang? Salah satu alasan adalah bahwa entropi silang adalah fungsi biaya yang secara luas
digunakan dan, oleh karena itu, layak untuk memahaminya dengan baik. Namun alasan yang paling penting adalah bahwa saturasi dari
Neurôn adalah masalah penting dalam jaringan saraf, masalah yang akan kita bahas secara berulang.
panjang buku. Oleh karena itu kita membahas entropi silang secara mendalam karena ini adalah laboratorium yang baik untuk memulai
untuk memahami saturasi neuron dan bagaimana hal itu dapat didekati.

Apa yang dimaksud dengan entropi silang? Dari mana ini berasal?

Diskusi kami tentang entropi silang terfokus pada analisis aljabar dan implementasi praktis.
Ini berguna, tetapi meninggalkan pertanyaan konseptual yang lebih luas yang tidak terjawab, seperti: apa arti entropi
entropi silang? Apakah ada cara intuitif untuk memikirkan tentang entropi silang? Dan bagaimana dengan maknanya
apa itu entropi silang yang intuitif? Bagaimana seharusnya kita memikirkannya?

Menjelaskan ini secara mendalam akan membawa kita lebih jauh dari yang kita inginkan dalam buku ini. Namun, itu layak
menekankan bahwa ada cara standar untuk menginterpretasikan entropi silang yang berasal dari bidang teori
informasi. Mari kita lihat.

Kami sudah tahu bahwa untuk melatih jaringan saraf, Anda perlu menemukan kesalahan antara output yang dihitung dan
keluaran target yang diinginkan. Ukuran kesalahan yang paling umum disebut sebagai kesalahan kuadrat rata-rata (atau Mean Square
Namun, ada beberapa hasil penelitian yang menyarankan penggunaan ukuran yang berbeda,
disebut sebagai kesalahan entropi silang, sebagai metode yang lebih disukai dibandingkan dengan kesalahan kuadrat rata-rata.

Ukuran entropi silang telah digunakan sebagai alternatif untuk kesalahan kuadrat rata-rata. Entropi
cruzada dapat digunakan sebagai ukuran kesalahan ketika keluaran dari sebuah jaringan dapat dianggap sebagai
mewakili hipotesis independen (misalnya, setiap simpul berarti konsep yang berbeda) dan aktivasi
dua node dapat dipahami sebagai mewakili probabilitas (atau kepercayaan) bahwa masing-masing dari
hipotesis bisa benar. Dalam hal ini, vektor keluaran mewakili distribusi probabilitas, dan
ukuran kesalahan kami—entropi silang—menunjukkan jarak antara apa yang diyakini jaringan tentang distribusi ini
harus seperti yang seharusnya. Ada juga alasan praktis untuk menggunakan entropi silang. Bisa
lebih berguna dalam masalah di mana targetnya adalah 0 dan 1. Entropi silang cenderung memungkinkan kesalahan
mengubah bobot bahkan ketika ada node yang ter saturasi (yang berarti bahwa turunan mereka hampir 0).
Mari kita memahami ini dengan lebih baik:

Entropi silang biasanya digunakan untuk mengukur perbedaan antara dua distribusi
probabilitas. Umumnya, distribusi "sebenarnya" (dari data yang digunakan untuk pelatihan) dinyatakan dalam
istilah distribusi One-Hot.

Contohnya, anggaplah bahwa untuk suatu instansi pelatihan tertentu (satu baris tunggal dalam dataset Anda),
classe seja B (de 3 possíveis possibilidades: A, B e C). A distribuição única para esta instância de
pelatihan adalah, oleh karena itu:
 Pr(Class A) Pr(Class B) Pr(Class C)

0.0 1.0 0.0

Anda dapat menginterpretasikan distribusi di atas sebagai berikut: instansi pelatihan memiliki 0% dari
probabilidade de ser classe A, 100% de probabilidade de ser classe B e 0% de probabilidade de ser a classe
C.

Sekarang, anggaplah bahwa algoritme pembelajaran mesin Anda telah memperkirakan distribusi berikut
probabilidade:

Pr(Class A) Pr(Class B) Pr(Class C)

0,228 0,619 0.153

Seberapa dekat distribusi yang diperkirakan dengan distribusi sebenarnya? Inilah yang menentukan kesalahan
entropi silang. Entropi silang diwakili oleh rumus ini:

Jumlahnya adalah tentang tiga kelas A, B, dan C. Jika Anda menyelesaikan perhitungan, Anda akan menemukan bahwa kerugiannya adalah 0,479.
Jadi, begitulah 'jauh' prediksi Anda dari distribusi yang sebenarnya.

Entropi silang adalah salah satu dari banyak fungsi kerugian yang mungkin. Fungsi-fungsi kerugian ini biasanya
ditulis sebagai J(theta) dan dapat digunakan dalam pen turunan gradien, yang merupakan struktur iteratif untuk
memindahkan parameter (atau koefisien) ke nilai optimal. Entropi silang menggambarkan kerugian antara
dua distribusi probabilitas.

Saat menggunakan jaringan saraf untuk melakukan klasifikasi dan prediksi, biasanya lebih baik menggunakan error entropi.
krusada bahwa kesalahan klasifikasi sedikit lebih baik menggunakan kesalahan entropi silang daripada kesalahan
kuadrat rata-rata untuk mengevaluasi kualitas jaringan saraf. Penting untuk menjelaskan bahwa kita sedang menangani
hanya dengan jaringan saraf yang digunakan untuk mengklasifikasikan data, seperti prediksi pemberian kredit
(ya atau tidak), atau bahkan klasifikasi lain seperti usia, jenis kelamin atau digit dalam dataset MNIST dan sebagainya
diante. Kami tidak sedang berurusan dengan jaringan saraf yang melakukan regresi, di mana nilai yang akan diprediksi adalah numerik.

Sampai bab berikutnya!

Bab 19–Overfitting dan Regularisasi–Bagian
1

Fisikawan Enrico Fermi, pemenang Hadiah Nobel Fisika pada tahun 1938, ditanya tentang pendapatnya mengenai
berkaitan dengan model matematis yang beberapa rekan usulkan sebagai solusi untuk sebuah hal penting
mas Fermi sedang
sceptical. Dia bertanya berapa banyak parameter bebas yang dapat ditentukan dalam model. "Empat" adalah jawabannya.
Fermi menjawab: "Saya ingat teman saya Johnny Von Neumann biasa berkata: dengan empat
parameter yang saya bisa pasang seekor gajah, dan dengan lima saya bisa membuatnya menggerakkan belalainya" *Dengan itu, dia
artinya kita tidak boleh terkesan ketika model yang kompleks cocok dengan satu set
dari data. Dengan parameter yang cukup, Anda dapat menyesuaikan sembarang kumpulan data.

(* Kutipan ini berasal dari artikel Freeman Dyson, yang merupakan salah satu orang yang mengusulkan model tersebut. Artikel ini
"Seekor gajah dengan empat parameter" atau "A four-parameter elephant" dapat ditemukan di sini.

Intinya, jelas, adalah bahwa model dengan sejumlah besar parameter dapat menggambarkan berbagai variasi
sangat luas dari fenomena. Meskipun model tersebut sesuai dengan data yang tersedia, itu
tidak menjadikannya model yang baik. Ini mungkin hanya berarti bahwa ada kebebasan yang cukup dalam model yang dapat
menggambarkan hampir setiap kumpulan data dengan ukuran tertentu, tanpa menangkap persepsi apapun
genuin dari fenomena yang dimaksud. Ketika ini terjadi, model akan berfungsi dengan baik untuk data yang ada,
tetapi tidak akan dapat menggeneralisasi untuk situasi baru. Uji sebenarnya dari sebuah model adalah kemampuannya untuk
membuat prediksi dalam situasi yang belum pernah terpapar sebelumnya.

Fermi dan von Neumann mencurigai model dengan empat parameter. Jaringan kami terdiri dari 30 neuron tersembunyi.
Untuk klasifikasi digit MNIST memiliki hampir 24.000 parameter! Jaringan kami dengan 100 neuron tersembunyi
memiliki sekitar 80.000 parameter dan jaringan saraf dalam generasi terbaru kadang-kadang mengandung jutaan atau bahkan
miliar parameter. Haruskah kita mempercayai hasilnya?

Mari kita mempertegas masalah ini dengan membangun sebuah situasi di mana jaringan kita melakukan pekerjaan dengan buruk pada
mengeneralisasi untuk situasi baru. Kami akan menggunakanjaringan kami yang terdiri dari 30 neuron tersembunyi,dengan
23.860
parameter. Tetapi kami tidak melatih jaringan menggunakan semua gambar pelatihan dari 50.000 digit MNIST.
Sebagai gantinya, kami hanya akan menggunakan 1.000 gambar pelatihan pertama. Menggunakan kumpulan terbatas ini
akan membuat masalah dengan generalisasi menjadi jauh lebih jelas. Mari kita latih menggunakan fungsi biaya dari
entropi silang, dengan laju pembelajaran η = 0,5 dan ukuran mini-batch 10. Namun,
Mari kita berlatih selama 400 epoch, karena kita tidak menggunakan banyak contoh pelatihan. Kita akan menggunakan
network2 untuk melihat bagaimana fungsi biaya berubah (kode dapat Anda temukan di repositori kursus di
Github):
Dengan menggunakan hasilnya, kita dapat menggambarkan bagaimana biaya berubah seiring jaringan belajar (skrip
[Link] berisi kode yang menghasilkan hasil ini):

Ini terlihat menggembirakan, menunjukkan pengurangan yang halus dalam biaya, persis seperti yang kita harapkan. Perhatikan bahwa saya
saya hanya menunjukkan periode pelatihan dari 200 hingga 399. Ini memberi kita gambaran yang baik tentang tahap akhir dari
pembelajaran, yang, seperti yang akan kita lihat, adalah di mana tindakan yang menarik terjadi.

Sekarang mari kita lihat bagaimana akurasi klasifikasi pada data uji berubah seiring waktu:
Sekali lagi, saya memperluas sedikit. Di 200 epoch pertama (tidak ditampilkan), akurasi naik sedikit
kurang dari 82%. Pembelajaran kemudian menurun secara bertahap. Akhirnya, sekitar tahun 280, akurasi
Klasifikasi hampir tidak lagi meningkat. Musim-musim selanjutnya hanya melihat fluktuasi kecil.
estocásticas dekat nilai presisi pada waktu 280. Bandingkan ini dengan grafik sebelumnya, di mana biayanya
terkait dengan data pelatihan terus menurun dengan lembut. Jika kita hanya melihat biaya ini, tampaknya
bahwa model kami masih semakin "baik". Tetapi hasil akurasi tes menunjukkan bahwa
perbaikan adalah ilusi. Sama seperti model yang tidak disukai Fermi, apa yang dipelajari jaringan kita setelah
era 280 tidak lagi digeneralisasi untuk data pengujian. Dan dengan demikian bukanlah pembelajaran yang berguna. Kita mengatakan bahwa
jaringan ini sangat beradaptasi atau mengalami over-adjustment atau bahkan overfitting, mulai dari periode 280.

Você pode se perguntar se o problema aqui é que eu estou olhando para o custo dos dados de treinamento,
ao contrário da precisão da classificação nos dados de teste. Em outras palavras, talvez o problema seja que
kami sedang melakukan perbandingan apel dan jeruk. Apa yang akan terjadi jika kita membandingkan biaya dari
Data pelatihan dengan biaya data pengujian, apakah kita akan membandingkan ukuran yang sama? Atau
mungkin kita bisa membandingkan akurasi klasifikasi baik di data pelatihan maupun di data
tes? Sebenarnya, fenomena yang sama pada dasarnya muncul, tidak peduli bagaimana kita melakukan perbandingan.
Detailnya berubah, bagaimanapun. Misalnya, mari kita analisis biaya pada data pengujian:
Kita bisa melihat bahwa biaya pada data uji membaik hingga epoch 15, tetapi setelah itu sebenarnya mulai
semakin memburuk, meskipun biaya dalam data pelatihan terus membaik. Ini adalah tanda lain bahwa kita
model sedang sangat beradaptasi (overfitting). Namun, ada sebuah teka-teki, yaitu apakah kita harus mempertimbangkan
epoch 15 atau epoch 280 sebagai titik di mana overfitting mendominasi pembelajaran? Dari titik
dari sudut pandang praktis, yang benar-benar penting bagi kami adalah meningkatkan akurasi klasifikasi pada data pengujian,
sementara biaya data uji tidak lebih dari sekadar proksi untuk akurasi klasifikasi. Dan dengan demikian
lebih masuk akal untuk mempertimbangkan era 280 sebagai titik di mana overfitting mendominasi.
pembelajaran dalam jaringan syaraf kami.

Sinyal lain dari overfitting dapat dilihat pada akurasi klasifikasi di data pelatihan:
Presisi meningkat hingga 100%. Artinya, jaringan kami mengklasifikasikan dengan benar semua 1.000 gambar dari
pelatihan! Sementara itu, akurasi pengujian kami hanya mencapai 82,27%. Jadi, jaringan kami benar-benar
sedang mempelajari tentang keunikan dari set pelatihan, tidak hanya mengenali angka dalam
Secara umum. Ini hampir seperti jaringan kami hanya menghafal himpunan pelatihan, tanpa memahami.
digit yang cukup baik untuk menggeneralisasi kumpulan tes.

Overfitting adalah masalah besar dalam jaringan saraf. Ini terutama benar dalam jaringan modern,
yang biasanya memiliki sejumlah besar bobot dan bias. Untuk melatih secara efektif, kita perlu sebuah
cara untuk mendeteksi kapan overfitting sedang terjadi. Dan kita perlu menerapkan teknik untuk mengurangi
efek dari overfitting (karena semua pekerjaan dan pengetahuan yang diperlukan, Ilmuwan Dataharus
muito bem remunerados).

Cara yang jelas untuk mendeteksi overfitting adalah dengan menggunakan pendekatan di atas, sambil memantau akurasi di
data uji sesuai dengan pelatihan jaringan kami. Jika kami menyadari bahwa akurasi pada data uji tidak
tapi semakin baik, kita harus berhenti berlatih. Tentu saja, secara ketat berbicara, ini tidak harus...
sebuah tanda overfitting. Mungkin saja akurasi pada data pengujian dan data pelatihan berhenti dari
Memperbaiki pada saat yang sama. Meskipun demikian, adopsi strategi ini akan mencegah overfitting.

Sebenarnya, kita akan menggunakan variasi dari strategi ini. Ingatlah bahwa, ketika kita memuat data
MNIST, kami memuat dalam tiga set data:
Sampai sekarang, kita menggunakan otraining_dataetest_data dan mengabaikan ovalidation_data. O validation_data berisi
10.000 gambar digit, gambar yang berbeda dari 50.000 gambar di set pelatihan
MNIST dan 10.000 gambar dalam kumpulan ujian MNIST. Alih-alih menggunakan test_data untuk menghindari
overfitting, kita akan menggunakan validation_data. Untuk melakukan ini, kita akan menggunakan hampir sama strategi yang dijelaskan
di atas untuk test_data. Artinya, kami akan menghitung akurasi pengklasifikasian pada data validasi pada akhir
Setiap era. Ketika akurasi klasifikasi pada data validasi sudah mencapai titik jenuh, kami berhenti melatih.
Strategi ini disebut dengan penghentian awal (Early-Stopping). Tentu saja, dalam praktiknya, kita tidak tahu
segera setelah akurasi sudah jenuh. Sebagai gantinya, kami terus melatih hingga kami yakin bahwa
bahwa presisi telah jenuh.

Mengapa menggunakan validation_data untuk menghindari overfitting, alih-alih test_data? Sebenarnya, ini adalah bagian dari
strategi yang lebih umum, yaitu menggunakan validation_data untuk mengevaluasi berbagai opsi evaluasi
hiperparameter, seperti jumlah epoch untuk pelatihan, laju pembelajaran, arsitektur terbaik dari
jaringan dan seterusnya. Kami menggunakan penilaian ini untuk menemukan dan menentukan nilai-nilai yang baik untuk
hiperparameter. Sebenarnya, meskipun saya belum menyebutkan hal ini sampai sekarang, ini adalah, sebagian, bagaimana kita sampai pada
pada pemilihan hiperparameter yang dibuat sebelumnya dalam buku ini. (Lebih banyak tentang ini nanti.)

Tentu, ini sama sekali tidak menjawab pertanyaan mengapa kita menggunakan validation_data untuk
menghindari overfitting, alih-alih data_uji. Untuk memahami mengapa, pertimbangkan bahwa, saat menentukan hiperparameter,
Kemungkinan kita akan mencoba banyak opsi berbeda untuk hiperparameter. Jika kita menetapkan
hiperparameter berdasarkan evaluasi test_data, kita akan dapat menyempurnakan hyperparameter kita.
hiperparameter pada data_uji. Artinya, kita bisa saja menemukan hiperparameter yang cocok di
keanehan khusus dari data uji, tetapi di mana kinerja jaringan tidak dapat digeneralisasi untuk
sets data lainnya. Kami melindungi terhadap ini dengan menemukan hiperparameter menggunakan
data_validasi. Jadi, setelah kita memiliki hiperparameter yang kita inginkan, kita melakukan evaluasi
akhir dari keakuratan menggunakan data_uji. Ini memberi kita keyakinan bahwa hasil kita pada data uji adalah
sebuah ukuran nyata seberapa baik jaringan saraf kita menggeneralisasi. Untuk mengatakannya dengan cara lain, Anda bisa
memikirkan data validasi sebagai jenis data pelatihan yang membantu kita belajar dengan baik
parameter. Pendekatan ini untuk menemukan hiperparameter yang baik kadang-kadang dikenal sebagai metode
"menahan", karena data validasi disimpan terpisah atau "dijaga" dari data
pelatihan.

Sekarang, dalam praktiknya, bahkan setelah menilai kinerja pada data pengujian, kita dapat mengubah pendapat kita.
dan mencoba pendekatan lain - mungkin arsitektur jaringan yang berbeda - yang melibatkan penemuan baru
kumpulan hiperparameter. Jika kita melakukan ini, apakah tidak ada bahaya kita juga akan berakhir dengan test_data?
Kami memerlukan regresi yang berpotensi tak terhingga dari kumpulan data, agar kami dapat memastikan
apakah hasil kami akan digeneralisasikan? Mengatasi kekhawatiran ini adalah masalah yang dalam dan sulit.
Namun untuk tujuan praktis kita, kita tidak akan terlalu khawatir dengan masalah ini. Sebagai gantinya, kita akan
kita fokus pada metode dasar retensi, berdasarkan data training_data, validation_data dan test_data,
sesuai dengan yang dijelaskan di atas.

Kami melihat bahwa overfitting terjadi ketika kita hanya menggunakan 1.000 gambar pelatihan. Apa yang
apa yang terjadi ketika kita menggunakan set pelatihan lengkap dari 50.000 gambar? Kami akan menjaga semua
parameter lain sama (30 neuron tersembunyi, laju pembelajaran 0,5, ukuran mini-batch 10)
Kami melatih menggunakan semua 50.000 gambar selama 30 epoch. Berikut adalah grafik yang menunjukkan hasilnya.
dari akurasi klasifikasi pada data pelatihan dan data pengujian. Perhatikan bahwa saya menggunakan data dari
tes di sini, alih-alih data validasi, untuk membuat hasil lebih langsung dapat dibandingkan dengan
grafik sebelumnya.
Seperti yang Anda lihat, akurasi pada data pengujian dan pelatihan tetap jauh lebih dekat daripada
ketika kami menggunakan 1.000 contoh pelatihan. Khususnya, akurasi klasifikasi terbaik
de 97,86% pada data pelatihan hanya 2,53% lebih tinggi daripada 95,33% pada data pengujian. Ini adalah
dibandingkan dengan selisih 17,73% yang kita alami sebelumnya! Overfitting masih terjadi, tetapi
itu sangat berkurang. Jaringan kami sedang menjadi jauh lebih baik dari data pelatihan untuk
data uji. Secara umum, salah satu cara terbaik untuk mengurangi overfitting adalah dengan meningkatkan volume
(ukuran) dari data pelatihan (sekarang jelas mengapaBig Datasedang merevolusi Ilmu
Data?). Dengan data pelatihan yang cukup, bahkan jaringan yang sangat besar pun sulit mengalami
overfitting. Sayangnya, data pelatihan bisa mahal atau sulit didapat, jadi tidak ada
selalu merupakan pilihan yang praktis.

Meningkatkan jumlah data pelatihan adalah salah satu cara untuk mengurangi overfitting. Tetapi ada cara lain
cara-cara untuk mengurangi tingkat overfitting? Salah satu pendekatan yang mungkin adalah dengan mengurangi ukuran jaringan kita.
Namun, jaringan besar memiliki potensi untuk menjadi lebih kuat daripada jaringan kecil dan, oleh karena itu, ini
itu adalah opsi yang hanya kami adopsi sebagai upaya terakhir.

Untungnya, ada teknik lain yang dapat mengurangi overfitting, bahkan ketika kita memiliki jaringan tetap dan
data pelatihan tetap. Teknik ini dikenal sebagai teknik regularisasi dan akan menjadi topik dari
bab selanjutnya.

Sampai saat itu!

Bab 20–Overfitting dan Regularisasi–Bagian
2

Meningkatkan jumlah data pelatihan adalah salah satu cara untuk mengurangi overfitting. Tetapi ada cara lain.
cara-cara untuk mengurangi frekuensi terjadinya overfitting? Salah satu pendekatan yang mungkin adalah mengurangi ukuran
dari jaringan kami. Namun, jaringan yang besar memiliki potensi untuk menjadi lebih kuat daripada jaringan kecil dan
ini adalah opsi yang hanya akan kami adopsi dengan rasa enggan.

Untungnya, ada teknik lain yang dapat mengurangi overfitting, bahkan ketika kita memiliki sebuah jaringan dari
ukuran tetap dan data pelatihan dalam jumlah terbatas. Teknik-teknik ini dikenal sebagai teknik
regularisasi. Dalam bab ini, kami menjelaskan salah satu teknik regularisasi yang paling umum digunakan,
sebuah teknik yang kadang dikenal sebagai pengurangan bobot (weight decay) atau Regularisasi L2. Ide dari
Regularisasi L2 adalah menambahkan istilah ekstra ke fungsi biaya, istilah yang disebut istilah regularisasi.
Berikut adalah entropi silang yang diregulasi:

Persamaan 1

Istilah pertama hanyalah ekspresi biasa untuk entropi silang. Tetapi kami menambahkan istilah kedua,
jumlah kuadrat dari semua bobot jaringan. Ini disesuaikan dengan faktor λ / 2n, di mana λ > 0 adalah
dikenal sebagai parameter regularisasi ené, seperti biasa, ukuran himpunan kami
pelatihan. Saya akan membahas lebih lanjut nanti bagaimana λ dipilih. Juga penting untuk dicatat bahwa istilah dari
regulasi tidak mencakup bias. Saya juga akan kembali ke ini di kemudian hari.

Tentu saja, adalah mungkin untuk menormalkan fungsi biaya lainnya, seperti biaya kuadrat. Ini dapat dilakukan dari
cara yang serupa:

Persamaan 2
Dalam kedua kasus, kita bisa menuliskan fungsi biaya teratur sebagai:

Persamaan 3

onde C0 adalah fungsi biaya asli dan tidak diregulasi.

Secara intuitif, efek dari regularisasi adalah membuat jaringan lebih suka belajar bobot yang kecil, yaitu
semua hal lainnya sama. Berat besar hanya akan diizinkan jika secara signifikan meningkatkan
bagian pertama dari fungsi biaya. Dengan kata lain, regularisasi dapat dilihat sebagai sebuah cara untuk
berkompromi antara menemukan bobot kecil dan meminimalkan fungsi biaya asli. Pentingnya relatif
dua elemen dari komitmen tergantung pada nilai λ: ketika λ kecil, kami lebih suka meminimalkan
fungsi biaya asli, tetapi ketika λ besar, kami lebih memilih bobot kecil.

Sekarang, tidak sepenuhnya jelas mengapa melakukan jenis komitmen ini dapat membantu mengurangi overfitting! Tapi
jadi memang benar, kurangi. Kami akan membahas pertanyaan mengapa ini membantu mengurangi overfitting di berikutnya
bab, tetapi pertama-tama mari kita bekerja pada contoh yang menunjukkan bagaimana regulasi mengurangi overfitting.

Untuk membangun sebuah contoh, kita perlu terlebih dahulu menemukan bagaimana menerapkan algoritma pembelajaran kita.
penurunan gradien stokastikdalam jaringan saraf yang diregulasi. Secara khusus, kita perlu tahu bagaimana
hitung turunan parsial ∂C/∂w dan ∂C/∂b untuk semua bobot dan bias di jaringan. Mengambil turunan
parcial dari Persamaan 3 di atas, kita memiliki:

Persamaan 4
Istilah ∂C0/∂w dan ∂C0/∂b dapat dihitung menggunakan backpropagation, seperti yang dijelaskan dalam bab-bab
sebelumnya. Dan dengan demikian kita melihat bahwa mudah untuk menghitung gradien dari fungsi biaya yang diregularisasi, karena hanya perlu menggunakan
backpropagation, seperti biasa, dan kemudian menambahkan (λ/n).wà turunan parsial dari semua istilah dari
peso. Sebagai turunan parsial terhadap bias tidak berubah dan, oleh karena itu, aturan pembelajaran
penurunan gradien untuk bias tidak berubah dari aturan biasa:

Persamaan 5

Aturan pembelajaran untuk bobot menjadi:

Persamaan 6

Ini persis sama dengan aturan biasa untuk pembelajaran penurunan gradien, kecuali untuk fakta bahwa
pertama menyusutkan berat w dengan faktor 1 - (ηλ/n). Pengurangan ini kadang-kadang disebut
de pengurangan berat, karena mengurangi beban. Sekilas, tampaknya ini berarti bahwa beban
sedang diarahkan ke nol, tetapi ini bukanlah itu, karena istilah lainnya bisa membawa bobot
untuk meningkat, jika itu menyebabkan penurunan fungsi biaya yang tidak teratur.

Oke, begini cara kerja penurunan gradien. Dan bagaimana dengan penurunan gradien stokastik? Nah, begini
seperti pada penurunan gradien stokastik yang tidak teratur, kita dapat memperkirakan ∂C0/∂w dengan rata-rata dari satu
mini-lote dari m contoh pelatihan. Dengan cara ini, aturan pembelajaran yang teratur untuk penurunan
gradien stokastik menjadi:

Persamaan 7

di mana jumlahnya adalah tentang contoh pelatihan x di mini-batch, dan Cx adalah biaya (tidak teratur) untuk setiap
contoh pelatihan. Ini persis sama dengan aturan biasa untuk penurunan gradien stokastik,
kecuali untuk faktor pengurangan berat 1 - (ηλ/n). Akhirnya, dan sepenuhnya, izinkan saya menyatakan
aturan pembelajaran yang teratur untuk bias. Artinya, pada dasarnya, persis sama dengan kasus
tidak terdaftar

Persamaan 8

di mana jumlah adalah tentang contoh pelatihan x dalam mini-batch.

Mari kita lihat bagaimana regulasi mengubah kinerja jaringan saraf kita. Kita akan menggunakan jaringan dengan 30
neuron yang tersembunyi, ukuran mini-batch 10, laju pembelajaran 0,5 dan fungsi biaya
entropi silang. Namun, kali ini kita akan menggunakan parameter regulasi λ = 0,1. Perhatikan bahwa di
kode, kita menggunakan nama variabel lmbda, karena lambda adalah kata kunci yang telah ditentukan dalam Python, dengan sebuah
makna yang tidak terkait dengan apa yang kita lakukan di sini (jika ada pertanyaan tentang kata kunci
di Python, akses kursus gratis Python Fundamentos Untuk Analisis Data–Bab 2).

Saya juga menggunakan test_data lagi, bukan validation_data. Secara ketat, kita harus menggunakan
data_validasi, untuk semua alasan yang telah kita diskusikan sebelumnya. Tapi saya memutuskan untuk menggunakan data_uji karena itu
mengembalikan hasil yang lebih langsung dapat dibandingkan dengan hasil kami sebelumnya dan tidak teratur.
Anda bisa dengan mudah mengubah kode untuk menggunakan validation_data dan Anda akan melihat bahwa itu akan memberikan hasil.
serupa.
Biaya untuk data pelatihan menurun seiring waktu, sama seperti pada kasus sebelumnya,
tidak teratur di bab sebelumnya:

Namun kali ini akurasi pada test_data terus meningkat selama 400 epoch:
Jelas, penggunaan regularisasi mengurangi overfitting. Selain itu, akurasi secara signifikan
lebih besar, dengan akurasi klasifikasi puncak sebesar 87,1%, dibandingkan dengan puncak 82,27% yang diperoleh
dalam kasus yang tidak teratur. Sebenarnya, hampir pasti kita bisa mendapatkan hasil yang cukup besar
lebih baik, melanjutkan pelatihan lebih dari 400 epoch. Tampaknya, secara empiris, regulasi sedang
membuat jaringan kami lebih umum dan secara signifikan mengurangi efek overfitting.

Apa yang terjadi jika kita keluar dari lingkungan buatan yang hanya memiliki 1.000 gambar pelatihan dan kembali ke
set lengkap pelatihan 50.000 gambar? Tentu saja, kita telah melihat bahwa overfitting jauh lebih sedikit
masalah dengan 50.000 gambar. Apakah regularisasi membantu lebih lanjut? Mari kita pertahankan hiperparameter
sama seperti contoh sebelumnya–30 epoch, laju pembelajaran 0,5, ukuran mini-batch 10. Namun,
kita perlu mengubah parameter regulasi. Alasanya adalah karena ukuran n dari himpunan
pelatihan berubah dari n = 1.000 menjadi n = 50.000, dan ini mengubah faktor penurunan bobot 1 − (ηλ/n). Jika
jika kita terus menggunakan λ = 0,1, itu akan berarti sangat sedikit kehilangan berat badan dan, oleh karena itu, sangat sedikit efek
dari regulasi. Kami mengkompensasi dengan mengubah menjadi λ = 5.0.

Oke, mari kita latih jaringan kita, berhenti terlebih dahulu untuk menginisialisasi ulang bobot:
Kami mendapatkan hasilnya:

Ada banyak kabar baik di sini. Pertama, akurasi klasifikasi kami pada data uji meningkat dari
95,49%, ketika tidak diperbaiki, menjadi 96,49%. Ini adalah perbaikan yang besar. Kedua,
kita dapat melihat bahwa perbedaan antara hasil di data pelatihan dan pengujian jauh lebih kecil dibandingkan
sebelumnya, dengan persentase di bawah nol. Ini masih merupakan celah yang signifikan, tetapi jelas kita telah melakukan
kemajuan substansial untuk mengurangi overfitting.

Akhirnya, mari kita lihat seberapa akurat klasifikasi uji yang kita peroleh ketika kita menggunakan 100 neuron.
Tersembunyi dan parameter regulasi λ = 5.0. Saya tidak akan melalui analisis detail tentang
overfitting di sini, ini murni untuk bersenang-senang, hanya untuk melihat akurasi yang bisa kita dapatkan ketika kita menggunakan
trik baru kami: fungsi biaya entropi silang dan Regulasi L2.

Hasil akhirnya adalah akurasi klasifikasi sebesar 97,92% pada data validasi. Ini adalah lompatan besar dari
kasus 30 neuron tersembunyi. Sebenarnya, sedikit lebih disesuaikan, untuk dijalankan selama 60 epoch dengan η =
0.1 e λ = 5.0, kami memecahkan batas 98%, mencapai akurasi klasifikasi 98.04% pada data
validasi. Tidak buruk untuk apa yang berakhir menjadi 152 baris kode!

Saya menjelaskan regulasi sebagai cara untuk mengurangi overfitting dan meningkatkan akurasi klasifikasi.
Sebenarnya, ini bukan satu-satunya manfaat. Secara empiris, dengan menjalankan beberapa eksekusi dari jaringan kami dengan
dataset MNIST, tetapi dengan inisialisasi bobot yang berbeda (acak), kami menemukan bahwa eksekusi tidak-
yang teratur secara sesekali akan terjebak, tampaknya terperangkap dalam minimum lokal dari fungsi
custo. Hasilnya adalah bahwa eksekusi yang berbeda kadang-kadang memberikan hasil yang cukup berbeda. Di sisi lain
Sebaliknya, eksekusi yang diatur memberikan hasil yang jauh lebih mudah untuk direplikasi.

Mengapa ini terjadi? Heuristiknya, jika fungsi biaya terdegradasi, panjang

vektor bobot kemungkinan akan tumbuh, semua hal lainnya sama. Seiring waktu, ini dapat menyebabkan
vektor berat yang benar-benar sangat besar. Ini dapat menyebabkan vektor berat terjebak
mengarah lebih kurang pada arah yang sama, kerana perubahan yang disebabkan oleh penurunan kecerunan membuat
hanya perubahan kecil dalam arah, ketika panjangnya panjang. Saya percaya fenomena ini ada
menyulitkan algoritma pembelajaran kita untuk mengeksplorasi ruang bobot dengan baik dan,
sehingga, lebih sulit untuk menemukan minimum yang baik dari fungsi biaya.

Kita belum selesai tentang regularisasi. Lebih lanjut tentang ini di bab berikutnya! Sampai saat itu!
Bab 21–Akhirnya, Mengapa Regulasi
Membantu Mengurangi Overfitting?

Kami melihat di bab sebelumnya bahwa regularisasi membantu mengurangi overfitting. Ini adalah hal yang menggembirakan, tetapi,
Sayangnya, tidak jelas mengapa regulasi membantu mengatasi overfitting! Sebuah cerita standar yang ...
orang-orang menjelaskan apa yang sedang terjadi mengikuti lebih kurang pemikiran ini: berat yang lebih kecil
adalah, dalam arti tertentu, memiliki kompleksitas yang lebih rendah dan, oleh karena itu, memberikan penjelasan yang lebih sederhana dan lebih
kuat untuk data dan biasanya harus dipilih. Ini adalah cerita yang cukup ringkas dan mengandung
berbagai elemen yang mungkin tampak samar atau memukau. Mari kita uraikan penjelasan ini dan
mengkaji-nya secara kritis. Bagaimanapun, Mengapa Regulasi Membantu Mengurangi Overfitting?

Untuk melakukan ini, mari kita anggap kita memiliki sekumpulan data sederhana yang ingin kita bangun sebuah
modelo:

Secara implisit, kita sedang mempelajari fenomena dunia nyata di sini, dengan x dan y mewakili data.
fenomena ini. Tujuan kami adalah membangun model yang memungkinkan kami memprediksi y sebagai fungsi dari x
ini adalah apa yang kami lakukan diPembelajaran MesinKita bisa mencoba menggunakan jaringan saraf untuk membangun ini
model, tetapi saya akan melakukan sesuatu yang lebih sederhana: saya akan mencoba memodelkan y sebagai polinomial dalam x. Saya sedang
melakukan ini daripada menggunakan jaringan saraf karena menggunakan polinomial akan membuat segalanya menjadi khusus
transparan. Setelah kita memahami kasus polinomial, kita akan menerjemahkannya ke dalam jaringan saraf.
Ada sepuluh titik pada grafik di atas, yang berarti kita dapat menemukan sebuah polinomial orde ke-9 y =
a0x9 + a1x8 +… + a9 yang cocok tepat dengan data. Berikut adalah grafik polinom ini:

Isso fornece um ajuste exato. Mas também podemos obter um bom ajuste usando o modelo linear y = 2x:
Model mana yang terbaik? Dan model mana yang lebih mungkin untuk menggeneralisasi dengan baik ke contoh lain?
fenomena dunia nyata yang sama?

Ini adalah pertanyaan yang sulit. Sebenarnya, kita tidak dapat menentukan dengan pasti jawaban untuk salah satu dari
pertanyaan di atas, tanpa banyak informasi lebih lanjut tentang fenomena dunia nyata yang kita analisis (itu
dimana pengalaman dariIlmuwan Datatentang area bisnis). Tapi mari kita pertimbangkan dua
kemungkinan: (1) polinomial urutan ke-9 adalah, sebenarnya, model yang benar-benar menggambarkan fenomena itu
dunia nyata, dan modelnya, oleh karena itu, akan menggeneralisasi dengan sempurna; (2) model yang benar adalah y = 2x, tetapi ada sebuah
noise tambahan kecil disebabkan oleh, katakanlah, kesalahan pengukuran, dan itulah sebabnya model tersebut tidak cocok
tepat.

Tidak mungkin secara a priori mengatakan kemungkinan mana dari dua kemungkinan ini yang benar (atau, sebenarnya, jika ada yang ketiga
kemungkinan adalah sah). Secara logis, salah satunya bisa saja benar. Dan itu bukan perbedaan sepele. Itu
benar bahwa dalam data yang diberikan hanya ada sedikit perbedaan antara kedua model. Tapi anggaplah
kami ingin memprediksi nilai y yang sesuai dengan nilai x yang besar, jauh lebih besar dari yang mana pun
sebagaimana ditunjukkan dalam grafik di atas. Jika kita mencoba melakukan ini, akan ada perbedaan dramatis antara perkiraan
dua model, karena model polinomial orde 9 mulai didominasi oleh istilah x9, sementara
model linear tetap, baik, linear.

Sebuah sudut pandang adalah mengatakan bahwa, dalam ilmu pengetahuan, kita harus mengikuti penjelasan yang paling sederhana, kecuali kita menjadi
terima kasih telah melakukan sebaliknya. Ketika kita menemukan model sederhana yang tampaknya menjelaskan banyak data,
kita tergoda untuk berteriak "Eureka!" Bagaimanapun, tampaknya tidak mungkin bahwa penjelasan sederhana terjadi hanya karena
kebetulan. Sebaliknya, kami mencurigai bahwa model tersebut harus menyatakan beberapa kebenaran yang mendasari
tentang fenomena. Dalam kasus ini, model y = 2x + kebisingan tampak jauh lebih sederhana daripada y = a0x9 +
a1x8 +…. Akan mengejutkan jika kesederhanaan ini terjadi secara kebetulan, dan kemudian kita curiga bahwa y =
2x + noise expresses some underlying truth. From this point of view, the 9th order model is really
belajar hanya efek dari kebisingan lokal. Dan begitulah, sementara model urutan ke-9 berfungsi
secara sempurna untuk titik data tertentu ini, model tidak akan dapat menggeneralisasi untuk yang lain
poin data, dan model linier akan memiliki kemampuan prediktif yang lebih besar.

Mari kita lihat apa arti sudut pandang ini untuk jaringan saraf. Misalkan jaringan kita memiliki, sebagian besar
Terkadang, beban kecil, seperti yang akan terjadi dalam jaringan yang teratur. Ukuran yang lebih kecil dari
pesos berarti bahwa perilaku jaringan tidak akan banyak berubah jika kita mengubah beberapa input acak
di sini dan di sana. Ini menyulitkan jaringan yang teratur untuk belajar efek dari kebisingan lokal pada data. Pikirkan tentang itu
sebagai cara untuk membuat agar bukti tidak begitu penting bagi keluaran jaringan. Sebaliknya,
jaringan teratur belajar untuk merespons jenis bukti yang sering dilihat di seluruh
kumpulan pelatihan. Di sisi lain, sebuah jaringan dengan bobot besar dapat mengubah cukup banyaknya
perilaku sebagai respons terhadap perubahan kecil dalam input. Jadi, jaringan yang tidak diregulasi dapat menggunakan
beban besar untuk mempelajari model kompleks yang mengandung banyak informasi tentang kebisingan dalam data
dari pelatihan. Singkatnya, jaringan yang diregulasi diarahkan untuk membangun model yang relatif sederhana
berdasarkan pola yang sering terlihat di data pelatihan dan tahan terhadap keanehan dari
pembelajaran kebisingan dalam data pelatihan. Harapannya adalah bahwa ini akan memaksa jaringan kami untuk belajar dari
kebenaran tentang fenomena yang dimaksud dan untuk menggeneralisasi lebih baik apa yang mereka pelajari.

Dengan mengatakan itu, dan dengan mempertahankan kebutuhan akan kehati-hatian dalam pikiran, adalah fakta empiris bahwa jaringan saraf
regularisasi umumnya menghasilkan generalisasi yang lebih baik daripada jaringan yang tidak teratur. Kenyataannya adalah tidak ada yang
masih mengembangkan penjelasan teoretis yang sepenuhnya meyakinkan untuk menjelaskan mengapa regulasi
membantu menggeneralisasi jaringan. Sebenarnya, para peneliti terus menulis artikel di mana mereka mencoba
berbagai pendekatan terhadap regulasi, membandingkannya untuk melihat mana yang bekerja lebih baik dan mencoba memahami mengapa
apa pendekatan yang berbeda bekerja lebih baik atau lebih buruk. Meskipun sering membantu, kita tidak memiliki sebuah
pemahaman sistematis yang sepenuhnya memuaskan tentang apa yang terjadi, hanya heuristik yang tidak lengkap dan
aturan umum.

Ada seperangkat pertanyaan yang lebih dalam di sini, pertanyaan yang menyentuh inti ilmu pengetahuan. Ini adalah pertanyaan tentang
bagaimana kita menggeneralisasi. Regularisasi dapat memberi kita tongkat sihir komputasional yang membantu kita
merah untuk menggeneralisasi lebih baik, tetapi tidak memberi kita pemahaman yang didasarkan pada prinsip tentang bagaimana
generalisasi berfungsi, tetapi tidak ada pendekatan yang terbaik.

Ini sangat mengganggu karena dalam kehidupan sehari-hari, kita manusia bisa melakukan generalisasi dengan baik. Ditunjukkan
hanya beberapa gambar seekor gajah, seorang anak akan cepat belajar mengenali gajah-gajah lainnya.
Tentu saja mereka kadang-kadang bisa membuat kesalahan, mungkin salah mengartikan badak dengan gajah,
Namun secara umum proses ini berfungsi dengan sangat tepat. Jadi kami memiliki sebuah sistem—otak
humano–dengan sejumlah besar parameter bebas. Dan setelah ditunjukkan hanya satu atau beberapa
gambar pelatihan, sistem belajar untuk menggeneralisasi ke gambar lain. Otak kita sedang
Rasa pasti, jika berjalan dengan sangat baik! Bagaimana kita melakukan ini? Pada titik ini kami tidak tahu. Saya harap
semoga di tahun-tahun mendatang kita mengembangkan teknik regulasi yang lebih kuat dalam jaringan saraf buatan,
técnicas que permitirão que as redes neurais generalizem bem, mesmo a partir de pequenos conjuntos de
data.

Faktanya, jaringan kami sudah menggeneralisasi lebih baik daripada yang bisa diharapkan sebelumnya. Sebuah jaringan dengan 100 neuron
ocultos memiliki hampir 80.000 parameter. Kami hanya memiliki 50.000 gambar dalam data pelatihan kami. Itu adalah
bagaimana mencoba menyesuaikan polinomial derajat 80.000 dalam 50.000 titik data. Akibatnya, kami
jaringan harus disesuaikan dengan baik. Dan, meskipun, seperti yang kita lihat sebelumnya, jaringan ini benar-benar membuat sebuah yang hebat
pekerjaan menggeneralisasi. Mengapa ini terjadi? Tidak dipahami dengan baik. Telah dikemukakan bahwa 'dinamika dari
Pembelajaran gradien menurun pada jaringan multilapis memiliki efek 'autoregulasi'.
sangat luar biasa, tetapi juga agak mengganggu bahwa kita tidak mengerti mengapa tepatnya itu
terjadi dan oleh karena itu seringkali model jaringan saraf dalam disebut sebagai "kotak hitam". Sementara
Itu, kami akan mengadopsi pendekatan pragmatis dan menggunakan regulasi setiap kali kami bisa. Jaringan kami
neural akan lebih baik seperti ini.

Biarkan saya menyelesaikan bagian ini dengan kembali ke detail yang saya tinggalkan tanpa penjelasan sebelumnya: fakta bahwa
regularisasi L2 tidak membatasi bias. Jelas bahwa akan mudah untuk memodifikasi prosedur regularisasi
untuk menormalkan bias. Secara empiris, melakukan ini seringkali tidak banyak mengubah hasil, jadi,
dalam ukuran tertentu, itu hanya sebuah konvensi untuk mengatur bias atau tidak. Namun, patut dicatat bahwa
memiliki bias yang besar tidak membuat neuron sensitif terhadap inputnya dengan cara yang sama seperti memiliki bobot
besar. Oleh karena itu, kita tidak perlu khawatir tentang bias besar yang memungkinkan jaringan kita untuk belajar
kebisingan dalam data pelatihan kami. Pada saat yang sama, memberikan bias besar memberi jaringan kami lebih
fleksibilitas dalam perilaku – khususnya, bias besar memfasilitasi saturasi neuron, yang
sering kali diinginkan. Oleh karena alasan ini, kami biasanya tidak menyertakan istilah bias saat kami mengatur jaringan
neural.

Anda sudah menyadari bahwa regularisasi adalah topik penting ketika kita membicarakan tentang jaringan saraf. Di kami
Di bab-bab selanjutnya kita akan mempelajari dua teknik regulasi lagi: Regulasi L1 dan Dropout!
perca!
Bab 22–Regulasi L1

Ada banyak teknik regularisasi selain Regularisasi L2 yang telah kita [Link] bab [Link] fato,
Begitu banyak teknik telah dikembangkan sehingga sulit untuk merangkum semuanya. Dalam bab ini dan dua bab berikutnya,
Mari kita jelaskan secara singkat tiga pendekatan lain untuk mengurangi overfitting: Regulasi L1, Dropout dan
peningkatan buatan ukuran himpunan pelatihan. Kami tidak akan membahas teknik-teknik ini secara mendalam.
kami melakukannya dengan Regularisasi L2. Sebaliknya, tujuan ini adalah untuk membiasakan Anda dengan ide-ide utama dan
menghargai keragaman teknik regulasi yang tersedia.

Regulasi L1

Dalam pendekatan ini, kami memodifikasi fungsi biaya yang tidak teratur, dengan menambahkan jumlah nilai-nilai
absolutos dari bobot:

Persamaan 1

Secara intuitif, ini mirip dengan Regularisasi L2, menghukum bobot besar dan cenderung membuat dengan
bahwa jaringan lebih memilih bobot kecil. Tentu saja, istilah Regularisasi L1 tidak sama dengan istilah
dari Regularização L2 dan, oleh karena itu, kita tidak harus mengharapkan untuk mendapatkan perilaku yang persis sama. Mari kita
mencoba memahami bagaimana perilaku jaringan yang dilatih menggunakan Regularisasi L1 berbeda dari jaringan
dilatih menggunakan Regularisasi L2.

Untuk melakukan ini, mari kita lihat turunan parsial dari fungsi biaya. Dari rumus sebelumnya kita mendapatkan:
 Persamaan 2

onde sgn(w) adalah tanda dari w, yaitu +1 jika w positif dan -1 jika w negatif. Menggunakan ekspresi ini, kita dapat
mudah memodifikasi backpropagation untuk melakukan penurunan gradien stokastik
menggunakan Regularisasi L1. Aturan pembaruan yang dihasilkan untuk jaringan yang diregulasi L1 adalah:

Persamaan 3–Aturan pembaruan L1

di mana, seperti biasa, kita bisa memperkirakan ∂C0/∂w menggunakan rata-rata mini-batch, jika kita mau. Bandingkan
ini dengan aturan pembaruan untuk Regularisasi L2:

Persamaan 4–Aturan pembaruan L2

Dalam kedua ekspresi, efek regularisasi adalah mengurangi bobot. Ini sesuai dengan kami
intuisinya bahwa kedua jenis regulasi menghukum bobot besar. Tetapi cara bobot
diminuem adalah berbeda. Dalam Regularisasi L1, bobot berkurang dalam jumlah tetap menuju 0. Di
Regularisasi L2, bobot berkurang dengan nilai yang proporsional terhadap w. Dan demikian, ketika bobot tertentu
memiliki magnitudo besar, Regularisasi L1 mengurangi bobot jauh lebih sedikit dibandingkan Regularisasi L2. Di
kontras, ketika |w| kecil, Regulasi L1 mengurangi berat jauh lebih banyak daripada Regulasi L2. O
Hasilnya adalah bahwa Regularisasi L1 cenderung untuk mengkonsentrasikan bobot jaringan pada sejumlah yang relatif kecil
dari koneksi yang sangat penting, sementara bobot lainnya diarahkan ke nol.

Namun masih ada satu detail kecil dalam diskusi di atas. Turunan parsial ∂C/∂w tidak terdefinisi ketika w =
0. Alasannya adalah bahwa fungsi |w| memiliki "sudut" tajam di w = 0 dan, oleh karena itu, tidak dapat didiferensiasi pada titik tersebut.
Semua baik, namun. Apa yang akan kami lakukan adalah menerapkan aturan biasa (tidak diatur) untuk penurunan gradien
stochastik ketika w = 0. Ini membantu menyelesaikan masalah - secara intuitif, efek regulasi adalah
mengurangi berat dan, tentu saja, tidak dapat mengurangi berat yang sudah 0. Untuk menempatkannya dengan lebih akurat,
Kami akan menggunakan Persamaan (2) dan (3) dengan konvensi bahwa sgn(0) = 0. Ini memberikan aturan yang bagus dan ringkas untuk digunakan.
melakukan penurunan gradien stokastik dengan Regularisasi L1.

Sekarang kita akan ke Dropout, di bab berikutnya!

Capítulo 23–Como Funciona o Dropout?

Dropout adalah teknik yang sangat berbeda untuk regularisasi. Berbeda dengan Regularisasi L1 dan L2,
Dropout tidak bergantung pada modifikasi fungsi biaya. Sebaliknya, dalam Dropout, kami memodifikasi itu sendiri.
rede. Biarkan saya menjelaskan mekanisme dasar dari Bagaimana Cara Kerja Dropout? sebelum memahami mengapa ia
fungsi dan apa hasilnya. Misalkan kita sedang mencoba melatih jaringan saraf:

Secara khusus, anggaplah kita memiliki masukan pelatihan x dan keluaran yang diinginkan yang sesuai y.
Biasanya, kami melatih melalui propagasi langsung dari x melalui jaringan, dan kemudian mundur.
(retropropagasi) untuk menentukan kontribusi kesalahan terhadap gradien. Dengan Dropout, proses ini adalah
dimodifikasi. Kami mulai dengan menghilangkan secara acak (dan sementara) beberapa dari neuron tersembunyi di
jaringan, membiarkan neuron masukan dan keluaran tidak tersentuh. Setelah melakukan ini, kita akan berakhir dengan sebuah jaringan
dengan cara berikut (perhatikan garis putus-putus pada gambar di bawah). Perhatikan neuron-neuron yang telah
sementara dihapus:
Kami meneruskan input x melalui jaringan yang dimodifikasi, dan kemudian melakukan backpropagation
hasil, juga melalui jaringan yang dimodifikasi. Setelah melakukan ini pada sekumpulan contoh mini,
kami memperbarui bobot dan bias yang sesuai. Selanjutnya, kami mengulangi proses, pertama memulihkan
neuron yang dihapus, kemudian memilih subset acak baru dari neuron tersembunyi untuk dikeluarkan,
mengestimasi gradien untuk mini-batch yang berbeda dan memperbarui bobot dan bias di jaringan.

Dengan mengulangi proses ini beberapa kali, jaringan kita akan mempelajari seperangkat bobot dan bias. Secara alami,
berat dan bias ini mungkin telah dipelajari dalam kondisi di mana sebagian neuron tersembunyi telah
dibuang. Ketika kita benar-benar menjalankan jaringan secara penuh, itu berarti lebih banyak neuron tersembunyi
akan aktif. Untuk mengimbanginya, kami mengurangi setengah dari bobot yang keluar dari neuron tersembunyi.

Prosedur penarikan ini mungkin terlihat aneh dan ad-hoc. Mengapa kami berharap ini akan membantu dengan
regularisasi? Untuk menjelaskan apa yang sedang terjadi, saya ingin Anda berhenti sejenak untuk berpikir tentang
o Dropout e, em vez disso, imagine o treinamento de redes neurais no modo padrão (sem Dropout). Em
khusus, bayangkan bahwa kita melatih beberapa jaringan saraf yang berbeda, semuanya menggunakan data yang sama
pelatihan. Jelas bahwa jaringan mungkin tidak mulai identik dan, sebagai hasilnya, setelah pelatihan, mereka
dapat, terkadang, memberikan hasil yang berbeda. Ketika itu terjadi, kita dapat menggunakan semacam skema dari
media atau pemungutan suara untuk memutuskan keluaran mana yang diterima. Misalnya, jika kita melatih lima jaringan, dan tiga di antaranya
mereka mengklasifikasikan sebuah digit sebagai "3", jadi kemungkinan besar itu adalah "3". Dua jaringan lainnya
mungkin mereka sedang melakukan kesalahan. Jenis skema rata-rata ini sering ditemukan sebagai
sebuah cara yang kuat (meskipun membutuhkan lebih banyak kapasitas komputasi) untuk mengurangi overfitting. Alasannya adalah
bahwa jaringan yang berbeda dapat tumpang tindih dengan cara yang berbeda dan rata-rata dapat membantu menghilangkan jenis ini
overfitting.

Apa hubungannya dengan Dropout? Secara heuristik, ketika kita meninggalkan berbagai set dari
neuron, itu seolah-olah kita sedang melatih jaringan saraf yang berbeda. Dan dengan demikian, prosedurnya
eliminasi adalah seperti menghitung rata-rata efek dari sejumlah besar jaringan yang berbeda. Yang berbeda
jaringan akan beradaptasi dengan cara yang berbeda, dan semoga, efek bersih dari Dropout akan
mengurangi overfitting.
Sebuah penjelasan heuristik terkait Dropout diberikan dalam salah satu artikel pertama yang menggunakan teknik tersebut:
Teknik ini mengurangi ko-adaptasi kompleks neuron, karena neuron tidak bisa mengandalkan
kehadiran neuron lain secara khusus. Oleh karena itu, dipaksa untuk belajar fitur yang lebih kuat yang merupakan
berguna bersama dengan banyak subkelompok acak yang berbeda dari neuron lainnya. Dengan kata lain,
jika kita memikirkan jaringan kita sebagai model yang membuat prediksi, maka kita bisa memikirkan tentang
Dropout sebagai cara untuk memastikan bahwa model kuat terhadap kehilangan bukti apa pun
individu. Dalam hal ini, ini sedikit mirip dengan Regularisasi L1 dan L2, yang cenderung mengurangi bobot dan,
dengan demikian, menjadikan jaringan lebih kuat untuk kehilangan koneksi individu mana pun dalam jaringan.

Tentu saja, ukuran sebenarnya dari Dropout adalah bahwa ia telah sangat berhasil dalam meningkatkan
kinerja jaringan saraf. Oartikel asli, memperkenalkan teknik tersebut, menerapkannya pada banyak tugas
berbeda. Bagi kami, sangat menarik bahwa mereka menerapkan Dropout dalam klasifikasi digit
MNIST, menggunakan jaringan saraf feedforward "vanilla" sepanjang garis yang mirip dengan yang kami
mempertimbangkan. Dokumen tersebut mencatat bahwa hasil terbaik yang dicapai seseorang hingga saat itu menggunakan
arsitektur tersebut mencapai akurasi klasifikasi sebesar 98,4% pada set pengujian. Mereka meningkatkannya menjadi
98,7% akurasi menggunakan kombinasi Dropout dan bentuk modifikasi dari Regularisasi L2. Da
bentuk yang sama, hasil yang mengesankan diperoleh untuk banyak tugas lainnya, termasuk masalah dari
pengakuan citra dan suara serta pemrosesan bahasa alami. Dropout telah menjadi khusus
berguna dalam pelatihan jaringan besar dan dalam, di mana masalah overfitting sering terjadi
agudo.

O Dropout dipelajari secara mendetail dan praktis dalam kursusPembelajaran Mendalam IIAkademi Data Science.

Sampai bab berikutnya!

Bab 24–Memperluas Secara Buatan
Data Pelatihan

Kami melihatsebelumnyabahwa akurasi klasifikasi dengan dataset MNIST turun menjadi persentase sekitar
dari 80%, ketika kami menggunakan hanya 1.000 gambar pelatihan. Tidak mengherankan bahwa ini terjadi, sebuah
vez que kurang data pelatihan berarti bahwa jaringan kami akan terpapar pada lebih sedikit variasi dalam bentuk
bagaimana manusia menulis digit. Mari kita coba melatih jaringan kami dengan 30 neuron tersembunyi dengan sebuah
beragam ukuran kumpulan data pelatihan yang berbeda, untuk melihat bagaimana kinerja bervariasi.
Kami akan melatih menggunakan ukuran mini-batch 10, laju pembelajaran η = 0,5, sebuah parameter dari
regularisasi λ = 5.0 dan fungsi biaya entropi silang. Kami akan melatih selama 30 epoch ketika kumpulan
data pelatihan lengkap akan digunakan dan kami akan meningkatkan jumlah epoch secara proporsional
ketika set pelatihan yang lebih kecil digunakan. Untuk memastikan bahwa faktor penurunan bobot
(faktor penurunan berat) tetap sama pada set pelatihan, kami akan menggunakan parameter
regulasi λ = 5.0 ketika lengkapnya dataset pelatihan digunakan, dan kita akan mengurangi
proporcionalmente ketika set pelatihan yang lebih kecil digunakan. Perhatikan grafik ini:

Seperti yang Anda lihat dengan menganalisis grafik di atas, akurasi klasifikasi meningkat secara signifikan
seiring dengan kita menggunakan lebih banyak data pelatihan. Diperkirakan, perbaikan ini akan berlanjut jika ada
lebih banyak data tersedia. Jelas bahwa, melihat grafik di atas, tampaknya kita mendekati
saturasi. Namun, anggaplah kita membuat ulang grafik dengan ukuran set pelatihan yang dipetakan
logaritmik:

Tampaknya jelas bahwa grafik masih naik menuju 100% akurasi. Ini menunjukkan bahwa, jika
kita menggunakan jauh lebih banyak data pelatihan – katakanlah, jutaan atau bahkan miliaran sampel digit
manuskrip, alih-alih hanya 50.000, mungkin kami akan memiliki kinerja yang jauh lebih baik,
meskipun di jaringan yang sangat kecil ini.

Obter mais dados de treinamento é uma ótima ideia. Infelizmente, pode ser caro e nem sempre é possível na
praktek. Namun, ada teknik lain yang bisa bekerja hampir sebaik itu, yaitu memperluas secara artifisial
data pelatihan. Misalkan, contohnya, kita mengambil gambar pelatihan MNIST, digit 5:
kita memutar dengan sudut kecil, katakanlah 15 derajat:

Itu masih dapat dikenali sebagai digit yang sama. Dan masih di tingkat piksel, itu sangat berbeda dari gambar mana pun
saat ini di data pelatihan MNIST. Mungkin untuk menambahkan gambar ini ke data
pelatihan dapat membantu jaringan kita untuk belajar lebih banyak tentang bagaimana mengklasifikasikan digit. Selain itu,
jelas, kami tidak terbatas untuk menambahkan hanya satu gambar. Kami dapat memperluas data kami dari
pelatihan dengan melakukan banyak rotasi kecil dari semua gambar pelatihan MNIST dan, kemudian,
menggunakan data pelatihan yang diperluas untuk meningkatkan kinerja jaringan kami.

Teknik ini sangat kuat dan telah banyak digunakan. Mari kita lihat beberapa hasil dari
umartikelyang menerapkan berbagai variasi teknik pada MNIST. Salah satu arsitektur jaringan saraf yang
mereka mempertimbangkan bahwa itu mirip dengan yang kami gunakan, jaringan feedforward dengan 800 neuron tersembunyi dan
menggunakan fungsi biaya entropi silang. Menjalankan jaringan dengan data pelatihan MNIST
standar, mereka mencapai akurasi klasifikasi 98,4% dalam kumpulan pengujian mereka. Mereka kemudian
memperluas data pelatihan, menggunakan tidak hanya rotasi, seperti yang saya jelaskan di atas, tetapi juga
mentransformasikan dan mendistorsi gambar. Saat melatih pada kumpulan data yang diperluas, meningkatkan akurasi dari
jaringan Anda hingga 98,9%. Mereka juga mengalami apa yang mereka sebut sebagai "distorsi elastis", semacam
spesial distorsi gambar yang ditujukan untuk meniru osilasi acak yang ditemukan di otot-otot
tangan. Dengan menggunakan distorsi elastis untuk memperluas data, mereka mencapai akurasi yang bahkan lebih tinggi,
99,3%. Secara efektif, mereka sedang memperluas pengalaman jaringan mereka, mengeksposnya pada jenis variasi
ditemukan dalam kaligrafi kerajaan. Jika Anda ingin belajar tentang teknik ini, mereka dipelajari secara rinci
emPenglihatan Komputer dan Pengenalan Gambar.

Variasi tentang teknik ini dapat digunakan untuk meningkatkan kinerja di banyak tugas.
pembelajaran, tidak hanya dalam pengenalan tulisan tangan. Prinsip umum adalah memperluas data dari
pelatihan menerapkan operasi yang mencerminkan variasi dunia nyata. Tidak sulit untuk memikirkan cara-cara untuk
lakukan ini. Misalkan, misalnya, Anda sedang membangun jaringan saraf untuk melakukan pengenalan
Kami manusia dapat mengenali ucapan bahkan di tengah distorsi seperti kebisingan latar belakang dan
Dengan cara ini Anda dapat memperluas data Anda dengan menambahkan kebisingan latar belakang. Kami juga dapat mengenali suara jika
Dia mungkin dipercepat atau diperlambat. Jadi, ini adalah cara lain untuk memperluas data pelatihan.
Teknik-teknik ini tidak selalu digunakan – misalnya, alih-alih memperluas data pelatihan
menambahkan kebisingan, mungkin lebih efisien untuk membersihkan input untuk jaringan dengan terlebih dahulu menerapkan sebuah filter
pengurangan kebisingan. Meskipun demikian, layak untuk mempertahankan gagasan untuk memperluas data pelatihan dan mencari
peluang untuk menerapkan teknik.

Sekarang Anda lebih memahami kekuatan dariData Besar, pois dengan lebih banyak data, dalam variasi yang lebih besar dan dihasilkan
dengan kecepatan tinggi, kami berhasil mencapai hasil yang belum pernah dilihat sebelumnya dalam Kecerdasan Buatan. Mari kita
melihat kembali bagaimana akurasi jaringan saraf kami bervariasi dengan ukuran set pelatihan:
Misalkan, alih-alih menggunakan jaringan saraf, kita menggunakan teknik pembelajaran mesin lainnya.
untuk mengklasifikasikan digit. Misalnya, mari kita coba menggunakan mesin vektor dukungan (SVM). Tidak
Jangan khawatir jika Anda tidak akrab dengan SVM, kita tidak perlu memahami rincian mereka.
saya ingin belajar tentang SVM, mereka dipelajari secara rinci diPembelajaran Mesin). Mari kita gunakan SVM
diberikan oleh pustaka scikit-learn. Lihat bagaimana kinerja SVM bervariasi tergantung pada ukuran
set pelatihan. Saya juga mencatat hasil dari jaringan syaraf, untuk memudahkan perbandingan:
Kemungkinan, hal pertama yang menarik perhatian tentang grafik ini adalah bahwa jaringan saraf kami mengungguli
SVM untuk setiap ukuran set pelatihan. Ini bagus, meskipun kami telah menggunakan pengaturan
prontas do SVM do scikit-learn, enquanto fizemos um bom trabalho customizando nossa rede neural. Um
Fakta halus, namun menarik, tentang grafik adalah bahwa, jika kita melatih SVM menggunakan 50.000 gambar, ia akan memiliki
performa yang lebih baik (94,48% akurasi) dibandingkan dengan jaringan syaraf kami ketika dilatih menggunakan 5.000 gambar
(akurasi 93,24%). Dengan kata lain, lebih banyak data pelatihan kadang-kadang dapat mengg
perbedaan dalam algoritma pembelajaran mesin yang digunakan.

Algo ainda mais interessante pode ocorrer. Suponha que estamos tentando resolver um problema usando
dua algoritma mesin pembelajaran, algoritma A dan algoritma B. Terkadang terjadi bahwa algoritma
A akan mengalahkan algoritma B dengan kumpulan data pelatihan, sementara algoritma B akan mengalahkan
algoritma A dengan set data pelatihan yang berbeda. Kami tidak melihat ini di atas - itu akan diperlukan.
bahwa kedua grafik tersebut berpotongan - tetapi jawaban yang benar untuk pertanyaan "Apakah algoritma A lebih baik daripada
algoritma B?” seria: “Berapa ukuran dataset pelatihan yang Anda gunakan?”
Semua ini adalah langkah pencegahan yang perlu diingat, baik saat melakukan pengembangan maupun saat membaca artikel.
penelitian. Banyak artikel berfokus pada menemukan trik baru untuk mendapatkan kinerja yang lebih baik di
set data referensi standar. "Teknik XPTO kami memberi kami peningkatan sebesar X persen dalam
benchmark standar Y" adalah bentuk kanonik dari klaim penelitian. Klaim semacam itu sering kali,
secara genuin, tetapi harus dipahami sebagai berlaku hanya dalam konteks dari kumpulan
data pelatihan spesifik yang digunakan. Bayangkan cerita alternatif di mana orang-orang yang
awal mula, mereka menciptakan kumpulan data referensi dengan memiliki izin penelitian yang lebih besar. Mereka
mereka mungkin telah menggunakan uang tambahan untuk mengumpulkan lebih banyak data pelatihan. Sangat mungkin bahwa
"aprimoramento" akibat teknik "XPTO" menghilang dalam kumpulan data yang lebih besar. Dalam lainnya
kata-kata, peningkatan yang diduga mungkin hanya sebuah kebetulan dalam sejarah. Pesan yang harus diambil,
terutama dalam aplikasi praktis, yang kita inginkan adalah algoritma yang lebih baik dan data yang lebih baik dari
pelatihan. Tidak masalah untuk mencari algoritma yang lebih baik, tetapi pastikan untuk tidak sedang
berfokus hanya pada algoritma terbaik, mengecualikan pencarian untuk data yang lebih banyak atau lebih baik dari
pelatihan.
Dengan ini kami menyimpulkan penyelaman kami ke dalam overfitting dan regularisasi. Tentu saja, kami akan kembali lagi ke
topik. Seperti yang telah kami sebutkan beberapa kali, overfitting adalah masalah besar dalam jaringan saraf,
terutama se komputer menjadi lebih kuat dan kita memiliki kemampuan untuk melatih
jaringan yang lebih besar. Sebagai hasilnya, ada kebutuhan mendesak untuk mengembangkan teknik-teknik yang kuat untuk
regulasi untuk mengurangi overfitting, dan ini adalah area yang sangat aktif dalam penelitian.

Pada bab berikutnya kita akan membahas topik penting lainnya: inisialisasi bobot. Sampai saat itu.
Bab 25–Inisialisasi Bobot dalam Jaringan
Kecerdasan Buatan

Ketika kita membuat jaringan saraf kita, kita harus membuat pilihan untuk nilai awal bobot dan bias.
(bias). Hingga sekarang, kami memilih mereka sesuai dengan preskripsi yang kami diskusikan dibab-bab sebelumnya.
Hanya untuk diingat, resepnya adalah memilih baik bobot maupun bias menggunakan variabel acak
Gaussianas independen, dinormalisasi untuk memiliki rata-rata 0 dan deviasi standar 1 (ini adalah suatu konsep
fundamental dalam Statistik dan jika Anda ingin memperoleh pengetahuan dalam Statistik, periksa yang terbaru dari kami
Pendidikan:Pelatihan Analisis Statistika untuk Ilmuwan Data).

Meskipun pendekatan ini telah berjalan dengan baik, cukup ad-hoc, dan layak untuk ditinjau kembali untuk melihat apakah
kita bisa menemukan cara yang lebih baik untuk menentukan bobot dan bias awal kita, dan mungkin membantu kita
jaringan saraf untuk belajar lebih cepat. Ini yang akan kita pelajari di bab ini.

Untuk memulai, mari kita memahami mengapa kita dapat melakukan sedikit lebih baik daripada menginisialisasi berat dan bias.
dengan nilai Gaussian yang dinormalisasi. Untuk melihat mengapa, anggaplah kita sedang bekerja dengan sebuah jaringan
dengan sejumlah besar – katakanlah 1.000 – neuron masukan. Dan mari kita anggap bahwa kita menggunakan nilai
Gaussianos dinormalisasi untuk menginisialisasi bobot yang terhubung ke lapisan tersembunyi pertama. Untuk saat ini, saya akan
saya fokus secara spesifik pada bobot yang menghubungkan neuron masukan ke neuron pertama di
lapisan tersembunyi dan mengabaikan sisa jaringan:

Mari kita anggap, untuk kesederhanaan, bahwa kita sedang mencoba melatih menggunakan input pelatihan x di mana
Setengah dari neuron masukan diaktifkan, yaitu, diatur ke 1, dan setengah dari neuron
entrada dimatikan, yaitu disesuaikan menjadi 0. Argumen berikut berlaku secara lebih umum, tetapi
anda akan mendapatkan esensi dari kasus khusus ini. Mari kita pertimbangkan jumlah berbobot z = ∑jwjxj + bd dari input
untuk neuron tersembunyi kita. Terjadi bahwa 500 istilah dalam jumlah ini menghilang, karena input
korespondensi xj adalah nol dan, dengan demikian, z adalah jumlah dari total 501 variabel acak Gaussian
dinormalisasi, mewakili 500 istilah berbobot dan istilah tambahan dari bias. Jadi, z adalah itu sendiri sebuah
distribusi Gaussian dengan rata-rata nol dan deviasi standar ≈ 22.4 (akar kuadrat dari 501). Dengan kata lain, z memiliki sebuah
distribusi Gaussian yang sangat lebar, tanpa puncak tajam, sesuai dengan gambar di bawah ini:
Secara khusus, kita dapat melihat di grafik ini bahwa sangat mungkin | z | akan cukup besar, artinya, z > 1 atau z
Jika itu ada, keluaran σ(z) dari neuron tersembunyi akan sangat dekat dengan 1 atau 0. Ini berarti bahwa
neuron kita yang tersembunyi akan terkontaminasi. Dan ketika ini terjadi, seperti yang kita ketahui, melakukan perubahan kecil pada
peso hanya akan membuat perubahan yang sangat kecil pada aktivasi neuron tersembunyi kita. Perubahan ini
huruf kecil dalam aktivasi neuron tersembunyi, pada gilirannya, hampir tidak akan mempengaruhi sisa neuron di jaringan, dan
kita akan melihat perubahan kecil yang sesuai dalam fungsi biaya. Akibatnya, bobot ini hanya
akan belajar sangat lambat ketika kita menggunakan algoritma penurunan gradien. Ini mirip dengan
masalah yang kita diskusikan sebelumnya di bab-bab lain, di mana neuron keluaran yang jenuh
nilai yang salah menyebabkan pembelajaran berkurang. Kami membahas masalah sebelumnya ini dengan sebuah
pemilihan fungsi biaya yang cerdas. Sayangnya, sementara ini membantu dengan neuron
Desaídasaturados, dia tidak melakukan apa-apa untuk masalah neuronocultosaturados.

Kami telah membahas tentang masuknya bobot untuk lapisan tersembunyi pertama. Secara alami, argumen
yang serupa juga diterapkan pada lapisan tersembunyi setelahnya: jika bobot di lapisan tersembunyi setelahnya
forem diinisialisasi menggunakan Gaussian yang dinormalisasi, maka aktivasi akan sering kali sangat
mendekati 0 atau 1, dan pembelajaran akan berlanjut sangat lambat.

Apakah ada cara untuk memilih inisialisasi yang lebih baik untuk bobot dan bias, agar tidak
mari kita memiliki jenis saturasi ini dan, dengan demikian, menghindari perlambatan dalam pembelajaran? Misalkan bahwa
tenhamos um neurônio com pesos de entrada nin. Então, inicializaremos esses pesos como variáveis
acak gaussian dengan rata-rata 0 dan deviasi standar:

Artinya, kita akan "menekan gaussian", sehingga neuron kita kurang mungkin untuk jenuh.
Kami akan terus memilih bias sebagai Gaussian dengan rata-rata 0 dan deviasi standar 1, karena alasan yang
kami akan kembali sebentar lagi. Dengan pilihan ini, jumlah tertimbang z = ∑jwjxj + b akan menjadi sekali lagi sebuah
variabel acak Gaussian dengan rata-rata 0, tetapi akan jauh lebih tajam daripada sebelumnya. Anggaplah, seperti yang kita lakukan
sebelumnya, bahwa 500 dari entri adalah nol dan 500 adalah 1. Jadi mudah untuk menunjukkan (lihat grafik di bawah) bahwa z
ada distribusi Gaussian dengan rata-rata 0 dan deviasi standar sama dengan 1,22... (akar kuadrat dari 3/2). Itu adalah
jauh lebih tajam dari sebelumnya, sehingga bahkan grafik di bawah ini meremehkan situasi, karena kita perlu
mengubah ukuran sumbu vertikal, ketika dibandingkan dengan grafik sebelumnya:
Sangat tidak mungkin neuron tersebut jenuh dan, akibatnya, sangat tidak mungkin bahwa ia memiliki
masalah dengan lambatnya pembelajaran.

Saya menyatakan di atas bahwa kami akan terus menginisialisasi bias seperti sebelumnya, sebagai variabel acak
Gaussianas dengan rata-rata 0 dan deviasi standar 1. Ini tidak menjadi masalah, karena sangat tidak mungkin bahwa
neuron kita akan jenuh. Sebenarnya, tidak masalah bagaimana kita menginisialisasi bias, asalkan
mari kita hindari masalah dengan saturasi neuron. Beberapa orang pergi sejauh itu untuk memulai
semua bias dengan 0, dan bergantung pada penurunan gradien untuk belajar bias yang sesuai. Tapi bagaimana itu
tidak mungkin akan membuat banyak perbedaan, kami akan melanjutkan dengan prosedur inisialisasi yang sama seperti sebelumnya.

Mari kita bandingkan hasil untuk pendekatan lama dan baru kita untuk inisialisasi bobot, menggunakan
tugas klasifikasi digit MNIST. Seperti sebelumnya, kita akan menggunakan 30 neuron tersembunyi, ukuran mini-
kumpulan 10, parameter regularisasi λ = 5.0 dan fungsi biaya entropi silang. Kami akan mengurangi
sedikit menurunkan tingkat pembelajaran η = 0,5 menjadi 0,1, karena itu membuat hasilnya sedikit lebih terlihat
di grafik. Kita dapat melatih menggunakan metode inisialisasi bobot lama (kodenya bisa
ditemukan di repositori buku ini diGithub):
Kita juga bisa melatih menggunakan pendekatan baru untuk menginisialisasi bobot. Sebenarnya, ini bahkan lebih
mudah, karena cara standar untuk menginisialisasi bobot jaringan adalah menggunakan pendekatan baru ini. Ini berarti bahwa
kita bisa mengabaikan pemanggilan net.large_weight_initializer() di atas:

Memplot hasilnya, kita mendapatkan:

Dalam kedua kasus, kami akhirnya memperoleh akurasi klasifikasi sedikit di atas 96%. Akurasi akhir
da klasifikasi hampir persis sama di kedua kasus, tetapi teknik inisialisasi baru itu sangat,
jauh lebih cepat. Di akhir musim pelatihan pertama, pendekatan lama untuk inisialisasi bobot
memiliki akurasi klasifikasi di bawah 87%, sementara pendekatan baru hampir mencapai 93%. Apa yang
sepertinya yang terjadi adalah pendekatan baru kami untuk inisialisasi bobot membawa kami ke proses
jauh lebih baik, yang memungkinkan kami untuk mendapatkan hasil yang baik jauh lebih cepat. Fenomena yang sama
juga terlihat jika kita menggambar hasil dengan 100 neuron tersembunyi:
Dalam hal ini, kedua kurva tersebut tidak bertemu. Namun, pengalaman kami menunjukkan bahwa, dengan hanya
beberapa epoches pelatihan lagi (tidak ditampilkan), presisinya menjadi hampir persis sama.
Oleh karena itu, berdasarkan eksperimen ini, tampaknya inisialisasi bobot yang ditingkatkan hanya mempercepat
pembelajaran, tidak mengubah kinerja akhir jaringan kita. Namun, kita akan melihat lebih lanjut beberapa
contoh jaringan saraf di mana perilaku jangka panjang secara signifikan lebih baik dengan
inisialisasi bobot menggunakan:

Dengan demikian, bukan hanya kecepatan pembelajaran yang ditingkatkan, tetapi juga kinerja akhirnya.

Pendekatan di atas untuk inisialisasi bobot membantu meningkatkan cara jaringan saraf kita.
Kami belajar. Teknik lain untuk inisialisasi bobot juga telah diusulkan, banyak yang berdasarkan pada ide ini
dasar. Kami tidak akan membahas pendekatan lainnya di sini, karena yang dijelaskan sebelumnya bekerja dengan baik.
cukup untuk tujuan kami. Jika Anda tertarik untuk meneliti lebih lanjut, kami sarankan untuk membaca
halaman 14 dan 15 dari sebuah artikel tahun 2012 oleh Yoshua Bengio (salah satu tokoh utama Deep Learning), baik
seperti referensi yang terkandung di dalamnya:Rekomendasi Praktis untuk Pelatihan Berbasis Gradien dari Deep
Arsitektur. Nos cursosPembelajaran Mendalam IePembelajaran Mendalam IITema ini juga dipelajari secara rinci.

Sampai bab selanjutnya!

Bab 26–Cara Memilih
Hiperparameter Jaringan Saraf

Sampai sekarang kami belum menjelaskan bagaimana nilai-nilai hiperparameter seperti laju dipilih.
pembelajaran, η, parameter regularisasi, λ dan seterusnya. Kami memberikan nilai yang berhasil
sangat baik, tetapi, dalam praktiknya, ketika Anda menggunakan jaringan saraf untuk menyelesaikan masalah, itu bisa jadi
sulit menemukan parameter yang baik. Dalam bab ini, kami memulai studi kami tentang Cara Memilih
Hiperparameter Jaringan Saraf. Mari kita mulai?

Bayangkan, misalnya, bahwa kita baru saja diperkenalkan dengan dataset MNIST dan mulai bekerja di atasnya,
tanpa mengetahui apa pun tentang hiperparameter mana yang harus digunakan. Mari kita anggap bahwa, untungnya, di awal kami
eksperimen, kami memilih banyak dari hiperparameter dengan cara yang sama seperti yang dilakukan dibab
sebelumnya: 30 neuron tersembunyi, ukuran mini-batch 10, dilatih selama 30 epoch menggunakan entropi
cruzada. Namun kami memilih laju pembelajaran η = 10.0 dan parameter regularisasi λ = 1000.0.
Berikut adalah contoh eksekusi jaringan (skrip tersedia di repositori buku diGithub):

Presisi klasifikasi kami tidak lebih baik dari kebetulan! Jaringan kami bertindak sebagai
generator suara acak!
“Nah, itu mudah untuk diperbaiki,” Anda bisa bilang, “cukup turunkan laju pembelajaran dan
hiperparameter regulasi. Sayangnya, Anda tidak tahu sebelumnya apa saja hiperparameter yang
Anda perlu menyesuaikan. Mungkin masalah sebenarnya adalah bahwa jaringan neuron tersembunyi kita tidak pernah
akan berfungsi dengan baik, tidak peduli bagaimana hiperparameter lainnya dipilih? Mungkin benar-benar
apakah kita perlu setidaknya 100 neuron tersembunyi? Atau 300 neuron tersembunyi? Atau beberapa lapisan tersembunyi?
Atau pendekatan berbeda untuk mengodekan keluaran? Mungkin jaringan kami sedang belajar, tetapi kami perlu
melatih dalam lebih banyak epoch? Mungkin mini-batch terlalu kecil? Mungkin lebih baik kita kembali ke
fungsi biaya kuadrat? Mungkin kita perlu mencoba pendekatan berbeda untuk menginisialisasi bobot? Dan
dan seterusnya. Jika itu mudah, kita tidak akan membutuhkan sebuahIlmuwan Data, nãapakah itu benar?

Sangat mudah merasa tersesat dengan begitu banyak pilihan dan kombinasi yang mungkin untuk hiperparameter. Itu bisa jadi
sangat frustasi jika jaringan Anda sangat besar atau menggunakan banyak data pelatihan, karena Anda dapat
berlatih selama berjam-jam, berhari-hari atau berminggu-minggu, hanya untuk tidak mendapatkan hasil. Jika situasi ini terus berlanjut, itu akan merugikan Anda
kepercayaan. Mungkin jaringan saraf adalah pendekatan yang salah untuk masalah Anda? Mungkin Anda harus
meninggalkan pekerjaan dan bekerja dengan peternakan lebah?

Dalam bab-bab selanjutnya, kami akan menjelaskan beberapa heuristik yang dapat digunakan untuk menentukan
hiperparameter dalam jaringan saraf. Tujuannya adalah untuk membantu Anda mengembangkan alur yang memungkinkan Anda
lakukan pekerjaan yang baik dalam menentukan hiperparameter. Tentu saja, kita tidak akan membahas semua tentang optimasi
hiperparameter. Ini adalah topik yang sangat besar, dan ini bukan, dengan cara apa pun, masalah yang sudah
sepenuhnya diselesaikan, tidak ada kesepakatan universal di antara para profesional tentang strategi yang tepat
ada selalu lebih banyak trik yang dapat Anda coba untuk mendapatkan sedikit lebih banyak kinerja
dari jaringan Anda. Tapi kami memiliki beberapa heuristik yang dapat kami mulai.

Memahami Situasi–Strategi Umum

Saat menggunakan jaringan syaraf untuk menyerang masalah baru, tantangan pertama adalah mendapatkan pembelajaran apa pun yang tidak-
sepele, yaitu, agar jaringan memperoleh hasil yang lebih baik daripada kebetulan. Ini bisa mengejutkan
sulit, terutama ketika menghadapi kelas masalah baru. Mari kita lihat beberapa strategi yang Anda
boleh digunakan jika memiliki masalah seperti itu.

Misalkan, misalnya, Anda sedang menyerang MNIST untuk pertama kalinya. Anda mulai dengan semangat,
tetapi merasa sedikit putus asa ketika jaringan pertamanya gagal total, seperti dalam contoh di atas. O
jalan yang harus dilalui adalah mengurangi ukuran masalah. Singkirkan semua gambar pelatihan dan
validasi, kecuali gambar 0 atau 1. Selanjutnya, coba latih jaringan untuk membedakan 0 dari 1. Tidak hanya
ini adalah masalah yang secara inheren lebih mudah daripada membedakan semua sepuluh digit, serta mengurangi
jumlah data pelatihan 80%, mempercepat pelatihan dengan faktor 5. Ini memungkinkan
eksperimen yang jauh lebih cepat dan, oleh karena itu, memberikan wawasan yang lebih cepat tentang cara membangun sebuah
jaringan yang bagus.

Anda dapat mempercepat percobaan lebih lanjut dengan memecah jaringan Anda menjadi jaringan yang lebih sederhana,
kemungkinan membuat pembelajaran yang berarti. Jika Anda percaya bahwa suatu jaringan [784, 10] kemungkinan
buat klasifikasi yang lebih baik dari kebetulan dengan dataset digit MNIST, jadi mulai kapan
eksperimen dengan jaringan ini. Ini akan jauh lebih cepat daripada melatih jaringan [784, 30, 10], dan Anda bisa
“falhar” lebih cepat (ini adalah konsep yang sangat umum di AS: “fail fast”, yaitu, lakukan kesalahan secepat mungkin)
secepat mungkin dan pelajari dari mereka. Jangan khawatir mencoba mencapai kesempurnaan, karena Anda tidak akan
mendapatkan dengan cara apa pun).

Anda bisa mempercepat eksperimen dengan meningkatkan frekuensi pemantauan. Di [Link],

kami memantau kinerja di akhir setiap era pelatihan. Dengan 50.000 gambar per era, ini
berarti menunggu sebentar - sekitar sepuluh detik per epoch, di laptop saya, saat melatih jaringan [784, 30,
10]–sebelum mendapatkan umpan balik tentang seberapa banyak jaringan sedang belajar. Jelas bahwa sepuluh detik tidak
sangat panjang, tetapi jika Anda ingin menguji puluhan opsi hiperparameter, itu membuat frustrasi, dan jika Anda ingin
menguji ratusan atau ribuan pilihan, ini mulai menjadi melemahkan. Kami dapat mendapatkan umpan balik lebih
secara cepat, memantau akurasi validasi dengan lebih sering, katakanlah, setiap 1.000 gambar dari
pelatihan. Selain itu, alih-alih menggunakan kumpulan lengkap 10.000 gambar validasi untuk
memantau kinerja, kita dapat memperoleh estimasi yang jauh lebih cepat hanya dengan menggunakan 100 gambar dari
validasi. Yang terpenting adalah bahwa jaringan melihat cukup gambar untuk benar-benar belajar dan mendapatkan sebuah
perkiraan kinerja yang cukup mendekati. Tentu saja, program kami [Link] saat ini tidak melakukan jenis ini
de monitoramento. Mas, como um clímax para obter um efeito semelhante para fins de ilustração, vamos
mengurangi data pelatihan kita menjadi hanya 1.000 gambar pelatihan pertama MNIST. Mari kita
coba dan lihat apa yang terjadi. (Untuk menjaga kode di bawah ini sederhana, saya tidak mengimplementasikan ide untuk menggunakan hanya
gambar 0 dan 1. Tentu saja, ini bisa dilakukan dengan sedikit lebih banyak usaha).

Kami masih menerima kebisingan murni! Tetapi ada kemenangan besar: sekarang kami mendapatkan umpan balik dalam sebuah
fraksi detik, alih-alih sekali setiap sepuluh detik. Ini berarti Anda bisa mengalami lebih banyak
cepat opsi hiperparameter lainnya, atau bahkan melakukan eksperimen menguji banyak opsi
berbeda dari hiperparameter hampir secara bersamaan.
Pada contoh di atas, kami membiarkan λ sebagai λ = 1000.0, seperti yang kami gunakan sebelumnya. Tapi karena kami mengubah
jumlah contoh pelatihan, kita seharusnya benar-benar mengubah λ untuk mempertahankan pengurangan bobot yang sama.
Ini berarti mengubah λ menjadi 20,0. Jika kita melakukan ini, maka inilah yang terjadi:
Ah! Kami memiliki sinyal. Itu bukan sinyal yang sangat baik, tetapi tetap saja sebuah sinyal. Itu adalah sesuatu yang bisa kami
membangun, memodifikasi hiperparameter untuk mencoba meningkatkan lebih jauh. Mungkin kita akan menemukan bahwa kita
tingkat pembelajaran perlu lebih tinggi. (Seperti yang mungkin Anda sadari, ini adalah dugaan yang konyol, karena alasan bahwa
Kami akan membahasnya segera, tetapi kami akan sampai di sana. Tidak ada jalan pintas untuk pembelajaran). Jadi, untuk menguji kami
prediksi, kami mencoba mengubah η hingga 100.0:

Ini tidak bagus, karena menunjukkan bahwa tebakan kita salah dan masalahnya bukanlah bahwa laju pembelajaran
fosse sangat rendah. Jadi, alih-alih itu, kami mencoba mengubah η menjadi η = 1.0:
Sekarang sudah lebih baik! Dan dengan cara ini kita bisa melanjutkan, menyesuaikan setiap hiperparameter secara individual,
meningkatkan kinerja secara bertahap. Setelah eksplorasi dilakukan untuk menemukan nilai yang lebih baik untuk
Kami melanjutkan untuk menemukan nilai yang baik untuk λ. Selanjutnya, coba arsitektur yang lebih kompleks.
katakanlah sebuah jaringan dengan 10 neuron tersembunyi dan sesuaikan nilainya untuk η dan λ lagi. Kemudian, tingkatkan menjadi
20 neuron tersembunyi dan kemudian, sesuaikan hiperparameter lainnya sedikit lebih dan seterusnya, di setiap
magang mengevaluasi kinerja menggunakan data validasi kami dan menggunakan evaluasi ini untuk menemukan
hiperparameter terbaik. Dengan melakukan ini, biasanya memerlukan waktu lebih lama untuk melihat dampaknya karena
modifikasi hiperparameter, dan dengan demikian kita dapat secara bertahap mengurangi frekuensi dari
pemantauan.

Semua ini tampak sangat menjanjikan sebagai strategi yang luas. Namun, saya ingin kembali ke tahap awal ini.
untuk menemukan hiperparameter yang memungkinkan suatu jaringan belajar apa saja. Bahkan, bahkan
diskusi di atas menyampaikan perspektif yang sangat positif. Bisa sangat mengecewakan bekerja dengan
sebuah jaringan yang tidak belajar apapun. Anda dapat menyesuaikan hiperparameter selama berhari-hari dan masih tidak mendapatkan
sebuah jawaban yang berarti. Karena itu, saya ingin menekankan sekali lagi bahwa, selama tahap-tahap awal,
Anda harus memastikan bahwa Anda dapat mendapatkan umpan balik cepat dari eksperimen. Secara intuitif, Anda bisa
Tampaknya menyederhanakan masalah dan arsitektur hanya akan memperlambatnya. Sebenarnya, ini mempercepat segalanya.
karena Anda dapat menemukan jaringan dengan sinyal yang signifikan lebih cepat. Setelah Anda memiliki
setelah menerima sinyal tersebut, seringkali Anda dapat memperoleh perbaikan cepat dengan meningkatkan hiperparameter. Dengan demikian
Seperti dalam segala hal dalam hidup, memulai bisa menjadi hal tersulit untuk dilakukan.

Oke, ini adalah strategi umum. Mari kita sekarang melihat beberapa rekomendasi spesifik untuk menentukan
hiperparameter. Saya akan fokus pada laju pembelajaran, η, pada parameter regularisasi L2, λ dan pada
ukuran mini-lot. Namun, banyak dari pengamatan juga berlaku untuk hiperparameter lainnya,
termasuk yang terkait dengan arsitektur jaringan, bentuk regulasi lainnya, dan beberapa hiperparameter
apa yang akan kita temukan lebih lanjut di sini di Buku Deep Learning, seperti koefisien momentum.

Oh tidak! Babnya sudah selesai! Tenang saja, kita akan melanjutkan di bab berikutnya. Sampai saat itu!
Bab 27–Tarif Pembelajaran Sebuah
Jaringan Saraf

Mari kita lanjutkan diskusi tentangbab sebelumnyatentang pemilihan hiperparameter dari model jaringan
neural, mempelajari salah satu yang paling penting, tingkat pembelajaran.

Misalkan kita menjalankan tiga jaringan saraf buatan yang dilatih dengan dataset MNIST dengan tiga laju belajar.
dari pembelajaran yang berbeda, η = 0.025, η = 0.25 dan η = 2.5, masing-masing. Mari kita definisikan yang lainnya
hiperparameter sesuai dengan pengalaman di bab-bab sebelumnya, menjalankan lebih dari 30 epoch, dengan
ukuran mini-lot 10 dan dengan λ = 5.0. Kami juga akan menggunakan semua 50.000 gambar dari
pelatihan. Berikut adalah grafik yang menunjukkan perilaku biaya pelatihan saat
kami melatih

Dengan η = 0,025, biaya menurun secara perlahan hingga periode akhir. Dengan η = 0,25, biaya awalnya menurun,
tetapi setelah sekitar 20 epoch ia mendekati saturasi, dan seterusnya sebagian besar perubahan adalah
hanya fluktuasi kecil dan tampaknya acak. Akhirnya, dengan η = 2.5, biayanya menjadi besar
osilasi sejak awal. Untuk memahami alasan osilasi, ingatlah bahwa penurunan stokastik dari
gradien yang diduga akan membawa kita secara bertahap ke lembah fungsi biaya (seperti yang dijelaskandi sini):
Namun, jika η sangat besar, langkah-langkahnya akan sangat besar sehingga sebenarnya dapat melampaui
minimum, membuat algoritme hanya tersesat selama pelatihan. Ini adalah
kemungkinan yang menyebabkan fluktuasi biaya ketika η = 2.5. Ketika kita memilih η = 0.25, yang
langkah awal membawa kita ke minimum fungsi biaya, dan hanya ketika kita mendekati minimum itu yang
kami mulai mengalami masalah overshooting. Dan ketika kami memilih η = 0,025, kami tidak mengalami ini.
masalah selama 30 epoch pertama.
Tentu saja, memilih yang begitu kecil menciptakan masalah lain, yang mengurangi kecepatan penurunan stokastik dari
gradien, meningkatkan total waktu pelatihan. Pendekatan yang lebih baik adalah mulai dengan η =
0,25, latih selama 20 epoch dan kemudian ubah menjadi η = 0,025. Kami akan membahas tabel-tabel tingkat ini.
belajar variabel kemudian. Untuk saat ini, mari kita fokus pada cara menemukan sebuah
satu nilai baik untuk laju pembelajaran, η.
Dengan gambar ini dalam pikiran, kita dapat mendefinisikan η dengan cara berikut. Pertama, kita memperkirakan nilai batas
di mana biaya pada data pelatihan mulai menurun segera, alih-alih berosilasi atau
meningkatkan. Perkiraan ini tidak harus sangat akurat. Anda bisa memperkirakan urutan magnitudo
mulai dengan η = 0.01. Jika biaya menurun selama beberapa epoch pertama, maka Anda harus secara bertahap
coba η = 0.1, 1.0,… hingga menemukan nilai untuk η di mana biaya berosilasi atau meningkat selama yang pertama
beberapa waktu (ini adalah bagian dari pekerjaan seorang)Ilmuwan Data).

Sebagai alternatif, jika biaya berfluktuasi atau meningkat selama epoch pertama, ketika η = 0.01, maka coba η
= 0.001 ,0.0001,… sampai menemukan nilai untuk η di mana biaya berkurang selama beberapa epoch pertama.
Dengan mengikuti prosedur ini, kita akan mendapatkan estimasi orde magnitudo untuk nilai batas η.
Anda dapat, secara opsional, memperhalus estimasi Anda, untuk memilih nilai maksimum η di mana biaya menurun
selama beberapa era pertama, katakan η = 0.5 atau η = 0.2 (tidak perlu agar ini super-
ini memberikan kita perkiraan untuk nilai batas η. Dan tentu saja, dokumentasikan semuanya!!!!

Jelas, nilai nyata η yang Anda gunakan tidak boleh lebih besar dari nilai batas. Sebenarnya, jika nilai η
tetap dapat digunakan sepanjang banyak zaman, jadi Anda mungkin ingin menggunakan nilai untuk η
yang lebih kecil, katakanlah, satu faktor dua di bawah batas. Pilihan ini biasanya akan memungkinkan Anda untuk
latihlah selama banyak waktu, tanpa menyebabkan perlambatan yang signifikan dalam pembelajaran.
Dalam kasus data MNIST, mengikuti strategi ini menghasilkan estimasi 0,1 untuk urutan magnitudo
nilai batas η. Setelah sedikit lebih banyak pemurnian, kita mendapatkan nilai batas η = 0,5. Mengikuti
preskripsi di atas, ini menyarankan menggunakan η = 0,25 sebagai nilai kita untuk laju pembelajaran. Faktanya, saya
Saya menemukan bahwa menggunakan η = 0.5 bekerja dengan cukup baik dalam 30 epoch yang, sebagian besar waktu, saya tidak me
khawatir menggunakan nilai η yang lebih kecil.

Semua ini terasa cukup sederhana. Namun, menggunakan biaya pelatihan untuk memilih η tampak
membantah apa yang kami katakan sebelumnya, bahwa kami akan memilih hiperparameter dengan mengevaluasi kinerja
menggunakan data validasi kami. Sebenarnya, kami akan menggunakan akurasi validasi untuk memilih
hiperparameter regulasi, ukuran mini-batch, dan parameter jaringan, seperti jumlah dari
lapisan dan neuron tersembunyi, dan seterusnya (kita akan mempelajari ini di bab-bab berikutnya).

Mengapa hal-hal berbeda untuk tingkat pembelajaran? Terus terang, pilihan ini adalah preferensi estetika.
Orang-orang mungkin agak idiosinkratik. Pemikirannya adalah bahwa hiperparameter lainnya ditujukan untuk
meningkatkan akurasi akhir klasifikasi pada set pengujian, dan oleh karena itu masuk akal untuk memilih mereka berdasarkan
dalam ketepatan validasi. Namun, laju pembelajaran hanya berpengaruh pada ketepatan akhir dari
klasifikasi. Tujuan utamanya adalah untuk benar-benar mengontrol ukuran langkah dalam penurunan gradien dan
memantau biaya pelatihan adalah cara terbaik untuk mendeteksi apakah ukuran langkahnya terlalu besar.
Dengan mengatakan itu, ini adalah preferensi pribadi. Pada awalnya, selama pembelajaran, biaya pelatihan
biasanya hanya menurun jika akurasi validasi meningkat dan dengan demikian, dalam praktiknya, tidak mungkin untuk melakukannya
banyak perbedaan dalam kriteria mana yang Anda gunakan.

Di bab berikutnya akan ada lebih banyak. Sampai jumpa!

Bab 28–Menggunakan Early Stopping Untuk
Menentukan Jumlah Epoch Pelatihan

Saat melatih jaringan saraf, berbagai keputusan perlu diambil terkait konfigurasi.
(hiperparameter) digunakan, untuk mendapatkan kinerja yang baik. Salah satu dari hiperparameter ini adalah jumlah
epoch pelatihan: yaitu, berapa banyak iterasi lengkap dari kumpulan data (epoch) yang harus dilakukan
digunakan? Jika kita menggunakan sedikit epoch, kita bisa mengalami masalah underfitting (yaitu, tidak belajar semuanya
apa yang bisa kami lakukan dengan data pelatihan); jika kita menggunakan banyak epoch, kita bisa mengalami masalah sebaliknya,
overfitting ("terlalu belajar", yaitu menyesuaikan "noise" dalam data pelatihan, bukan sinyal).
Kami menggunakan Early Stopping ("Penghentian Dini" atau "Penghentian Awal") tepatnya untuk mencoba menentukan
secara manual nilai ini. Juga dapat dianggap sebagai jenis metode regularisasi (seperti L1/L2
penurunan berat dan dropout yang dipelajarisebelumnyadi sini di buku), karena dapat mencegah overfitting jaringan
neural. Gambar di bawah ini membantu untuk mendefinisikan dengan jelas apa itu Early Stopping:

Saat melatih jaringan saraf, biasanya kita tertarik untuk mendapatkan jaringan dengan kinerja ideal dari
generalisasi. Namun, semua arsitektur jaringan saraf standar, seperti perceptron multilapis
total terhubung, cenderung mengalami overfitting. Sementara jaringan tampak membaik, yaitu, kesalahan di
set pelatihan menurun, pada suatu saat selama pelatihan sebenarnya mulai memburuk
sekali lagi, yaitu, kesalahan dalam contoh yang tidak terlihat meningkat.

Normalmente, kesalahan generalisasi diperkirakan oleh kesalahan validasi, yaitu, kesalahan rata-rata dalam suatu
kumpulan validasi, sekumpulan contoh tetap yang bukan dari kumpulan pelatihan. Terdapat
Dasarnya ada dua cara untuk mengatasi overfitting: mengurangi jumlah dimensi dari ruang
parameter atau mengurangi ukuran efektif dari setiap dimensi. Teknik untuk mengurangi jumlah dari
parameter adalah pembelajaran konstruktif yang serakah, pemangkasan atau berbagi bobot. Teknik untuk
mengurangi ukuran setiap dimensi parameter adalah regularisasi, seperti weight decay atau dropout, atau a
Pemberhentian Dini (Early Stopping). Pemberhentian dini banyak digunakan karena mudah dipahami dan
Diimplementasikan dan dilaporkan sebagai lebih baik daripada metode regularisasi dalam banyak kasus.

Menggunakan Early Stopping berarti bahwa, pada akhir setiap epoch, kita harus menghitung akurasi klasifikasi di
data validasi. Ketika akurasi berhenti meningkat, kami menghentikan pelatihan. Ini membuat
konfigurasi jumlah epoch yang sangat sederhana. Khususnya, ini berarti bahwa kita tidak perlu
khawatir dalam menemukan secara eksplisit bagaimana jumlah epoch tergantung pada hyperparameter lainnya, karena
ini dilakukan secara otomatis. Selain itu, Penghentian Dini juga secara otomatis mencegah
overfitting. Ini adalah, jelas, sesuatu yang baik, meskipun pada tahap awal eksperimen dapat berguna
matikan Penghentian Awal, agar Anda dapat melihat tanda-tanda overfitting dan menggunakannya untuk mendefinisikan
pendekatan regulasi Anda.

Untuk menerapkan Penghentian Dini, kita perlu mengatakan dengan lebih tepat apa yang berarti bahwa ketepatan
Klasifikasi berhenti meningkat. Seperti yang sudah kita lihat, akurasi bisa sedikit bergerak, meskipun ketika
tendensi umum adalah untuk memperbaiki. Jika kita berhenti untuk pertama kalinya, akurasi menurun, jadi hampir pasti
Kami akan berhenti ketika ada lebih banyak perbaikan yang perlu dilakukan. Aturan yang lebih baik adalah menyelesaikan jika akurasi terbaik
tidak meningkatkan peringkat untuk sementara waktu. Misalkan, misalnya, kita sedang bekerja dengan
dataset MNIST. Kita dapat memilih untuk berhenti jika akurasi klasifikasi tidak meningkat selama
sepuluh era terakhir. Ini menjamin bahwa kita tidak berhenti terlalu cepat, sebagai respons terhadap keberuntungan buruk dalam pelatihan, tetapi
juga bahwa kita tidak sedang menunggu selamanya untuk perbaikan yang tidak pernah terjadi.

Aturan "berhenti melatih jika tidak membaik dalam sepuluh epoch" ini baik untuk eksplorasi awal
MNIST. Namun, jaringan terkadang bisa menstabilkan diri pada tingkat akurasi tertentu.
klasifikasi untuk beberapa waktu, hanya untuk mulai membaik lagi. Jika Anda mencoba mendapatkan sebuah
kinerja yang sangat baik, aturan 'berhenti pelatihan jika tidak membaik dalam sepuluh epoch' bisa sangat
agresif. Dalam hal ini, kami menyarankan untuk menggunakan aturan ini untuk eksperimen awal dan, secara bertahap, mengadopsi
aturan yang lebih lunak, sesuai dengan pemahaman yang lebih baik tentang cara jaringan Anda dilatih: tanpa perbaikan dalam dua puluh
era, tanpa perbaikan dalam lima puluh era dan seterusnya. Tentu saja, ini memperkenalkan hiperparameter baru
untuk mengoptimalkan! Dalam praktiknya, bagaimanapun, biasanya mudah untuk menentukan hiperparameter ini untuk mendapatkan hasil yang baik
hasil. Dengan cara yang sama, untuk masalah yang berbeda dari MNIST, aturan tidak-perbaikan-dalam-sepuluh dapat
terlalu agresif atau tidak cukup agresif, tergantung pada rincian masalah. Namun,
Dengan sedikit percobaan, biasanya mudah untuk menemukan strategi yang baik untuk Early Stopping.
Ini adalah bagian dari pekerjaanIlmuwan DataAnda melakukannyaInsinyur Kecerdasan Buatan.

Hingga kini, kami belum menggunakan Early Stopping dalam eksperimen MNIST kami. Alasannya adalah kami telah melakukan
banyak perbandingan antara berbagai pendekatan pembelajaran. Untuk perbandingan semacam itu, berguna untuk menggunakan yang sama
jumlah epoch di setiap kasus. Namun, perlu untuk memodifikasi [Link] (tersedia di repositori
melakukan kursus diGithub) Untuk mengimplementasikan Early Stopping, kami akan membiarkan itu sebagai tugas untuk Anda. Jika
membutuhkan bantuan, Early Stopping dipelajari secara mendetail dan dengan aktivitas praktis dalam Deep Learning di
DSA, tidak ada kursusDeep Learning II.

Sampai chapter berikutnya!

Bab 29–Menentukan Ukuran Mini-
Batch

Ketika data pelatihan dibagi menjadi beberapa batch kecil, setiap batch disebut Mini-Batch
(atau Mini-Lote). Anggaplah bahwa data pelatihan memiliki 32.000 instansi dan bahwa ukuran dari satu
Mini-Batch ditetapkan sebagai 32. Jadi, akan ada 1.000 Mini-Batch. Tapi berapa ukuran yang harusnya
Mini-Batch? Inilah yang akan kita bahas di bab ini: Menentukan Ukuran Mini-Batch.

Tapi mengapa kita menggunakan Mini-Batches? Misalkan Anda memiliki sekitar 1 miliar data pelatihan. Jika
Anda memutuskan untuk menggunakan seluruh set pelatihan di setiap epoch, Anda akan membutuhkan banyak memori.
RAM dan penyimpanan untuk memproses data ini, sangat mungkin bahwa mesin Anda (atau bahkan
umkluster komputer) tidak memiliki cukup memori. Jika Anda memutuskan untuk menggunakan sebuah contoh dari
pelatihan di setiap era, satu miliar data, sekaligus, Anda mengabaikan filosofi
vetorisasi dan ini akan membuat proses pelatihan jauh lebih lambat.

Oleh karena itu, kami menggunakan subset dari data pelatihan (kami sebut "Mini-Batch") satu per satu
setiap era. Ini akan memungkinkan kita untuk menjaga dua tujuan: menyesuaikan data yang cukup dalam memori
komputer dan mempertahankan filosofi vektorisasi pada saat yang sama. Satu hal yang penting tentang Mini-Batch
adalah bahwa, lebih baik memilih ukuran Mini-Batch sebagai kelipatan dari 2 dan nilai-nilai umum adalah: 64, 128,
256 dan 512. Silakan menggunakan nilai lain dan kita akan membahas lebih lanjut tentang ini kemudian di sini.
bahkan di bab ini.

Lihat contoh: katakanlah Anda memiliki 1 miliar data pelatihan. Anda menetapkan ukuran Anda
Mini-Batch yaitu, katakanlah, 512. Jadi, di setiap epoch Anda memiliki 512 data pelatihan untuk diproses.
Konfigurasi ini akan memakan waktu sekitar: ([Link] / 512) = 1.953.125 epoch untuk diselesaikan.
Oleh karena itu, ukuran Mini-Batch adalah jumlah data yang ingin Anda proses dalam setiap epoch.

Jika kita memperbarui parameter model setelah memproses semua data pelatihan (yaitu,
epoca), akan memakan waktu yang lama untuk mendapatkan pembaruan model dalam pelatihan, dan data dari
Pelatihan integer kemungkinan tidak muat di memori. Jika kita memperbarui parameter model
setelah pemrosesan setiap instance (misalnya, penurunan gradien stokastik), pembaruan dari
model akan terlalu bising dan prosesnya tidak akan efisien secara komputasi.

Oleh karena itu, penggunaan Mini-Batch (terutama dalam penurunan gradien) diperkenalkan sebagai sebuah trade-off
off antara {pembaruan cepat model, efisiensi memori} dan {pembaruan akurat model,
efisiensi komputasi}. Adalah tugas dariScientist Datamenyesuaikan lebih banyak parameter ini dalam proses
pelatihan.

Namun, bagaimana kita harus menentukan ukuran mini-

Batch?
Untuk menjawab pertanyaan ini, mari kita pertama-tama berasumsi bahwa kita sedang melakukan pembelajaran daring, yaitu,
yang sedang kita gunakan adalah ukuran Mini-Batch sama dengan 1.

Kekhawatiran yang jelas tentang pembelajaran online adalah bahwa penggunaan Mini-Batch yang hanya berisi satu
contoh pelatihan akan menyebabkan kesalahan signifikan dalam estimasi gradien kami. Alasannya adalah bahwa
Estimasi individu bertahap tidak harus sangat akurat. Yang kita butuhkan hanyalah sebuah estimasi.
cukup tepat agar fungsi biaya kita terus menurun. Ini seperti Anda mencoba
sampai ke Kutub Utara, tetapi memiliki kompas yang memberi tahu 10 hingga 20 derajat setiap kali Anda melihatnya
ela. Se você berhenti untuk memeriksa kompas secara teratur, dan kompas mengarah dengan benar, Anda pada akhirnya akan
sampai di Kutub Utara.

Berdasarkan argumen ini, sepertinya kita harus menggunakan pembelajaran daring. Faktanya, situasinya menjadi
lebih rumit dari itu. Dalam sebuah masalah dariterakhirbab, kami menunjukkan bahwa adalah mungkin untuk menggunakan teknik
dari matriks untuk menghitung pembaruan gradien untuk semua contoh dalam Mini-Batch
secara bersamaan, alih-alih melakukan loop di atasnya. Bergantung pada detail perangkat keras Anda dan
perpustakaan darialjabar linier, podakan sedikit lebih cepat untuk menghitung estimasi gradien untuk Mini-
Lote sebesar (misalnya) ukuran 100, alih-alih menghitung estimasi gradien Mini-Lote dengan cara
loop tentang 100 contoh pelatihan secara terpisah. Ini mungkin memakan waktu (katakanlah) hanya 50 kali lebih lama
tempo, bukan 100 kali lebih lama.
Sekarang, pada awalnya, tampaknya ini tidak banyak membantu kita. Dengan Mini-Lot kita yang berukuran 100, aturannya
pembelajaran untuk bobot tampak seperti:

di mana penjumlahan adalah tentang contoh pelatihan dalam Mini-Batch. Ini setara dengan:

untuk pembelajaran online. Meskipun memerlukan waktu 50 kali lebih lama untuk melakukan pembaruan Mini-Batch, masih
sepertinya lebih baik melakukan pembelajaran secara online, karena kami akan selalu memperbarui dengan lebih sering.
Namun, anggaplah bahwa dalam kasus Mini-Lot kita meningkatkan laju pembelajaran sebesar faktor 100,
maka aturan pembaruan menjadi:

Ini mirip dengan 100 instance pembelajaran online terpisah dengan laju pembelajaran
η. Namun membutuhkan waktu 50 kali lebih lama daripada melakukan satu instance pembelajaran online.
Tentu saja, ini tidak persis sama dengan 100 contoh pembelajaran online, karena di Mini-Batch
∇Cxs semuanya dievaluasi untuk himpunan bobot yang sama, berbeda dengan pembelajaran kumulatif yang
terjadi dalam kasus daring. Meskipun demikian, tampaknya jelas mungkin bahwa penggunaan Mini-Lot yang lebih besar dapat mempercepat
hal-hal.

Dengan faktor-faktor ini dalam pikiran, memilih ukuran Mini-Lote terbaik adalah kompromi (pilihan). Sangat
kecil, dan Anda tidak bisa memanfaatkan sepenuhnya manfaat dari pustaka matriks yang baik
dioptimalkan untuk perangkat keras cepat. Terlalu besar dan Anda hanya tidak memperbarui bobot Anda
cukup sering. Yang perlu Anda lakukan adalah memilih nilai yang memaksimalkan kecepatan
pembelajaran. Untungnya, pemilihan ukuran Mini-Lot di mana kecepatan dimaksimalkan adalah
relatif independen terhadap hiperparameter lainnya (selain arsitektur umum), jadi Anda tidak
perlu mengoptimalkan hiperparameter ini untuk menemukan ukuran Mini-Lote yang baik. Jalannya ke
melalui adalah, oleh karena itu, menggunakan beberapa nilai yang dapat diterima (tetapi tidak harus ideal) untuk yang lainnya
hiperparameter, dan kemudian menguji berbagai ukuran Mini-Batch yang berbeda, menskalakan η seperti yang telah kita lakukan di
Contoh di atas. Plotkan akurasi validasi terhadap waktu (seperti dalam waktu nyata yang berlalu, bukan dalam
masa!) dan pilih ukuran Mini-Lot yang memberikan perbaikan tercepat dalam kinerja. Dengan
ukuran Mini-Lote yang dipilih, Anda dapat terus mengoptimalkan hiperparameter lainnya. Apakah Anda mengerti sekarang
mengapaIlmuwan Dataharus menerima imbalan yang sangat baik?

Tentu saja, seperti yang Anda pasti sadari, kami tidak melakukan optimasi ini di jaringan contoh kami (yang Anda
temukan diGithub). Faktanya, implementasi kami tidak menggunakan pendekatan tercepat untuk pembaruan
Mini-Batch. Kami hanya menggunakan ukuran Mini-Lot sebesar 10 tanpa komentar atau penjelasan.
hampir semua contoh. Karena itu, kita bisa mempercepat pembelajaran dengan mengurangi ukuran
Mini-Lote. Kami tidak melakukan ini, sebagian karena kami ingin menggambarkan penggunaan Mini-Lote selain ukuran 1, dan
Sebagian karena eksperimen awal kami menunjukkan bahwa percepatan akan cukup modest, sebuah
ketika jaringan contoh kita cukup sederhana. Dalam implementasi praktis, bagaimanapun, pasti
kami akan menerapkan pendekatan tercepat untuk pembaruan Mini-Batch dan kemudian kami akan melakukan
usaha untuk mengoptimalkan ukuran Mini-Lot, agar dapat memaksimalkan kecepatan keseluruhan kami.

Di kursus kamiPelatihan Kecerdasan Buatan, siswa bekerja dengan Mini-Batches karena dataset
yang digunakan sangat besar dan kita perlu mengoptimalkan waktu pelatihan. Semua siswa dari Pelatihan memiliki
akses jarak jauh gratis ke super server DSA dengan dua GPU dan kami mengajarkan cara mengoptimalkan pelatihan
dan menggunakan sumber daya komputer secara efisien. Penentuan Mini-Batch adalah salah satu aktivitas
utama. Akses program lengkap kursus di sini:Pembentukan Kecerdasan Buatan e comece sua
pelatihan hari ini juga.
Bab 30–Variasi dari Gradient Stochastic
Optimisasi Descent-Hessian dan Momentum

Setiap teknik yang ditunjukkan hinggadi siniitu berharga dan harus dikuasai oleh mereka yang berniat untuk bekerja dengan
jaringan saraf buatan dan aplikasi Kecerdasan Buatan, tetapi ini bukanlah satu-satunya alasan mengapa kami
Kami menjelaskan. Poin utama adalah membiasakan Anda dengan beberapa masalah yang dapat terjadi di jaringan.
neural dan dengan gaya analisis yang dapat membantu mengatasi masalah ini. Dengan cara tertentu, kita belajar untuk
berpikir tentang jaringan saraf. Sekarang di bab ini, kami merangkum secara singkat beberapa teknik lainnya.
Sketsa-sketsa ini kurang mendalam dibandingkan diskusi sebelumnya, tetapi harus menyampaikan beberapa
sentimen terhadap keberagaman teknik yang tersedia untuk digunakan dalam jaringan saraf. Ingat bahwa Anda selalu
Anda dapat mempelajari semua teknik ini secara rinci di kursus dariPembentukan Kecerdasan Buatan.

Variasi dari Stochastic Gradient Descent

Penurunan gradien stokastik melalui backpropagation telah membantu kami dalam menyerang masalah
klasifikasi digit dari dataset MNIST. Namun, ada banyak pendekatan lain untuk mengoptimalkan
fungsi biaya dan, kadang-kadang, pendekatan lain ini menawarkan kinerja yang lebih baik daripada gradien stokastik
di mini-lot. Di bab ini kita akan membahas dua pendekatan tersebut, Optimasi Hessian dan Momentum.

Optimisasi Hessian
Untuk memulai diskusi kita, ada baiknya untuk menyisihkan jaringan saraf untuk sementara. Sebagai gantinya, mari kita
hanya mempertimbangkan masalah abstrak untuk meminimalkan fungsi biaya C yang merupakan fungsi dari banyak
variabel, w = w1, w2, ... , maka C = C(w). Berdasarkan teorema Taylor, fungsi biaya dapat diperkirakan
dekat dengan titik w oleh:

Formula 1

Kita bisa menulis ulang ini dengan cara yang lebih ringkas:
 Formula 2

di mana∇C adalah vektor gradien biasa dan H adalah matriks yang dikenal sebagai Matriks Hessian. Misalkan kita
kita mendekati C dengan mengabaikan istilah orde lebih tinggi yang diwakili oleh … di atas:

Formula 3

Dengan menggunakan perhitungan, kita dapat menunjukkan bahwa ekspresi di sisi kanan dapat diminimalkan dengan memilih:

Formula 4

Mengingat bahwa Formula 3 adalah representasi yang baik untuk fungsi biaya, maka kami berharap bahwa

perubahan titik w menjadi deva berkurang

secara signifikan fungsi biaya. Ini menunjukkan algoritma yang mungkin untuk meminimalkan biaya:

Pilih sebuah titik awal, w.

Perbarui w menjadi titik baru w ′ = w − H ^ − 1∇C, di mana Hessian H dan∇C dihitung dalam w.
Perbarui w′ ke titik baru w′′ = w′ − H′ ^ − 1 ∇′C, di mana Hessian H′ dan ∇'C dihitung dalam w'.
…

Dalam praktiknya, Formula 3 hanyalah sebuah pendekatan dan lebih baik mengambil langkah yang lebih kecil. Kami melakukan ini dengan mengubah

berulang kali w untuk suatu jumlah onde η é conhecido

sebagai tingkat pembelajaran.
Pendekatan ini untuk meminimalkan fungsi biaya dikenal sebagai Teknik Hessian atau Hessian
Optimisasi. Ada hasil teoretis dan empiris yang menunjukkan bahwa metode Hessian konvergen di
sebuah minimum dalam lebih sedikit langkah daripada penurunan gradien standar. Secara khusus, dengan menggabungkan
informasi tentang perubahan urutan kedua pada fungsi biaya, mungkin pendekatan Hessian
hindari banyak patologi yang dapat terjadi pada penurunan gradien. Selain itu, ada versi algoritma dari
retropropagasi yang dapat digunakan untuk menghitung Hessian.

Se a Hessian Optimization é tão bom, por que não a estamos usando em nossas redes neurais? Infelizmente,
meskipun memiliki banyak sifat yang diinginkan, memiliki satu sifat yang sangat tidak diinginkan: sangat sulit untuk
menerapkan dalam praktik. Sebagian dari masalah adalah ukuran matriks Hessian. Misalkan Anda memiliki jaringan
neural com 107 pesos e vieses. Em seguida, a matriz Hessiana correspondente conterá 107 × 107 = 1014
masukan. Ini adalah jumlah besar masukan! Dan ini membuat perhitungan H ^ − 1∇C sangat sulit
dalam praktiknya. Namun, itu tidak berarti bahwa tidak berguna untuk memahami. Sebenarnya, ada banyak variasi dalam penurunan
de gradiente yang terinspirasi oleh Optimisasi Hessian, tetapi menghindari masalah dengan matriks
terlalu besar. Mari kita lihat salah satu teknik ini, penurunan gradien berbasis
Momentum.

Momentum
Secara intuitif, keuntungan dari Optimisasi Hessian adalah bahwa ia menggabungkan tidak hanya informasi tentang
gradien, tetapi juga informasi tentang bagaimana gradien berubah. Penurunan gradien berbasis
Momentum didasarkan pada intuisi yang serupa, tetapi menghindari matriks besar dari turunan kedua. Untuk
memahami teknik Momentum, pikirkan tentang gambar asli kita tentang penurunan gradien, di mana
kita mempertimbangkan sebuah bola yang bergulir di lembah (lihat gambar di bawah). Kita mengamati bahwa penurunan gradien adalah,
meskipun namanya, hanya sedikit mirip dengan bola jatuh ke dasar lembah.

Teknik Momentum memodifikasi penurunan gradien dengan dua cara yang membuatnya lebih mirip dengan
gambar fisik. Pertama, memperkenalkan suatu pengertian 'kecepatan' untuk parameter yang sedang kita coba
mengoptimalkan. Gradien berfungsi untuk mengubah kecepatan, bukan (secara langsung) “posisi”, dengan cara yang sama bahwa
gaya fisik mengubah kecepatan, hanya mempengaruhi posisi secara tidak langsung. Kedua, metodenya
Momentum memperkenalkan sejenis istilah gesekan, yang cenderung mengurangi kecepatan secara bertahap.

Mari kita memberikan deskripsi matematis yang lebih tepat. Kami memperkenalkan variabel kecepatan v = v1, v2,…
satu untuk setiap variabel wj yang bersangkutan. Jadi kami mengganti aturan pembaruan penurunan
gradien w → w′ = w − η∇C oleh:

Dalam persamaan ini, μ adalah hiperparameter yang mengontrol jumlah redaman atau gesekan dalam sistem.
Untuk memahami arti dari persamaan, berguna untuk terlebih dahulu mempertimbangkan kasus di mana μ = 1, yang sesuai dengan
tidak ada gesekan. Ketika ini terjadi, pemeriksaan terhadap persamaan menunjukkan bahwa "gaya"∇C sekarang
mengubah kecepatan, v, dan kecepatan mengontrol laju perubahan w. Secara intuitif, kita
kami meningkatkan kecepatan dengan menambahkan istilah gradien secara berulang-ulang ke dalamnya. Ini berarti jika
gradasi berada di (perkiraan) arah yang sama melalui beberapa putaran pembelajaran,
kita bisa mengembangkan sedikit uap bergerak ke arah itu. Pikirkan, misalnya, tentang apa yang terjadi
jika kita bergerak langsung melalui kemiringan:

Setiap langkah kecepatannya menjadi lebih besar di tanjakan, jadi kami bergerak semakin cepat menuju
dasar lembah. Ini dapat memungkinkan teknik Momentum bekerja jauh lebih cepat daripada
penurunan gradien standar. Tentu saja, satu masalah adalah bahwa, begitu kita sampai di dasar lembah, kita akan
ultrapassar. Atau, jika gradien harus berubah dengan cepat, maka kita bisa bertemu pergi ke arah
Kesalahan. Inilah alasan untuk hiperparameter µ dalam persamaan di atas.

Saya telah mengatakan sebelumnya bahwa μ mengontrol jumlah gesekan dalam sistem; untuk menjadi sedikit lebih tepat,
anda harus memikirkan 1 − μ sebagai jumlah gesekan dalam sistem. Ketika μ = 1, seperti yang kita lihat, tidak ada gesekan
kecepatan sepenuhnya dikendalikan oleh gradien∇C. Sebaliknya, ketika μ = 0 ada banyak gesekan, a
kecepatan tidak dapat terakumulasi dan persamaan di atas menyusut menjadi persamaan biasa untuk gradien
turunan, w → w ′ = w − η∇C. Dalam praktiknya, menggunakan nilai perantara antara 0 dan 1 dapat memberikan kita banyak dari
manfaat dapat meningkatkan kecepatan, tetapi tanpa menyebabkan overshooting. Kita dapat memilih sebuah nilai
para μ menggunakan data validasi yang ditahan, dengan cara yang sama seperti kita memilih η dan λ. Teknik ini adalah
dipelajari secara rincidisini.

Saya menghindari menyebutkan hiperparameter μ sejauh ini. Alasannya adalah bahwa nama standar untuk μ dipilih dengan buruk: itu adalah
disebut sebagai koefisien momentum. Ini berpotensi membingungkan, karena μ sama sekali tidak
noção momen fisika. Sebaliknya, itu lebih terkait dengan gesekan. Namun, istilah
koefisien momentum sangat banyak digunakan, oleh karena itu kami akan terus menggunakannya.

Satu hal baik tentang teknik Momentum adalah bahwa tidak diperlukan hampir tidak ada pekerjaan untuk memodifikasinya.
sebuah implementasi penurunan gradien untuk menggabungkan Momentum. Kita masih bisa menggunakan
retropropagasi untuk menghitung gradien, seperti sebelumnya, dan menggunakan ide-ide seperti sampling mini-
lottes yang dipilih secara stokastik. Dengan cara ini, kita dapat memperoleh beberapa keuntungan dari Hessian
Optimasi, menggunakan informasi tentang bagaimana gradien berubah, tetapi tanpa kerugian dan dengan
hanya sedikit modifikasi pada kode kami. Dalam praktiknya, teknik Momentum umumnya digunakan dan,
seringkali, mempercepat pembelajaran.
Sampai jumpa di bab selanjutnya!
Bab 31–Jaringan Saraf Tiruan
Dapatkah Menghitung Fungsi Apa Pun?

Salah satu fakta yang paling mengesankan tentang jaringan saraf adalah bahwa mereka dapat menghitung fungsi apa pun. Artinya,
anggaplah ada seseorang yang memberikan Anda fungsi rumit, f(x):

Tidak peduli apa pun fungsinya, dipastikan ada jaringan saraf sehingga, untuk setiap masukan
kemungkinan, x, nilai f(x) (atau beberapa pendekatan) akan dikirim dari jaringan, misalnya:

Hasil ini tetap berlaku meskipun fungsi memiliki banyak masukan, f = f(x1,…, xm) dan banyak keluaran. Oleh karena itu
contoh, ini adalah jaringan yang menghitung fungsi dengan m = 3 masukan dan n = 2 keluaran:
Hasil ini memberi tahu kita bahwa jaringan saraf memiliki jenis universalitas. Tidak peduli fungsi mana
kami ingin menghitung, kami tahu ada jaringan saraf yang dapat melakukan pekerjaan tersebut.

Selain itu, teorema universalitas ini berlaku bahkan jika kita membatasi jaringan kita hanya untuk memiliki
satu lapisan perantara antara neuron input dan output - yang disebut lapisan tersembunyi
unik. Oleh karena itu, bahkan arsitektur jaringan yang sangat sederhana dapat menjadi sangat kuat dan ini membantu
menjelaskan mengapa jaringan saraf digunakan dalam aplikasi canggih Kecerdasan Buatan.

Teorema universalitas sangat dikenal oleh orang-orang yang menggunakan jaringan saraf. Tetapi mengapa itu benar
tidak begitu dipahami secara luas. Sebagian besar penjelasan yang tersedia cukup teknis. Oleh
contoh, salah satu artikel asli yang membuktikan hasilnya menggunakan teorema Hahn-Banach,
teorema representasi Riesz dan analisis Fourier. Jika Anda seorang matematikawan, argumen tersebut tidak
sulit diikuti, tetapi tidak begitu mudah bagi kebanyakan orang. Sangat disayangkan, karena alasan yang mendasari
universalisme itu sederhana dan indah.

Di bab-bab berikutnya, kami akan memberikan penjelasan yang sederhana dan terutama visual tentang teorema dari
universalitas. Kami akan melangkah langkah demi langkah melalui ide-ide utama. Anda akan memahami mengapa itu benar bahwa
jaringan saraf dapat menghitung fungsi apapun. Anda akan memahami beberapa batasan dari hasilnya. Dan
Anda akan memahami bagaimana hasilnya terkait dengan jaringan saraf dalam (Deep Learning).

Bab-bab akan disusun agar menyenangkan dan objektif. Asalkan Anda hanya memiliki sedikit saja dari
pengetahuan dasar tentang jaringan saraf, Anda harus dapat mengikuti penjelasannya. Namun, kami akan
menyediakan tautan sesekali ke materi sebelumnya, untuk membantu mengisi kekurangan yang ada dalam Anda
pengetahuan.

Teorema universalitas adalah hal yang umum dalam ilmu komputer, hingga kadang-kadang kita
kita melupakan betapa mengagumkannya mereka. Tetapi patut diingat: kemampuan untuk menghitung sebuah
fungsi arbitrer benar-benar luar biasa. Hampir setiap proses yang dapat Anda bayangkan bisa jadi
dikenal sebagai komputasi fungsi. Pertimbangkan masalah menamai sebuah karya musik berdasarkan
sebuah contoh kecil dari bagian tersebut. Ini dapat dipikirkan sebagai perhitungan suatu fungsi. Atau pertimbangkan
masalah menerjemahkan teks Cina ke dalam bahasa Inggris. Sekali lagi, ini dapat dipikirkan sebagai komputasi
dari sebuah fungsi. Atau pertimbangkan masalah menganalisis file film mp4 dan menghasilkan deskripsi dari
sinopsis film dan diskusi tentang kualitas akting para aktor. Sekali lagi, ini dapat dipikirkan
sebagai sejenis komputasi fungsi. Universalitas berarti bahwa, secara prinsip, jaringan saraf dapat
melakukan semua ini dan lebih banyak lagi.

Tentu saja, hanya karena kita tahu bahwa ada jaringan saraf yang dapat (misalnya) menerjemahkan teks Tiongkok ke
Dalam bahasa Inggris, ini tidak berarti bahwa kita memiliki teknik yang baik untuk membangun atau bahkan mengenali jaringan semacam itu. Ini
limitation also applies to traditional universality theorems for models such as circuits
boolean. Namun, seperti yang kita lihat sebelumnya di buku, jaringan syaraf memiliki algoritma yang kuat untuk
fungsi pembelajaran. Kombinasi algoritma pembelajaran + universalitas adalah campuran
menarik. Sampai sekarang, buku ini telah fokus pada algoritma pembelajaran. Di bab-bab berikutnya, kami
kami memfokuskan pada universalisme dan apa artinya.

Pemahaman tentang konsep ini adalah kunci untuk arsitektur Deep Learning yang lebih maju, yang sedang
por vir mais a frente, neste livro!
Bab 32–Bagaimana Sebuah Jaringan Saraf
Kecerdasan Buatan Menemukan Pendekatan Sebuah
Fungsi

Ini adalah bab yang sangat penting untuk memahami bagaimana jaringan saraf sebenarnya bekerja dan
Sebuah Jaringan Saraf Buatan Menemukan Pendekatan Sebuah Fungsi. Ikuti penjelasan langkah demi langkah.
Saya akan menganalisis setiap grafik yang disajikan.

Sebelum menjelaskan mengapa teorema universalitas itu benar, saya ingin menyebutkan dua peringatan.
pernyataan informal ini: "jaringan saraf dapat menghitung fungsi apa pun", yang kita lihat di
babanterior.
Pertama, ini tidak berarti bahwa sebuah jaringan dapat digunakan untuk menghitung dengan tepat fungsi apa pun. Sebagai gantinya
Dengan ini, kita dapat memperoleh pendekatan yang sebaik yang kita inginkan. Meningkatkan jumlah
neurônios ocultos, podemos melhorar a aproximação. Por exemplo, anteriormente ilustramos uma rede
menghitung suatu fungsi f(x) menggunakan tiga neuron tersembunyi. Untuk sebagian besar fungsi, hanya satu
aproximação dari kualitas rendah akan memungkinkan menggunakan tiga neuron tersembunyi. Dengan meningkatkan jumlah
neurons tersembunyi (katakanlah, untuk lima), kita dapat memperoleh pendekatan yang lebih baik:

Dan kita dapat meningkatkan lebih lanjut dengan menambah jumlah neuron tersembunyi.

Untuk membuat pernyataan ini lebih tepat, anggaplah kita memiliki fungsi f(x) yang ingin kita
menghitung dengan beberapa ketelitian yang diinginkan ϵ > 0. Jaminannya adalah bahwa menggunakan neuron tersembunyi yang cukup selalu
kita dapat menemukan jaringan saraf yang outputnya g(x) memenuhi | g(x)− f(x) | < ϵ, untuk semua input x. Dalam
Dengan kata lain, pendekatannya akan baik dalam batas ketepatan yang diinginkan untuk setiap input yang mungkin.

Peringatan kedua adalah bahwa kelas fungsi yang dapat didekati dengan cara yang dijelaskan adalah fungsi
terus-menerus. Jika suatu fungsi tidak kontinu, yaitu, melakukan lompatan yang tiba-tiba dan mendadak, maka, secara umum, tidak akan
mungkin dapat mendekati menggunakan jaringan saraf. Ini tidak mengejutkan, karena jaringan saraf kita menghitung
fungsi kontinu dari masukan Anda. Namun, meskipun fungsi yang sebenarnya ingin kami hitung
fosse diskontinu, sering kali pendekatan kontinu cukup baik. Jika demikian, maka kita bisa menggunakan
sebuah jaringan saraf. Dalam praktiknya, ini biasanya bukan batasan yang penting.

Singkatnya, pernyataan yang lebih tepat dari teorema universalitas adalah bahwa jaringan saraf dengan satu
lapisan tersembunyi dapat digunakan untuk mendekati fungsi kontinu apa pun dengan akurasi yang diinginkan.
Di sini dan di bab berikutnya, kita akan membuktikan versi dari hasil ini.

Universalitas Dengan Satu Masukan dan Satu Keluaran

Untuk memahami mengapa teorema universalitas adalah benar, mari kita mulai dengan memahami bagaimana membangun
sebuah jaringan syaraf yang mendekati sebuah fungsi dengan hanya satu input dan satu output:

Ini adalah inti dari masalah universalitas. Setelah kita memahami kasus khusus ini, itu benar-benar mudah.
memperluas untuk fungsi dengan banyak input dan banyak output (topik bab berikutnya).
Untuk membangun wawasan tentang bagaimana membangun jaringan untuk menghitung f, mari kita mulai dengan sebuah jaringan
mengandung hanya satu lapisan tersembunyi, dengan dua neuron tersembunyi dan satu lapisan keluaran yang mengandung satu
neurônio de saída:

Untuk mendapatkan gambaran tentang bagaimana komponen jaringan berfungsi, mari kita fokus pada neuron tersembunyi.
superior. Diagrams di bawah, dengan meningkatkan nilai w, kita dapat segera melihat bagaimana fungsi
dihitung oleh neuron tersembunyi atas berubah:
Seperti yang kita pelajari sebelumnya di buku, apa yang dihitung oleh neuron tersembunyi adalah σ(wx + b),
onde σ(z) ≡ 1 / (1 + e^-z) é a função sigmóide. Até agora, fizemos uso frequente dessa forma algébrica. Mas,
untuk bukti universalitas, kita akan mendapatkan lebih banyak kebijaksanaan dengan sepenuhnya mengabaikan aljabar dan, sebagai ganti
disso, manipulando dan mengamati bentuk yang ditunjukkan pada grafik. Ini tidak hanya akan memberikan kita gambaran yang lebih baik
apa yang sedang terjadi, tetapi juga akan memberi kita sebuah bukti universalitas yang berlaku untuk fungsi lainnya
de ativação yang bukan fungsi sigmóide.
Untuk memulai ujian ini, kita bisa meningkatkan bias, b, pada diagram di atas. Anda akan melihat bahwa, seiring dengan bias
meningkat, grafik bergerak ke kiri, tetapi bentuknya tidak berubah.

Selanjutnya, kita dapat mengurangi bias. Anda akan melihat bahwa seiring dengan berkurangnya bias, grafik bergerak ke
ke kanan, tetapi, sekali lagi, bentuknya tidak berubah. Kemudian, kita mengurangi beban menjadi sekitar 2 atau 3. Anda
anda akan melihat bahwa seiring dengan berkurangnya berat, kurva menjadi lebih panjang. Mungkin perlu untuk mengubah bias juga, untuk
menjaga kurva di bingkai.

Akhirnya, kami menaikkan berat di atas w = 100. Kurva menjadi lebih curam, sampai akhirnya, itu
mulai tampak seperti fungsi langkah (Step Function). Gambar berikut menunjukkan seperti apa hasilnya:
Kita bisa menyederhanakan analisis kita sedikit dengan meningkatkan bobot agar keluaran benar-benar menjadi Step.
Fungsi, untuk pendekatan yang sangat baik. Di bawah ini saya memplot keluaran dari neuron tersembunyi atas ketika yang
berat adalah w = 999.

Sebenarnya, agak lebih mudah bekerja dengan fungsi langkah daripada dengan fungsi sigmoid umum.
alasan adalah bahwa, di lapisan output, kita menjumlahkan kontribusi dari semua neuron tersembunyi. Mudah untuk menganalisis
penjumlahan beberapa fungsi langkah, tetapi lebih sulit untuk memikirkan tentang apa yang terjadi ketika Anda menambahkan banyak
dari kurva berbentuk sigmoid. Dan dengan demikian membuat segala sesuatu jauh lebih mudah untuk diasumsikan bahwa neuron kita
tersembunyi sedang mengeluarkan fungsi langkah. Lebih tepatnya, kami melakukan ini dengan menetapkan berat w sebagai
nilai sangat besar dan kemudian menentukan posisi langkah dengan memodifikasi bias. Jelas bahwa menangani keluaran
karena fungsi langkah adalah suatu pendekatan, tetapi itu adalah pendekatan yang sangat baik dan, untuk sementara, kita akan memperlakukannya
makan seperti yang tepat. Saya akan kembali nanti untuk membahas dampak penyimpangan dari pendekatan ini.

Pada nilai x berapa tahap terjadi? Dengan kata lain, bagaimana posisi tahap bergantung pada berat dan bias?
Untuk menjawab pertanyaan ini, kita dapat memodifikasi bobot dan bias di diagram di atas. Apakah Anda bisa
menemukan bagaimana posisi langkah bergantung pada w dan b. Dengan sedikit usaha, Anda harus dapat melakukannya.
meyakinkan bahwa posisi tahap berbanding lurus dengan b dan berbanding terbalik dengan w.
Sebenarnya, langkahnya ada pada posisi s = −b / w, seperti yang dapat Anda lihat dengan memodifikasi bobot dan bias di
diagrama berikut:

Ini akan sangat menyederhanakan hidup kita untuk menggambarkan neuron tersembunyi hanya dengan satu parameter,
s, yang merupakan posisi langkah, s = -b / w.

Seperti yang disebutkan di atas, kami secara implisit mendefinisikan bobot w pada input sebagai nilai besar–
cukup besar agar fungsi langkah menjadi pendekatan yang baik. Kita dapat dengan mudah mengonversi
sebuah neuron yang diparameterisasi dengan cara ini kembali ke model konvensional, memilih bias b = -ws.

Sampai sekarang, kita telah fokus pada output hanya dari neuron tersembunyi yang lebih tinggi. Mari kita lihat
perilaku seluruh jaringan. Secara khusus, mari kita anggap bahwa neuron tersembunyi sedang mengcomputasi
fungsi langkah yang diparameterkan oleh titik langkah s1 (neuron atas) dan s2 (neuron bawah). Dan
mereka akan memiliki bobot output masing-masing w1 dan w2. Berikut adalah jaringannya:

Apa yang dipetakan di sebelah kanan adalah keluaran berbobot w1a1 + w2a2 dari lapisan tersembunyi. Di sini, a1 dan a2 adalah
keluaran dari neuron tersembunyi atas dan bawah, masing-masing. Keluaran ini sering kali
dikenal sebagai aktivasi neuron.
Kita dapat meningkatkan atau mengurangi titik langkah s1 dari neuron tersembunyi atas dan itu memberi kita gambaran mengenai
bagaimana ini mengubah keluaran terpilih dari lapisan tersembunyi. Penting untuk memahami apa yang terjadi ketika s1
lewati s2. Anda akan melihat bahwa grafik berubah bentuk ketika ini terjadi, saat kita bergerak dari satu
situasi di mana neuron tersembunyi atas adalah yang pertama diaktifkan untuk situasi di mana neuron
tersembunyi di bagian bawah adalah yang pertama diaktifkan.

Dengan cara yang sama, kita dapat memanipulasi titik langkah s2 dari neuron tersembunyi di bagian bawah dan memiliki sebuah
ide tentang bagaimana ini mengubah keluaran gabungan dari neuron tersembunyi.

Akhirnya, kita dapat mendefinisikan w1 sebagai 0,8 dan w2 sebagai −0,8. Anda menerima fungsi "bump", yang dimulai
tidak pada titik s1, berakhir di titik s2 dan memiliki tinggi 0.8. Misalnya, keluaran berbobot bisa seperti ini:
Tentu, kita dapat mengubah ukuran bump untuk memiliki tinggi yang berbeda. Mari kita gunakan satu parameter, h, untuk
tunjukkan tingginya. Untuk mengurangi kebingungan, saya juga akan menghapus notasi "s1 = ..." dan "w1 = ...".

Kita dapat mengubah nilai h ke atas dan ke bawah, untuk melihat bagaimana tinggi tonjolan berubah.

Anda akan memperhatikan, kebetulan, bahwa kami menggunakan neuron kami dengan cara yang tidak dapat dianggap sebagai
hanya dalam istilah grafis, tetapi dalam istilah pemrograman yang lebih konvensional, seperti semacam
pernyataan if-then-else, misalnya:
Sebagian besar saya akan tetap dengan sudut pandang grafis. Namun, pada bagian berikut, terkadang Anda mungkin menemukan
berguna untuk bertukar sudut pandang dan berpikir tentang sesuatu dalam istilah jika-maka-jika-tidak (salah satu dasar dari
pemrograman konvensional).
Kita bisa menggunakan trik kita untuk membuat bump untuk mendapatkan dua tonjolan, dengan mencolokkan dua pasangan neuron.
tersembunyi dalam jaringan yang sama:

Saya menghapus bobot di sini, hanya dengan menuliskan nilai h untuk setiap pasangan neuron tersembunyi.
Dengan cara yang lebih umum, kita dapat menggunakan ide ini untuk mendapatkan sebanyak mungkin puncak yang kita inginkan, dari mana saja.
altura. Khususnya, kita bisa membagi interval [0,1] menjadi sejumlah besar, N, subinterval, dan menggunakan N
pasangan neuron tersembunyi untuk mengatur puncak dengan ketinggian yang diinginkan. Mari kita lihat bagaimana ini berfungsi
para N = 5. Maaf atas kompleksitas diagram di bawah ini (saya bisa menyembunyikan kompleksitas
mengabstraksikan lebih jauh, tetapi saya rasa ada baiknya menambahkan sedikit kompleksitas, untuk mendapatkan ide yang lebih
konkret tentang bagaimana jaringan ini berfungsi):
Anda dapat melihat bahwa ada lima pasangan neuron tersembunyi. Titik-titik yang terukur untuk masing-masing
pasangan neuron adalah 0,1 / 5, kemudian 1 / 5,2 / 5 dan seterusnya, hingga 4 / 5,5 / 5. Nilai-nilai ini adalah tetap–
mereka membuat kita memiliki lima tonjolan yang terdistribusi secara merata di grafik.

Setiap pasangan neuron memiliki nilai h yang terkait dengannya. Ingat, koneksi keluar dari neuron memiliki
pesos h e −h (não marcados). Ao alterar os pesos de saída, estamos realmente projetando a função!

Sejalan dengan perubahan tinggi, kita dapat melihat perubahan yang sesuai pada nilai h. Dan juga ada sebuah
perubahan pada bobot keluaran yang sesuai, yaitu + h dan −h.

Dengan kata lain, kita dapat memanipulasi langsung fungsi yang muncul di grafik sebelah kanan dan melihatnya
refleksikan di nilai h di sebelah kiri.
Tapi di sini kami mempertimbangkan sebuah input dan sebuah output, yang cukup sederhana. Dengan banyak input, konsepnya adalah
dasarnya sama, tetapi kita akan membahas keunikan di bab-bab berikutnya, ketika
mendalami jaringan saraf dalam. Sampai jumpa.

Bab 33–Mengapa Jaringan Saraf

Apakah Anjing Pudding Sulit Dilatih?
Kami sekarang memulai bagian ketiga dan terakhir dari buku ini, di mana kita akan mempelajari bagaimana Deep Learning berfungsi dan
model-model utama dan arsitektur jaringan saraf dalam, dengan berbagai contoh dan aplikasi. Tapi
Pertama-tama kita harus menjawab pertanyaan berikut: Mengapa Jaringan Saraf Dalam Sulit untuk
Melatih?

Bayangkan Anda adalah seorang insinyur yang diminta untuk merancang komputer dari nol. Suatu hari, Anda sedang
bekerja di kantornya, merancang sirkuit logika, menetapkan gerbang AND dan OR, dan seterusnya
Diante, ketika bos Anda datang dengan kabar buruk. Klien baru saja menambahkan persyaratan desain.
menakjubkan: sirkuit untuk komputer utuh hanya harus memiliki dua lapisan kedalaman:

Anda terkejut dan berkata kepada atasan Anda: "Klien itu gila!"

Atasan Anda menjawab: "Saya pikir mereka juga gila. Tapi kita perlu memenuhi persyaratan ini."

Sebenarnya, ada makna terbatas di mana pelanggan tidak gila. Misalkan Anda memiliki izin untuk
menggunakan gerbang logika khusus yang memungkinkan Anda menerapkan AND (kata "dan" dalam logika) dan menggabungkan sejumlah input
mengharapkan. Dan Anda juga diizinkan untuk sebuah gerbang NAND dengan banyak input, yaitu sebuah gerbang yang
Anda dapat menerapkan AND pada beberapa masukan dan kemudian membalikkan keluaran. Dengan pintu khusus ini, adalah mungkin untuk menghitung
fungsi apapun menggunakan sirkuit dengan hanya dua lapisan kedalaman.
Tetapi hanya karena sesuatu itu mungkin, bukan berarti itu adalah ide yang baik. Dalam praktiknya, ketika kita menyelesaikan masalah desain
sirkuit (atau hampir semua jenis masalah algoritmik), biasanya kita mulai dengan menemukan bagaimana
menyelesaikan sub-masalah, dan kemudian secara bertahap mengintegrasikan solusi. Dengan kata lain, kami menciptakan sebuah
solusi melalui berbagai lapisan abstraksi.
Misalnya, anggaplah kita sedang merancang sirkuit logika untuk mengalikan dua angka.
Kemungkinan, kita ingin membangunnya dari sub-sirkuit, melakukan operasi seperti menambahkan dua
angka. Sub-sirkuit untuk menambahkan dua angka akan, pada gilirannya, dibangun dari sub-sub-
circuitos para adicionar dois bits. Muito grosso modo, nosso circuito será parecido com:

Dengan kata lain, sirkuit akhir kami terdiri dari setidaknya tiga lapisan elemen sirkuit. Sebenarnya,
kemungkinan akan mengandung lebih dari tiga lapisan, karena kami membagi sub-tugas menjadi unit-unit yang lebih kecil daripada yang
dideskripsikan sebelumnya. Tetapi Anda memahami ide umumnya.

Jadi sirkuit dalam memfasilitasi proses desain. Namun, mereka tidak hanya berguna untuk desain.
Memang ada bukti matematis yang menunjukkan bahwa, untuk beberapa fungsi, sirkuit yang sangat dangkal
memerlukan elemen sirkuit yang jauh lebih banyak untuk dihitung dibandingkan sirkuit yang dalam.
Sebagai contoh, sebuah seri terkenal dariartikelawal 1980-an menunjukkan bahwa menghitung paritas dari sebuah
sekumpulan bit membutuhkan banyak gerbang secara eksponensial, jika dibuat dengan sirkuit permukaan. Di sisi lain
Sisi, jika Anda menggunakan sirkuit yang lebih dalam, mudah untuk menghitung paritas menggunakan sirkuit kecil: cukup
menghitung paritas dari pasangan bit, kemudian menggunakan hasil tersebut untuk menghitung paritas dari pasangan pasangan
bit dan seterusnya. membangun paritas umum dengan cepat. Sirkuit yang dalam, oleh karena itu,
dapat secara intrinsik jauh lebih kuat daripada sirkuit permukaan.

Sampai sekarang, buku ini telah membahas jaringan saraf seperti klien gila. Hampir semua jaringan yang mana
kami bekerja hanya memiliki satu lapisan tersembunyi neuron (ditambah lapisan input dan output):
Jaringan sederhana ini telah sangat berguna: di bab-bab sebelumnya, kami menggunakan jaringan seperti ini
untuk mengklasifikasikan digit tulisan tangan dengan akurasi lebih dari 98%! Namun, secara intuitif, kami berharap
bahwa jaringan dengan lebih banyak lapisan tersembunyi menjadi lebih kuat:

Jaringan semacam itu dapat menggunakan lapisan perantara untuk membangun banyak lapisan abstraksi, sehingga
seperti yang kita lakukan dalam rangkaian boolean. Sebagai contoh, jika kita sedang melakukan pengenalan pola visual,
jadi neuron dari lapisan pertama dapat belajar mengenali tepi, neuron dari lapisan kedua
lapisan dapat belajar mengenali bentuk yang lebih kompleks, katakanlah, segitiga atau persegi panjang, yang dibangun
mulai dari tepi. Lapisan ketiga akan mengenali bentuk yang lebih kompleks. Dan seterusnya. Ini
berbagai lapisan abstraksi tampaknya memberikan jaringan dalam keuntungan yang meyakinkan di
belajar untuk menyelesaikan masalah kompleks pengenalan pola. Selain itu, seperti di
dalam kasus sirkuit, ada hasil teori yang menunjukkan bahwa jaringan mendalam secara intrinsik lebih
lebih kuat daripada jaringan dangkal.
Bagaimana kita bisa melatih jaringan yang dalam ini? Di bab-bab berikutnya, kita akan mencoba melatih jaringan yang dalam.
menggunakan algoritma pembelajaran kami: turunan gradien stokastik melalui propagasi balik (yang sudah
kita telah mempelajari secara rinci di bab-bab sebelumnya, tetapi sekarang akan kita terapkan di jaringan saraf dalam.
Tapi kita akan menghadapi masalah, dengan jaringan dalam kita tidak melakukan banyak hal (jika itu memang masalahnya)
lebih baik daripada jaringan dangkal.

Kegagalan ini tampaknya mengejutkan mengingat diskusi di atas. Alih-alih menyerah pada jaringan dalam, mari kita
mendalami dan mencoba memahami apa yang menyulitkan pelatihan jaringan dalam kita. Ketika
Jika kita melihat lebih dekat, kita akan menemukan bahwa berbagai lapisan dari jaringan dalam kita sedang belajar di
kecepatan yang sangat berbeda. Khususnya, ketika lapisan belakang jaringan sedang belajar dengan baik,
lapisan awal biasanya terjebak selama pelatihan, hampir tidak belajar apa-apa. Hambatan ini
ini bukan hanya karena sial. Sebaliknya, kami akan menemukan bahwa ada alasan dasar untuk itu
lambatnya pembelajaran, terhubung dengan penggunaan teknik pembelajaran yang berbasis gradien.

Seiring kita mendalami masalah, kita akan belajar bahwa fenomena sebaliknya juga bisa terjadi:
lapisan pertama mungkin belajar dengan baik, tetapi lapisan berikutnya bisa terjebak. Di
benar, kita akan menemukan bahwa ada ketidakstabilan intrinsik yang terkait dengan pembelajaran melalui gradien
penurunan dalam jaringan saraf dalam banyak lapisan. Ketidakstabilan ini cenderung menghasilkan lapisan
sebelumnya atau setelahnya terjebak selama pelatihan.

Namun, ketika kita memusatkan perhatian pada kesulitan ini, kita bisa mulai memahami apa yang diperlukan untuk
melatih jaringan dalam secara efektif. Dan itulah yang akan kita lakukan di bab-bab berikutnya.
Sekarang adalah saatnya untuk bersenang-senang. Sampai jumpa.
Bab 34–Masalah Pemborosan
Gradien
Jadi,mengapa jaringan saraf dalam sulit dilatih?

Untuk menjawab pertanyaan ini, pertama-tama kita tinjau kasus jaringan dengan hanya satu lapisan tersembunyi.
Seperti biasa, kami akan menggunakan masalah klasifikasi digit MNIST yang sudah dipelajari sebelumnya.
bab-bab sebelumnya dan yang Anda temukan di repositori buku ini diGithub

Dari shell Python, kami memuat data MNIST:

Kami mendirikan jaringan kami:

Jaringan ini memiliki 784 neuron di lapisan input, yang sesuai dengan 28 × 28 = 784 piksel dalam gambar.
input. Kami menggunakan 30 neuron tersembunyi, serta 10 neuron output, yang sesuai dengan 10
klasifikasi yang mungkin untuk digit MNIST ('0', '1', '2',..., '9').

Mari kita coba melatih jaringan kita selama 30 epoch penuh, menggunakan mini-batch dari 10 contoh pelatihan
sekali, laju pembelajaran η = 0.1 dan parameter regularisasi λ = 5.0. Seiring dengan
kami melatih, kami memantau akurasi klasifikasi di kumpulan data validation_data. Kami bisa
jalankan skrip [Link] dengan semua perintah. Melalui prompt perintah atau terminal, kita mengetik: python
[Link] (pelatihan dapat memakan waktu banyak menit tergantung pada kecepatan komputer).
Pada akhir pelatihan, kami memperoleh akurasi klasifikasi sebesar 96,48% (sekitar), setara
a hasil sebelumnya kami dengan pengaturan serupa. Sekarang, kita akan menambahkan lapisan lain
tersembunyi, juga dengan 30 neuron, dan mencoba melatih dengan hiperparameter yang sama. Kami menggunakan:

net = [Link]([784, 30, 30, 10])

Ini memberikan akurasi klasifikasi yang lebih baik 96,90%. Ini menggembirakan: sedikit lebih dalam
sedang membantu. Mari kita tambahkan satu lapisan tersembunyi lagi dengan 30 neuron.

net = [Link]([784, 30, 30, 30, 10])

Ini tidak membantu sama sekali. Sebenarnya, hasilnya turun menjadi 96,57%, mendekati jaringan asli kami. Dan anggaplah
kita menambahkan satu lapisan tersembunyi lagi.

net = [Link]([784, 30, 30, 30, 30, 10])

Perilaku ini tampak aneh. Secara intuitif, lapisan tersembunyi tambahan seharusnya membuat jaringan mampu untuk
mempelajari fungsi klasifikasi yang lebih kompleks dan, dengan demikian, melakukan klasifikasi yang lebih baik. Tentu saja,
hal-hal tidak boleh menjadi lebih buruk, karena lapisan ekstra dapat, dalam kasus terburuk, hanya tidak melakukan apa-apa.
Tetapi itu bukan yang terjadi.
Jadi, apa yang sedang terjadi? Mari kita anggap bahwa lapisan tersembunyi tambahan benar-benar dapat membantu dalam
prinsip dan masalahnya adalah bahwa algoritma pembelajaran kami tidak menemukan bobot dan bias
benar. Kami ingin mengetahui apa yang salah dalam algoritma pembelajaran kami dan bagaimana cara memperbaikinya.
lebih baik.
Untuk memahami lebih baik apa yang salah, mari kita visualisasikan bagaimana jaringan belajar. Di bawah ini, kami menggambarkan sebagian dari
sebuah jaringan [784,30,30,10], yaitu, sebuah jaringan dengan dua lapisan tersembunyi, masing-masing berisi 30 neuron
tersembunyi. Setiap neuron dalam diagram memiliki sebuah batang kecil di dalamnya, yang mewakili kecepatan di mana
neuron sedang berubah saat jaringan belajar. Sebuah bilah besar berarti bahwa bobot dan bias dari
neuron cepat berubah, sementara sebuah batang kecil berarti bahwa bobot dan bias sedang
perubahan secara perlahan. Lebih tepatnya, garis menunjukkan gradien ∂C / ∂b untuk setiap neuron, yaitu,
tarif perubahan biaya terkait dengan bias neuron. Di bab-bab sebelumnya, kita melihat bahwa ini
jumlah gradien mengontrol tidak hanya kecepatan perubahan bias selama pembelajaran, tetapi
juga kecepatan dengan mana bobot yang dimasukkan ke dalam neuron juga berubah. Jangan khawatir jika Anda tidak se
mengingat detailnya: satu-satunya hal yang perlu diingat adalah bahwa batang ini menunjukkan kecepatan dengan
bahwa bobot dan bias setiap neuron berubah seiring dengan pembelajaran jaringan.

Untuk menjaga diagram tetap sederhana, saya hanya menunjukkan enam neuron utama di dua lapisan tersembunyi.
hapus neuron input, karena mereka tidak memiliki bobot atau bias untuk dipelajari. Saya juga menghapus
neuron keluaran, karena kita sedang membuat perbandingan per lapisan, dan lebih masuk akal untuk membandingkan lapisan
dengan jumlah neuron yang sama. Hasilnya dipetakan di awal pelatihan, yaitu,
segera setelah inisialisasi jaringan. Berikut adalah mereka:

Jaringan diinisialisasi secara acak dan, oleh karena itu, tidak mengejutkan bahwa ada banyak variasi dalam kecepatan
dengan apa neuron belajar. Meskipun demikian, satu hal yang perlu disoroti adalah bahwa batang pada kedua
camada oculta biasanya jauh lebih besar daripada bilah di lapisan tersembunyi pertama. Sebagai hasilnya,
neuron-neuron lapisan tersembunyi kedua belajar sedikit lebih cepat dibandingkan neuron-neuron lapisan pertama.
lapisan tersembunyi. Ini hanyalah kebetulan, atau neuron di lapisan tersembunyi kedua
kemungkinan mereka akan belajar lebih cepat daripada neuron di lapisan tersembunyi pertama secara umum?
Untuk menentukan apakah ini benar, berguna untuk memiliki cara global untuk membandingkan kecepatan pembelajaran di
lapisan tersembunyi pertama dan kedua. Untuk melakukan ini, kami akan menunjukkan gradien sebagai δlj = ∂C / ∂blj, yaitu,
gradien untuk neuron jth di lapisan lth.

Kita bisa menganggap gradien δ1 sebagai vektor yang entri-entrinya menentukan seberapa cepat ke pertama
lapisan tersembunyi belajar, dan δ2 sebagai vektor yang entri-entri menentukan kecepatan di mana yang kedua
lapisan tersembunyi belajar. Kemudian, kita akan menggunakan panjang vektor-vektor ini sebagai ukuran global dari
kecepatan di mana lapisan-lapisan belajar. Jadi, misalnya, panjang "δ1" mengukur
kecepatan di mana lapisan tersembunyi pertama sedang belajar, sementara panjang "δ2" mengukur
kecepatan di mana lapisan tersembunyi kedua sedang belajar.
Dengan definisi ini, dan pada konfigurasi yang sama seperti yang dipetakan di atas, kami menemukan δδ1 = 0,07… dan δδ2 =
0.31…. Ini mengonfirmasi kecurigaan kami sebelumnya: neuron di lapisan tersembunyi kedua memang ada
belajar jauh lebih cepat daripada neuron lapisan tersembunyi pertama.
Apa yang terjadi jika kita menambahkan lebih banyak lapisan tersembunyi? Jika kita memiliki tiga lapisan tersembunyi, dalam sebuah jaringan
[784,30,30,30,10], maka kecepatan belajar yang sesuai akan menjadi 0,012, 0,060 dan 0,283. Sekali lagi,
lapisan tersembunyi sebelumnya belajar jauh lebih lambat daripada lapisan tersembunyi posterior.
Misalkan kita menambahkan satu lapisan lagi dengan 30 neuron tersembunyi. Dalam hal ini, masing-masing
kecepatan belajar adalah 0,003, 0,017, 0,070, dan 0,285. Polanya valid: lapisan awal
kami belajar lebih lambat daripada lapisan-lapisan yang lebih belakang.

Kami telah mengamati kecepatan pembelajaran di awal pelatihan, yaitu segera setelah jaringan dibuat.
inicializadas. Bagaimana kecepatan pembelajaran berubah seiring dengan kita melatih jaringan kita? Mari kita kembali
untuk melihat jaringan hanya dengan dua lapisan tersembunyi. Kecepatan pembelajaran berubah sebagai berikut:
Untuk menghasilkan hasil ini, kami menggunakan penurunan gradien dalam batch dengan hanya 1.000 gambar dari
pelatihan, dilatih selama lebih dari 500 epoch. Ini sedikit berbeda dari yang biasanya kita latih di
bab sebelumnya, tetapi yang terjadi adalah penggunaan gradien stokastik dalam mini-batch memberikan hasil yang jauh lebih baik
berisik (meskipun sangat mirip, ketika Anda mengukur kebisingan). Menggunakan parameter yang kami pilih adalah sebuah
cara mudah untuk melunakkan hasil, sehingga kita bisa melihat apa yang sedang terjadi.

Dalam hal apapun, seperti yang Anda lihat, kedua lapisan mulai belajar dengan kecepatan yang sangat
berbeda (seperti yang sudah kita ketahui). Kecepatan di kedua lapisan turun sangat cepat, sebelum
memulihkan. Tetapi, meskipun segalanya, lapisan tersembunyi pertama belajar jauh lebih lambat daripada yang kedua
lapisan tersembunyi.

Dan bagaimana dengan jaringan yang lebih kompleks? Berikut adalah hasil dari eksperimen serupa, tetapi kali ini
dengan tiga lapisan tersembunyi (jaringan [784,30,30,30,10]):

Sekali lagi, lapisan tersembunyi pertama belajar jauh lebih lambat dibandingkan dengan lapisan tersembunyi.
posteriores. Finalmente, kita akan menambahkan lapisan tersembunyi keempat (sebuah jaringan [784,30,30,30,30,10]) dan melihat
apa yang terjadi ketika kita berlatih:
Sekali lagi, lapisan tersembunyi pertama belajar jauh lebih lambat daripada lapisan tersembunyi lainnya.
posteriores. Dalam hal ini, lapisan tersembunyi pertama belajar sekitar 100 kali lebih lambat
bahwa lapisan tersembunyi terakhir. Alami bahwa kita mengalami masalah dalam melatih jaringan ini sebelumnya!

Kami memiliki pengamatan penting di sini: di setidaknya beberapa jaringan saraf dalam, gradien cenderung
berkurang saat kita bergerak mundur melalui lapisan tersembunyi. Ini berarti bahwa neuron
lapisan sebelumnya belajar jauh lebih lambat dibandingkan dengan neuron di lapisan berikutnya. Dan,
meskipun kita hanya melihat ini di satu jaringan, ada alasan mendasar mengapa ini terjadi di
banyak jaringan saraf. Fenomena ini dikenal sebagai Masalah Penipisan Gradien atau
Masalah Gradien Menghilang. Ini adalah masalah yang sangat umum dan bahkan lebih nyata dalam Jaringan Syaraf
Recurrent, digunakan dalam aplikasi Pemrosesan Bahasa Alami.

Mengapa masalah dissipasi gradien terjadi? Apakah ada cara untuk menghindarinya? Dan bagaimana seharusnya kita
lidar com isso no treinamento de redes neurais profundas? Na verdade, aprenderemos rapidamente que não é
tidak terhindarkan, meskipun alternatifnya juga tidak terlalu menarik: terkadang, gradien menjadi jauh lebih besar di
lapisan sebelumnya! Masalah ini disebut ledakan gradien, dan itu bukan berita yang jauh lebih baik
dari masalah dissipasi gradien. Umumnya, dapat dilihat bahwa gradien dalam jaringan saraf
profundas adalah tidak stabil, cenderung meledak atau menghilang di lapisan sebelumnya. Ketidakstabilan ini adalah suatu
problema fundamental para o aprendizado baseado em gradiente em redes neurais profundas. É algo que
kita perlu memahami dan, jika memungkinkan, mengambil langkah-langkah untuk menyelesaikannya.

Sementara menjauh dari jaringan saraf, bayangkan bahwa kita mencoba untuk meminimalkan secara numerik
sebuah fungsi f(x) dari satu variabel. Bukankah akan menjadi berita baik jika turunan f′(x) kecil? Itu
tidak berarti bahwa kita sudah dekat dengan suatu ekstrem? Dengan cara yang sama, gradien kecil di dalam
lapisan awal dari jaringan dalam dapat berarti bahwa kita tidak perlu melakukan banyak penyesuaian bobot dan
tampak?

Tentu, itu bukanlah kasusnya. Ingatlah bahwa kami menginisialisasi bobot dan bias secara acak di jaringan.
sangat tidak mungkin bahwa bobot dan bias awal kami akan melakukan pekerjaan yang baik dalam hal apapun yang
kami berharap jaringan kami melakukan. Untuk menjadi konkret, pertimbangkan lapisan pertama dari bobot dalam sebuah jaringan
[784,30,30,30,10] untuk masalah MNIST. Inisialisasi acak berarti bahwa layer pertama
hapus sebagian besar informasi tentang gambar masukan. Meskipun lapisan berikutnya
Meskipun telah dilatih secara ekstensif, mereka masih akan merasa sangat sulit untuk mengidentifikasi gambar dari
masuk, hanya karena mereka tidak memiliki informasi yang cukup. Dan dengan demikian, tidak mungkin bahwa tidak
harus belajar banyak di lapisan pertama. Jika kita akan melatih jaringan dalam, kita perlu menemukan
bagaimana cara menyelesaikan masalah dissipasi gradien.
Jika saya menjadi Anda, saya tidak akan melewatkan bab berikutnya dengan penjelasan matematis untuk hal yang penting ini.
fenomena dalam pelatihan jaringan syaraf dalam (Deep Learning).
Bab 35–Matematika Masalah
Dissipasi Gradien dalam Deep Learning

Mari kita lanjutkan diskusi yang dimulai di babanterior. Untuk memahami mengapa masalah pelemahan
do gradiente ocorre, kita akan mempertimbangkan jaringan saraf dalam yang paling sederhana: satu dengan hanya satu
neurona di setiap lapisan. Berikut adalah jaringan dengan tiga lapisan tersembunyi:

Di sini, w1, w2,… adalah bobot, b1, b2,… adalah bias dan C adalah beberapa fungsi biaya. Hanya untuk diingat
bagaimana ini bekerja, keluaran aj dari neuron j adalah σ(zj), di mana σ adalah fungsi aktivasi sigmoid biasa, dan zj =
wjaj − 1 + bj adalah masukan terarah untuk neuron. Saya menggambar biaya C di akhir untuk menekankan bahwa
biaya adalah fungsi dari keluaran jaringan, a4: jika keluaran nyata dari jaringan mendekati keluaran yang diinginkan, maka
biaya akan rendah, sementara jika jauh, biaya akan tinggi.
Mari kita pelajari gradien ∂C / ∂b1 yang terkait dengan neuron tersembunyi pertama. Kita akan mendefinisikan sebuah ekspresi untuk
∂C / ∂b1 e, mempelajari ekspresi ini, kita akan memahami mengapa masalah dikeluarkannya gradien terjadi.

Saya akan mulai dengan menunjukkan ekspresi untuk ∂C / ∂b1. Tampaknya menakutkan, tetapi sebenarnya memiliki
sebuah struktur sederhana, yang akan saya jelaskan dalam waktu dekat. Berikut adalah ekspresi (abaikan jaringan, untuk saat ini, dan catat
que σ ′ é apenas a derivada da função σ):

Struktur dalam ekspresi adalah sebagai berikut: ada sebuah istilah σ ′ (zj) dalam produk untuk setiap neuron di jaringan; sebuah
peso wj untuk setiap peso di jaringan; dan suatu istilah akhir ∂C / ∂a4, yang sesuai dengan fungsi biaya di akhir.
Perhatikan bahwa saya menempatkan setiap istilah dalam ekspresi di atas bagian yang sesuai dari jaringan. Jadi jaringan itu sendiri adalah
Sebuah mnemonik untuk ekspresi.

Ada juga penjelasan sederhana mengapa ungkapan di atas itu benar dan, oleh karena itu, sangat menyenangkan (dan
mungkin menjelaskan) melihat penjelasan ini.

Bayangkan bahwa kita melakukan perubahan kecil Δb1 pada bias b1. Ini akan memicu serangkaian perubahan.
em cascata no sisa jaringan. Pertama, menyebabkan perubahan Δa1 pada keluaran neuron tersembunyi pertama. Ini,
sebaliknya, akan menyebabkan perubahan Δz2 pada masukan terponderasi untuk neuron tersembunyi kedua. Jadi, sebuah
perubahan Δa2 pada keluaran neuron tersembunyi kedua. Dan seterusnya, sampai mencapai perubahan C pada
biaya saat keluar. Kami memiliki
Ini menunjukkan bahwa kita dapat menemukan ekspresi untuk gradien ∂C / ∂b1, menyertai
secara hati-hati efek dari setiap tahap dari air terjun ini.

Untuk melakukan ini, mari kita pikirkan tentang bagaimana Δb1 membuat keluaran a1 dari neuron tersembunyi pertama berubah. Kami
kita punya a1 = σ (z1) = σ (w1a0 + b1), jadi:

Esse termo σ ′ (z1) deve parecer familiar: é o primeiro termo em nossa expressão reivindicada para o
gradien ∂C / ∂b1. Intuitif, istilah ini mengubah perubahan Δb1 pada bias menjadi perubahan Δa1 pada
aktivasi keluaran. Perubahan ini Δa1 pada gilirannya menyebabkan perubahan pada masukan tertimbang z2 = w2a1 + b2
untuk neuron tersembunyi kedua:

Menggabungkan ekspresi kami untuk Δz2 dan Δa1, kami melihat bagaimana perubahan pada bias b1 menyebar sepanjang
jaringan untuk mempengaruhi z2:
Sekali lagi, ini harus terdengar familiar: sekarang kita memiliki dua istilah pertama dalam ekspresi kita
dikuasai untuk gradien ∂C / ∂b1.

Kita bisa melanjutkan dengan cara ini, melacak bagaimana perubahan menyebar ke seluruh jaringan.
Di setiap neuron, kami mengambil suatu istilah σ ′ (zj) dan, di setiap bobot, kami memilih suatu istilah wj. Hasil akhirnya adalah
sebuah ekspresi yang menghubungkan perubahan akhir ΔC pada biaya untuk perubahan awal Δb1 pada bias:

Membagi dengan Δb1, sebenarnya, kita mendapatkan ekspresi yang diinginkan untuk gradien:

Mengapa masalah penguraian gradien terjadi

akhirnya?
Untuk memahami mengapa masalah disipasi gradien terjadi, mari kita tuliskan secara eksplisit
ekspresi penuh untuk gradien:

Dengan pengecualian dari istilah terakhir, ekspresi ini adalah hasil kali dari istilah dalam bentuk wjσ ′ (zj). Untuk memahami
cara masing-masing dari istilah ini berperilaku, mari kita lihat grafik dari fungsi σ ′:
Turunan mencapai maksimum di σ ′ (0) = 1/4. Sekarang, jika kita menggunakan pendekatan standar kita untuk menginisialisasi
berat di jaringan, kami akan memilih berat menggunakan distribusi normal (Gaussian) dengan rata-rata 0 dan deviasi
pola 1. Dengan demikian, bobot umumnya memenuhi | wj | < 1. Mengumpulkan pengamatan ini, kita melihat bahwa
termos wjσ ′ (zj) umumnya memenuhi | wjσ ′ (zj) | < 1/4. Dan ketika kita mengambil produk dari banyak dari ini
termos, produk akan cenderung menurun secara eksponensial: semakin banyak istilah, semakin kecil produk tersebut. Ini sedang
mulai tercium seperti penjelasan yang mungkin untuk masalah dissipasi gradien.

Untuk membuat semuanya sedikit lebih eksplisit, mari kita bandingkan ekspresi untuk ∂C / ∂b1 dengan sebuah
ekspresi untuk gradien berkaitan dengan bias posterior, katakanlah ∂C / ∂b3. Secara alami, kami tidak menjelaskan
secara eksplisit sebuah ekspresi untuk ∂C / ∂b3, tetapi mengikuti pola yang sama yang dijelaskan di atas untuk ∂C / ∂b1. Di sini
ini adalah perbandingan antara dua ungkapan:
Kedua ekspresi berbagi banyak istilah. Namun gradien ∂C / ∂b1 mencakup dua istilah tambahan, masing-masing
um da forma wjσ ′ (zj). Como vimos, esses termos são tipicamente menores que 1/4 dari magnitudo. E assim o
gradien ∂C / ∂b1 biasanya akan menjadi faktor 16 (atau lebih) lebih kecil daripada ∂C / ∂b3. Ini adalah asal usul
esensial dari masalah disipasi gradien.

Tentu saja ini adalah argumen informal, bukan bukti yang ketat bahwa masalah dissipasi
gradien akan terjadi. Ada beberapa klausul pelarian yang mungkin. Secara khusus, kita dapat bertanya apakah
berat wj dapat meningkat selama pelatihan. Jika mereka melakukannya, mungkin istilah wjσ ′ (zj) di
produk tidak lagi memenuhi | wjσ ′ (zj) | < 1/4. Sebenarnya, jika istilah menjadi cukup besar –
lebih besar dari 1 – maka kita tidak akan lagi memiliki masalah dissipasi gradien. Sebaliknya, gradien
akan tumbuh secara eksponensial saat kita bergerak mundur melalui lapisan. Alih-alih menjadi masalah dari
dissipasi gradien, kami akan menghadapi masalah peledakan gradien. Tapi ini adalah topik untuk yang berikutnya
bab!

Untuk mempelajari semua rincian matematis di balik proses ini, cek kursus unik dan eksklusif kami.
di Brasil:Matematika untuk Machine Learning. Diini adalah bab berikutnya.

Bab 36–Masalah Lain dengan

Gradien di Jaringan Saraf Buatan
Di babanteriorkami menggambarkan untuk Anda Matematika yang membantu menjelaskan penyebab masalahnya
dissipasi gradien. Tetapi dissipasi bukanlah satu-satunya masalah yang dapat terjadi. Dalam bab ini kita akan
menggambarkan masalah lain yang mungkin terjadi dengan gradien dalam jaringan saraf buatan.

Ledakan Gradien
Mari kita lihat contoh eksplisit di mana terjadi ledakan gradien. Contohnya sangat sederhana dan
Mari kita mengubah beberapa parameter di jaringan untuk memastikan bahwa kita mengalami ledakan gradien.
Meski melakukan perubahan ini untuk memaksa masalah, ledakan gradien bukanlah hanya sebuah
kemungkinan hipotesis dan benar-benar bisa terjadi.

Ada dua langkah untuk mendapatkan ledakan gradien. Pertama, kita memilih semua bobot di jaringan sebagai
besar, katakanlah w1 = w2 = w3 = w4 = 100. Kedua, mari kita memilih bias sehingga istilah σ ′ (zj)
jangan terlalu kecil. Ini sebenarnya sangat mudah dilakukan: yang kita butuhkan hanyalah memilih bias
untuk memastikan bahwa input berbobot untuk setiap neuron adalah zj = 0 (dan kemudian σ ′ (zj) = 1/4). Jadi, oleh
contoh, kita ingin z1 = w1a0 + b1 = 0. Kita bisa mendapatkan ini dengan mengatur b1 = −100∗ a0. Kita bisa menggunakan a
ide yang sama untuk memilih bias lainnya. Ketika kita melakukan ini, kita melihat bahwa semua istilah wjσ ′ (zj)
sama dengan 100∗ 1/4 = 25. Dengan pilihan ini, terjadi masalah ledakan gradien.

Instabilitas Gradien
Masalah mendasar di sini bukanlah masalah gradien yang menghilang atau masalah dari
gradien yang meledak. Itu karena gradien di lapisan awal adalah produk dari semua istilah di semua lapisan
posteriores. Ketika ada banyak lapisan, ini adalah situasi yang secara intrinsik tidak stabil. Satu-satunya cara yang
semua lapisan dapat belajar dengan kecepatan yang hampir sama jika semua produk istilah ini ada
berikutnya untuk menyeimbangkan. Tanpa mekanisme atau alasan yang mendasari agar keseimbangan terjadi, itu adalah
sangat tidak mungkin terjadi hanya kebetulan. Singkatnya, masalah nyata di sini adalah bahwa jaringan
jaringan saraf mengalami masalah ketidakstabilan gradien. Akibatnya, jika kita menggunakan teknik
pembelajaran berbasis gradien standar, lapisan yang berbeda di dalam jaringan cenderung belajar dengan kecepatan yang berbeda
sepenuhnya berbeda.

Masalah yang Paling Umum adalah Memang Disipasi Gradien

Kami melihat bahwa gradien dapat menghilang atau meledak di lapisan awal jaringan dalam. Faktanya, saat
Menggunakan neuron sigmoida, gradien biasanya menghilang. Untuk melihat mengapa, pertimbangkan lagi
ekspresi | wσ ′ (z) |. Untuk menghindari masalah dissipasi gradien, kita perlu | wσ ′ (z) | ≥1. Anda
Anda mungkin berpikir bahwa ini bisa terjadi dengan mudah jika w sangat besar. Namun, itu lebih sulit daripada
sepertinya. Alasannya adalah bahwa istilah σ ′ (z) juga bergantung pada w: σ ′ (z) = σ ′ (wa + b), di mana a adalah aktivasi dari
masuk. Jadi, ketika kita membuat w besar, kita perlu berhati-hati agar kita tidak secara bersamaan membuat σ
(wa + b) kecil. Ini menjadi pembatasan yang cukup besar. Alasannya adalah ketika kita membuat w besar,
Kita cenderung membuat wa + b menjadi sangat besar. Melihat grafik σ ′ Anda dapat melihat bahwa ini menempatkan kita
di luar 'asas' fungsi σ ′, di mana diperlukan nilai yang sangat kecil. Satu-satunya cara untuk menghindari hal ini adalah jika ...
aktivasi input berada dalam rentang nilai yang sangat sempit. Terkadang ini akan terjadi,
lebih sering, namun, ini tidak terjadi. Dan demikian, dalam kasus umum, kita memiliki disipasi dari
gradasi.

Gradien yang Tidak Stabil di Jaringan yang Lebih Kompleks

Kami telah mempelajari jaringan sederhana sebagai contoh, dengan hanya satu neuron di setiap lapisan tersembunyi. Dan bagaimana dengan
jaringan dalam yang lebih kompleks, dengan banyak neuron di setiap lapisan tersembunyi (secara tipikal Deep
Pembelajaran)?
Faktanya, perilaku yang sama terjadi di jaringan tersebut. Di bab-bab sebelumnya di mana kami mempelajari
retropropagasi, kita melihat bahwa gradien pada lapisan l dari jaringan dengan L lapisan diberikan oleh:

Di sini, Σ ′ (zl) adalah matriks diagonal yang entri-entrinya adalah nilai σ ′ (z) untuk entri yang diberi bobot untuk a
camada l. Sebagai wl adalah matriks bobot untuk lapisan yang berbeda. Dan∇aC adalah vektor dari turunan parsial dari
C berhubungan dengan aktivasi keluaran.

Ini adalah ekspresi yang jauh lebih rumit dibandingkan dengan kasus satu neuron. Meskipun demikian, jika Anda
melihat dari dekat, bentuk esensialnya sangat mirip, dengan banyak pasangan bentuk:

Selain itu, matriks Σ′ (zj) memiliki entri kecil di diagonal, tidak ada yang lebih besar dari 1/4. Sejak

agar matriks bobot wj tidak terlalu besar, setiap istilah tambahan:

cenderung membuat vektor gradien lebih kecil, mengarah pada pengurangan gradien. Lebih umum, yang besar
jumlah suku dalam produk cenderung mengarah pada gradien yang tidak stabil, seperti dalam contoh kita sebelumnya.
Dalam praktiknya, ini biasanya ditemukan di jaringan sigmoid di mana gradien menghilang.
secara eksponensial dengan cepat di lapisan-lapisan sebelumnya. Sebagai hasilnya, pembelajaran menurun di lapisan-lapisan ini
lapisan. Perlambatan ini bukan hanya kecelakaan atau ketidaknyamanan: ini adalah akibat
fundamental dari pendekatan yang kami adopsi untuk pembelajaran jaringan.

Hambatan Lain untuk Pembelajaran Mendalam

Dalam beberapa bab terakhir ini, kami berkonsentrasi pada pemborosan gradien–dan, secara umum, gradien yang tidak stabil–
sebagai hambatan bagi pembelajaran mendalam. Faktanya, gradien yang tidak stabil hanyalah sebuah hambatan untuk
pembelajaran mendalam, meskipun merupakan hambatan penting yang mendasar. Banyak penelitian yang sedang berlangsung
memiliki tujuan untuk memahami lebih baik tantangan yang dapat terjadi saat melatih jaringan dalam.
Mari kita sebutkan secara singkat beberapa artikel, untuk memberi Anda rasa beberapa dari pertanyaan yang...
orang-orang sedang melakukan.

Sebagai contoh pertama, pada tahun 2010Glorot dan Bengioditemukan

bukti yang menunjukkan bahwa penggunaan fungsi
de ativação sigmóide dapat menyebabkan masalah dalam pelatihan jaringan yang dalam. Secara khusus, mereka
ditemukan bukti bahwa penggunaan sigmoid akan membuat aktivasi di lapisan tersembunyi akhir jenuh
dekat dengan 0 di awal pelatihan, secara substansial mengurangi pembelajaran. Mereka menyarankan beberapa
fungsi aktivasi alternatif, yang tampaknya tidak terlalu mengalami masalah saturasi ini.

Sebagai contoh kedua, pada tahun 2013,Sutskever, Martens, Dahl dan Hinton estudaram o impacto na
pembelajaran mendalam baik dari inisialisasi bobot acak maupun jadwal momentum di
penurunan gradien stokastik berdasarkan momentum. Dalam kedua kasus, membuat pilihan yang baik menghasilkan sebuah
perbedaan substansial dalam kemampuan untuk melatih jaringan dalam.

Contoh-contoh ini menunjukkan bahwa "Apa yang menyulitkan pelatihan jaringan dalam?" adalah pertanyaan yang kompleks.
Dalam beberapa bab terakhir ini, kami fokus pada ketidakstabilan yang terkait dengan pembelajaran berbasis
gradien pada jaringan dalam. Hasil dari dua paragraf terakhir menunjukkan bahwa ada juga peran
dijalankan oleh pemilihan fungsi aktivasi, cara bobot diinisialisasi dan bahkan
detail tentang bagaimana pembelajaran dengan gradien menurun diimplementasikan. Dan, tentu saja, pilihan dari
arsitektur jaringan dan hiperparameter lainnya juga penting. Dengan demikian, banyak faktor dapat
berperan dalam menyulitkan pembentukan jaringan yang dalam, dan pemahaman tentang semua faktor ini
masih menjadi objek penelitian yang sedang berlangsung. Kabar baiknya adalah, mulai dari bab berikutnya, kita akan berubah
ini adalah mengembangkan berbagai pendekatan untuk pembelajaran mendalam yang, hingga titik tertentu, dapat mengatasi
kamu mengarahkan semua tantangan ini.

Bukankah apa yang kita alami saat ini dalam sejarah umat manusia itu luar biasa? Semua ini yang
kami telah mempelajari hingga di sini dasar aplikasi Kecerdasan Buatan yang sudah ditemukan di pasar,
di berbagai aplikasi dan bahkan di smartphone kita. Dan kita masih ada di awal.
Dan Anda, ingin atau tidak ingin menjadi bagian dari revolusi luar biasa yang dibawa oleh Kecerdasan Buatan? Jika jawabannya adalah
ya, apa yang kamu tunggu?

Bab 37–Efek Ukuran Batch pada

Pelatihan Jaringan Saraf Tiruan

Mulai dari bab ini Anda akan memahami dengan lebih rinci arsitektur dari model-model utamaDalam
Pembelajaran, dengan penekanan pada pemilihan hiperparameter dan pendekatan pelatihan. Mari kita mulai dengan
Efek Ukuran Batch pada Pelatihan Jaringan Saraf Buatan.

Dalam eksperimen ini, kami akan menyelidiki efek ukuran batch (Batch Size) pada dinamika
pelatihan. Ukuran batch (Batch Size) adalah istilah yang digunakan dalam pembelajaran mesin dan mengacu pada
jumlah contoh pelatihan yang digunakan dalam satu iterasi. Ukuran Batch dapat menjadi salah satu dari tiga pilihan:

mode batch: di mana ukuran batch sama dengan total dataset, membuat nilai iterasi dan
masa yang setara.
modus mini-batch: di mana ukuran batch lebih besar dari satu, tetapi lebih kecil dari ukuran total kumpulan
data. Umumnya, sebuah angka yang dapat dibagi dengan ukuran total dari kumpulan data.
mode stokastik: di mana ukuran batch sama dengan satu. Oleh karena itu, gradien dan parameter jaringan
neural diperbarui setelah setiap sampel.

Metrik yang akan kita fokuskan adalah ogap generalisasi, yang didefinisikan sebagai perbedaan antara
nilai dari waktu pelatihan dan nilai dari waktu pengujian. Mari kita investigasi ukuran batch dalam konteks
da klasifikasi gambar (sama yang digunakan di berbagai bab sebelumnya). Secara spesifik, kita akan menggunakan
kumpulan data MNIST.
Dalam kasus kami, perbedaan generalisasi hanyalah perbedaan antara akurasi klasifikasi di
waktu uji dan waktu pelatihan. Pengalaman ini ditujukan untuk memberikan beberapa intuisi
dasar tentang efek ukuran batch. Sudah menjadi pengetahuan umum di komunitas pembelajaran mesin bahwa
kesulitan untuk membuat pernyataan umum tentang efek hiperparameter biasanya bervariasi tergantung pada kumpulan
diberikan himpunan data dan model ke model. Oleh karena itu, kesimpulan yang kami buat di sini hanya dapat berfungsi
sebagai indikasi daripada pernyataan umum tentang ukuran lot.

Ukuran batch adalah salah satu hiperparameter terpenting untuk menyetel sistem modern
pembelajaran [Link] Datasering kali ingin menggunakan ukuran batch yang lebih besar untuk
melatih model Anda, karena memungkinkan percepatan komputasi dari paralelisme GPU. Namun,
sudah dikenal bahwa ukuran lot yang sangat besar akan mengarah pada generalisasi yang buruk (meskipun
saat ini tidak diketahui secara pasti mengapa ini terjadi). Untuk fungsi konveks yang sedang kita coba
Mengoptimalkan, ada persaingan yang melekat antara manfaat ukuran lot yang lebih kecil dan lebih besar.

Di satu sisi, menggunakan satu batch yang sama dengan seluruh kumpulan data menjamin konvergensi ke optimal global dari
fungsi objektif. Namun, ini adalah biaya dari konvergensi empiris yang lebih lambat menuju optimal ini. Oleh
di sisi lain, penggunaan ukuran lot yang lebih kecil secara empiris menunjukkan konvergensi yang lebih cepat untuk
solusi 'baik'. Ini secara intuitif dijelaskan oleh fakta bahwa ukuran batch yang lebih kecil memungkinkan bahwa
model "mulailah pembelajaran sebelum melihat semua data". Kerugian menggunakan ukuran batch
menor adalah bahwa tidak ada jaminan bahwa model akan konvergen ke optimal global. Ia akan melompat di sekitar
global yang sangat baik, tergantung pada hubungan antara ukuran batch dan ukuran dataset. Oleh karena itu,
sob tidak ada batasan komputasi, sering kali disarankan untuk memulai dengan yang kecil
ukuran lot, memetik manfaat dari dinamika pelatihan yang lebih cepat, dan tingkatkan ukuran
melalui pelatihan, juga memanfaatkan manfaat dari konvergensi yang dijamin.

Secara empiris telah diamati bahwa ukuran lot yang lebih kecil tidak hanya memiliki dinamika pelatihan yang lebih
cepat, tetapi juga generalisasi untuk himpunan data uji versus ukuran batch yang lebih besar. Tapi
pernyataan ini memiliki batasan. Kita tahu bahwa ukuran batch 1 biasanya berfungsi dengan sangat buruk. Itu adalah
umumnya diterima bahwa ada 'titik ideal' untuk ukuran batch antara 1 dan seluruh kumpulan data dari
pelatihan yang akan memberikan generalisasi terbaik. 'titik ideal' ini biasanya tergantung pada kumpulan
data dan model yang dimaksud. Alasan untuk generalisasi yang lebih baik secara samar-samar dikaitkan dengan keberadaan
de "kebisingan" dalam pelatihan dengan ukuran batch kecil. Karena sistem jaringan saraf adalah
sangat rentan terhadap penyesuaian berlebihan (overfitting), idenya adalah bahwa visualisasi dari berbagai ukuran
setiap lot kecil, dengan setiap lot menjadi representasi "berisik" dari seluruh kumpulan data, akan menyebabkan sebuah
sejenis dinamika 'tarik-dan-tarik'. Dinamika ini mencegah jaringan syaraf terlalu menyesuaikan diri di
kumpulan pelatihan dan, oleh karena itu, memiliki kinerja yang buruk di kumpulan pengujian.

Definisi Masalah

Masalah yang akan diselidiki adalah klasifikasi. Diberikan gambar X, tujuannya adalah untuk memprediksi
label gambar y. Dalam kasus kumpulan data MNIST, X adalah gambar hitam-putih dari digit 0
a 9 e ysão as etiquetas de dígitos correspondentes “0” a “9”. Nosso modelo de escolha é uma rede neural.
Secara spesifik, kami akan menggunakan Perceptron Multilapis (MLP). Kecuali dinyatakan lain, ini adalah
model standar digunakan dalam percobaan:

2 lapisan tersembunyi sepenuhnya terhubung (FC), 1024 unit masing-masing

Fungsi aktivasi ReLU
Fungsi kehilangan: logaritma negatif
Pengoptimal: SGD (Stochastic Gradient Descent)
Tingkat pembelajaran: 0,01
Épocas: 30

Pada akhirnya, pertanyaan yang ingin kita jawab adalah "berapa ukuran batch yang harus saya gunakan saat melatih sebuah"
jaringan saraf?
Efek Ukuran Lot

Hal pertama yang harus kita lakukan untuk mengonfirmasi masalah yang sedang kita teliti adalah menunjukkan kepada
ketergantungan antara interval generalisasi dan ukuran batch. Saya telah merujuk pada metrik yang
kami mempertimbangkan sebagai "kesenjangan generalisasi". Ini biasanya merupakan ukuran penulis tentang topik tersebut.
digunakan dalam artikel dan makalah, tetapi untuk kesederhanaan dalam studi kami kami hanya akan memperhatikan
presisi tes harus setinggi mungkin. Seperti yang akan kita lihat, presisi pelatihan dan tes akan bergantung pada
ukuran lot, oleh karena itu lebih signifikan untuk berbicara tentang ketepatan pengujian daripada kesenjangan generalisasi.
Lebih khusus, kami ingin agar akurasi tes setelah sejumlah besar epoch
pelatihan, jadi tinggi. Berapa banyak epoch yang merupakan "jumlah epoch yang besar"? Idealnya, ini didefinisikan sebagai yang
jumlah epoch pelatihan yang diperlukan, sehingga pelatihan tambahan memberikan sedikit
atau tidak ada peningkatan dalam ketepatan pengujian. Dalam praktiknya, ini sulit untuk ditentukan dan kita harus menebak
berapa banyak era yang tepat untuk mencapai perilaku ideal. Saya menyajikan ketepatan pengujian dari
modela jaringan saraf kami dilatih menggunakan berbagai ukuran batch di bawah ini (untuk belajar melakukan semuanya
itu dalam praktik, klik di sini).

Kurva berwarna oranye: ukuran lot 64

Kurva dalam hijau: ukuran lot 256
Kurva berwarna ungu: ukuran lot 1024

Penemuan: ukuran lot yang lebih besar mengakibatkan akurasi yang lebih rendah pada data pengujian.

Sumbu x menunjukkan jumlah epoch pelatihan. Sumbu y diberi label untuk setiap pemetaan. MNIST adalah
jelas sekumpulan data yang mudah untuk dilatih; kita dapat mencapai 100% akurasi dalam pelatihan dan 98% dalam
uji coba hanya dengan model MLP kami berdasarkan ukuran batch 64. Selain itu, kami melihat tren yang jelas
antara ukuran batch dan akurasi tes (dan pelatihan!). Kesimpulan pertama kami adalah sebagai berikut:
ukuran lot yang lebih besar menyebabkan akurasi yang lebih rendah pada data pengujian. Pola ini tampaknya ada.
di ujungnya untuk set data MNIST. Saya mencoba ukuran batch sama dengan 2 dan mencapai sebuah
presisi pengujian bahkan lebih baik 99% (dibandingkan 98% untuk ukuran batch 64)! Sebagai peringatan, tidak
saya harap ukuran batch yang sangat kecil, seperti 2, dapat bekerja dengan baik pada kumpulan data yang lebih kompleks.

Namun dalam eksperimen ini kami tidak mempertimbangkan perubahan dalam laju pembelajaran. Kami bisa meningkatkan
akurasi dalam pengujian dengan ukuran batch yang lebih besar, menyesuaikan laju pembelajaran (learning rate)? Tidak
Tunggu bab berikutnya untuk menemukannya! Sampai saat itu.

Bab 38–Efek dari Tingkat Pembelajaran

tidak dalam Pelatihan Jaringan Saraf Tiruan

Mari kita lanjutkan diskusi tentang bab tersebutuloanteriordan

mencoba meningkatkan akurasi model pada data uji
mulai dari ukuran batch yang lebih besar, meningkatkan laju pembelajaran. Mari kita pelajari O
Efek dari Tingkat Pembelajaran pada Pelatihan Jaringan Saraf Buatan.

Beberapa penelitian dalam literatur tentang optimisasi dalam Machine Learning menunjukkan bahwa meningkatkan laju
pembelajaran dapat mengimbangi ukuran batch yang lebih besar. Dengan itu dalam pikiran, kami meningkatkan tarif
pembelajaran model kami untuk melihat apakah kami dapat memulihkan akurasi pada data tes (yang telah hilang
dikurangi saat meningkatkan ukuran batch). Grafik di bawah ini menunjukkan kesimpulan:
Kurva berwarna oranye: ukuran batch 64, laju pembelajaran 0.01 (referensi)
Kurva berwarna ungu: ukuran batch 1024, laju pembelajaran 0,01 (referensi)
Kurva berwarna biru: ukuran lot 1024, laju pembelajaran 0,1

Kurva berwarna oranye dan ungu adalah untuk referensi dan merupakan sama dengan rangkaian grafik pada bab
anterior. Seperti kurva ungu, kurva biru dilatih dengan ukuran lot besar sebesar 1024. Namun,
kurva biru memiliki tingkat pembelajaran yang meningkat 10 kali. Anehnya, kita dapat memulihkan
precisão nos dados de teste a partir de um tamanho de lote maior, aumentando a taxa de aprendizado.
Dengan menggunakan ukuran batch 64 (oranye) mencapai akurasi pengujian 98%, sementara penggunaan sebuah
ukuran batch 1024 hanya mencapai sekitar 96%. Tetapi dengan meningkatkan laju pembelajaran, menggunakan sebuah
ukuran batch 1024 juga mencapai akurasi pengujian 98%. Sama seperti dengan kesimpulan kami
sebelumnya, berhati-hatilah saat menganalisis hasil ini. Diketahui bahwa peningkatan sederhana dalam tingkat pembelajaran
tidak sepenuhnya mengimbangi ukuran lot yang besar dalam kumpulan data yang lebih kompleks daripada
MNIST.

Apa pengaruhnya ketika mengurangi ukuran batch selama pelatihan model?

Pertanyaan menarik berikutnya yang harus diajukan adalah apakah pelatihan dengan batch besar "memulai Anda dalam sebuah
jalur buruk yang tidak bisa kamu pulihkan." Artinya, jika kita mulai berlatih dengan ukuran batch
1024, jadi kami beralih ke ukuran batch 64, apakah kami masih bisa mencapai akurasi pengujian tertinggi sebesar 98%?

Kami menyelidiki tiga kasus: melatih menggunakan ukuran batch kecil untuk satu epoch, beralih ke sebuah
ukuran batch besar, berlatih menggunakan ukuran batch kecil untuk banyak epoch dan beralih ke satu
ukuran lot yang lebih besar dan melatih menggunakan ukuran lot yang besar dan kemudian menggunakan laju pembelajaran
lebih tinggi dengan ukuran lot yang sama. Hasil di bawah ini:
Kurva berwarna oranye: melatih dengan ukuran batch 64 selama 30 epoch (referensi)
Kurva dalam kuning neon: latih dengan ukuran batch 1024 selama 60 epoch (referensi)
Kurva berwarna hijau: latih dengan ukuran batch 1024 selama 1 epoch dan kemudian ubah ke ukuran batch 64.
30 zaman total de 31 epoka
Kurva berwarna kuning tua: latih dengan ukuran batch 1024 selama 30 epoch dan kemudian ubah ukuran menjadi
lote 64 selama 30 epoch (total 60 epoch)
Kurva berwarna ungu: pelatihan dengan ukuran batch 1024 dan peningkatan laju pembelajaran sebanyak 10x pada saat itu
31 (total dari 60 era)

Seperti sebelumnya, kurva berwarna oranye adalah untuk ukuran batch kecil. Kurva berwarna kuning neon digunakan
sebagai kontrol untuk memastikan bahwa kita tidak memperbaiki akurasi tes karena kita
hanya berlatih lebih banyak. Jika Anda memberi perhatian lebih pada sumbu x, epoh-epoh diberi nomor dari 0 hingga 30.
Ini terjadi karena hanya 30 epoch terakhir dari pelatihan yang ditampilkan. Untuk eksperimen dengan
lebih dari 30 epoch pelatihan secara total, epoch pertama x–30 telah diabaikan.

Sulit melihat tiga garis lainnya karena mereka tumpang tindih, tetapi tidak masalah, karena dalam ketiga kasus tersebut
kami mendapatkan kembali akurasi dalam pengujian 98%! Kesimpulannya, memulai dengan ukuran batch yang besar tidak
"ambil model yang terjebak" di lingkungan yang memiliki lokasi ideal yang sangat baik. Model dapat beralih ke sebuah
tamanho batch yang lebih kecil atau tingkat pembelajaran yang lebih tinggi kapan saja untuk mencapai akurasi
uji coba yang lebih baik.

Untuk memahami perilaku matematis di balik seluruh proses ini, kita perlu membawa
gradien untuk diskusi ini. Itu yang akan kita lakukan di bab berikutnya. Sampai saat itu.
Bab 39–Hubungan Antara Ukuran Lot dan
Perhitungan Gradien

Mari kita lanjutkan dengan diskusi tentangduabab sebelumnyadan menyelidiki Hubungan Antara Ukuran
Lote dan Perhitungan Gradien.

Bagaimana menjelaskan mengapa pelatihan dengan ukuran batch yang lebih besar mengarah pada akurasi yang lebih rendah dalam pengujian? Sebuah hipotesis
mungkin saja sampel pelatihan dalam satu batch saling mempengaruhi (bersaing) dengan gradien satu dari
outro. Satu sampel ingin menggerakkan bobot model ke arah tertentu, sementara sampel lainnya ingin
memindahkan beban ke arah yang berlawanan. Oleh karena itu, gradien mereka cenderung saling membatalkan dan Anda mendapatkan sebuah
gradien umum kecil. Mungkin, jika sampel dibagi menjadi dua batch, persaingan akan berkurang,
karena model tersebut dapat menemukan bobot yang akan memenuhi kedua sampel, jika dilakukan secara berurutan. Di
dengan kata lain, optimasi berurutan dari sampel lebih mudah daripada optimasi simultan di
ruang parameter kompleks dan berdimensi tinggi.

Hipotesis ditunjukkan secara grafik di bawah. Panah ungu menunjukkan satu langkah gradien.
turunan menggunakan ukuran batch 2. Panah biru dan merah menunjukkan dua langkah berturut-turut dari
turunan gradien menggunakan ukuran batch 1. Panah hitam adalah jumlah vektor dari panah biru dan merah dan
mewakili kemajuan keseluruhan yang dibuat model dalam dua tahap ukuran batch 1. Kedua eksperimen
mulai dengan bobot yang sama di ruang bobot. Meskipun tidak ditampilkan secara eksplisit dalam gambar,
hipotesisnya adalah bahwa garis ungu jauh lebih pendek daripada garis hitam, karena persaingan gradien.
Dengan kata lain, gradien dari satu langkah dengan ukuran batch besar lebih kecil daripada jumlah gradien.
dari berbagai tahap ukuran batch kecil.

eksperimen ini melibatkan replikasi gambar yang ditunjukkan di atas. Kami melatih model untuk
keadaan yang ditentukan. Selanjutnya, kelompok kontrol (panah ungu) dihitung dengan menemukan gradien dari
etapa unik dengan ukuran batch 1024. Grup eksperimental (panah hitam) dihitung dengan melakukan beberapa tahap
de gradien dan menemukan jumlah vektor gradien ini menggunakan ukuran batch yang lebih kecil. Produk
do número de etapas e do tamanho do lote adalah konstan di 1024. Ini mewakili model yang berbeda yang
ambil sejumlah tetap sampel.

Sebagai contoh, untuk ukuran batch 64, kita melakukan 1024/64 = 16 langkah, menjumlahkan 16 gradien tersebut untuk
menemukan gradien umum. Untuk ukuran batch 1024, kita melakukan 1024/1024 = 1 langkah. Perhatikan bahwa, untuk
ukuran lot yang lebih kecil, sampel berbeda diambil untuk setiap lot. Idenya adalah untuk membandingkan
gradien dari model untuk ukuran batch yang berbeda setelah model melihat jumlah yang sama
contoh. Sebagai peringatan terakhir, untuk menyederhanakan, kami hanya mengukur gradien dari lapisan terakhir.
model MLP kami (Multilayer Perceptron), yang memiliki 1024⋅ 10 = 10240 peso.

Kami menyelidiki ukuran lot berikut: 1, 2, 3, 4, 5, 6, 7, 8, 16, 32, 64, 128, 256, 512, 1024.

Sebuah tes berarti:

1. Pemuatan / penetapan ulang bobot model untuk titik pelatihan tetap (kami menggunakan bobot model
setelah pelatihan selama 2/30 epoch dengan ukuran batch 1024.
2. Pengambilan sampel acak dari 1024 sampel data dari himpunan pelatihan.
3. Pelatihan model melalui semua 1024 sampel data sekali, dengan ukuran yang berbeda
lote.

Untuk setiap ukuran batch, kami mengulang eksperimen seribu kali. Kami tidak mengumpulkan data lebih lanjut karena
menyimpan tensor gradien itu benar-benar sangat mahal (kami menyimpan tensor dari setiap percobaan untuk
menghitung statistik orde lebih tinggi nanti). Ukuran total file dengan tensor gradien
itu sebesar 600 MB.

Untuk setiap salah satu dari 1000 uji coba, kami menghitung norma euclidean dari tensor gradien yang dijumlahkan (panah hitam
dalam gambar kami). Jadi, kami menghitung rata-rata dan deviasi standar norma-norma ini selama 1000 pengujian.
Ini dilakukan untuk setiap ukuran batch.

Saya ingin menyelidiki dua regimen berat yang berbeda: pada awal pelatihan, ketika beban tidak
konvergen dan banyak pembelajaran terjadi dan, lebih tardu, selama pelatihan, ketika bobot hampir
konvergensi dan pembelajaran minimum sedang terjadi. Untuk rezim awal, saya melatih model MLP untuk
2 epoch dengan ukuran batch 1024 dan untuk regime selanjutnya, saya melatih model selama 30 epoch.

Penemuan: ukuran lot yang lebih besar menghasilkan langkah gradien yang lebih besar daripada ukuran
lotes yang lebih kecil untuk jumlah sampel yang sama yang dilihat.
Sumbu x menunjukkan ukuran lot. Sumbu y menunjukkan norma Euclidean rata-rata dari tensor gradien di
1000 percobaan. Batang kesalahan menunjukkan variasi norma euclidean dalam 1000 percobaan. Titik-titik
azuis adalah eksperimen yang dilakukan dalam pengaturan awal, di mana model dilatih selama 2 epoh. Titik-titik
verdes adalah rezim posterior di mana model dilatih selama 30 epoch. Seperti yang diharapkan, gradiennya adalah
lebih besar di awal pelatihan (titik biru lebih besar daripada titik hijau).

Bertentangan dengan hipotesis kami, norma gradien rata-rata meningkat seiring dengan ukuran batch! Kami mengharapkan bahwa
gradienya lebih kecil untuk ukuran batch yang lebih besar karena persaingan antara sampel dari
Sebaliknya, apa yang kami temukan adalah bahwa ukuran batch yang lebih besar menghasilkan langkah gradien yang lebih besar
dari ukuran lot yang lebih kecil untuk jumlah sampel yang sama yang terlihat. Perhatikan bahwa norma Euclidean
dapat diartikan sebagai jarak euclidean antara kumpulan bobot baru dan kumpulan awal
peso. Oleh karena itu, pelatihan dengan batch besar cenderung menjauh dari bobot awal setelah melihat satu
jumlah tetap sampel daripada pelatihan dengan ukuran batch yang lebih kecil. Hubungan antara ukuran
lote dan norma gradien adalah √x. Dengan kata lain, hubungan antara ukuran lot dan norma dari
gradien persegi adalah linier.

Selain itu, variasinya jauh lebih kecil untuk ukuran batch yang lebih kecil. Namun, apa yang bisa kita ...
menarik adalah besarnya varians terkait dengan besarnya rata-rata. Oleh karena itu, untuk melakukan sebuah
perbandingan yang lebih tajam, saya mengukur rata-rata dan deviasi standar setiap ukuran lot untuk rata-rata
ukuran lot 1024. Dengan kata lain,

di mana batang-batang mewakili nilai yang dinormalisasi dan i menunjukkan ukuran batch tertentu.

Kami membenarkan pengukuran rata-rata dan deviasi standar dari norma gradien karena ini adalah
setara dengan meningkatkan tingkat pembelajaran untuk eksperimen dengan ukuran batch yang lebih kecil.
Pada dasarnya, kami ingin tahu "dari jarak yang sama dari berat awal, apa variasi dalam
norma gradien untuk berbagai ukuran lahan”? Ingatlah bahwa kita sedang mengukur variasi
pada norma gradien dan bukan pada variasi gradien itu sendiri, yang merupakan metrik yang jauh lebih akurat.
Penemuan: Untuk jarak rata-rata yang sama dari norma Euclidean dari bobot awal model,
ukuran lot yang lebih besar memiliki variansi yang lebih besar dalam jarak.

Kami melihat hasil yang sangat mengejutkan di atas. Untuk jarak rata-rata yang sama dari norma Euclidean dari
pesos awal model, ukuran lote yang lebih besar memiliki varians yang lebih besar dalam jarak. Ini cukup banyak! Di
suma, diberikan dua model yang dilatih dengan ukuran batch yang berbeda, pada gradien tertentu,
jika laju pembelajaran disesuaikan sehingga kedua model bergerak rata-rata pada yang sama
jarak, model dengan ukuran batch yang lebih besar akan bervariasi lebih dalam hal pergerakannya. Ini adalah sebuah
pouco contra-intuitivo, pois é bem conhecido que tamanhos menores de lotes são “ruidosos” e, portanto,
Anda dapat mengharapkan bahwa variasi norma gradien akan lebih besar. Perhatikan bahwa, untuk setiap tes, kami sedang
menggunakan 1024 sampel berbeda, daripada menggunakan 1024 sampel yang sama di semua uji coba. Perhatikan
juga bahwa variasi antara tes dapat disebabkan oleh dua hal: sampel yang berbeda yang diambil
dieksplorasi dari kumpulan data antara berbagai tes dan benih acak untuk setiap tes (yang tidak
terkendali, tetapi harus benar-benar demikian). Melangkah maju, saya akan mengasumsikan bahwa variasi disebabkan oleh yang pertama
fator: amostras diferentes. Este é um resultado interessante e poderíamos seguir esta investigação por muitos
bab. Tapi untuk saat ini, Anda sudah menerima informasi yang cukup untuk memahami Hubungan Antara
Ukuran Batch dan Perhitungan Gradien. Jenis eksperimen ini sangat penting dalam pekerjaan di
penelitian dan pengembangan model baru!

Kita dapat menyimpulkan satu tahap lagi dari buku ini dan memulai perjalanan terakhir dan paling mendebarkan kita.
pembelajaran, mempelajari arsitektur utama Deep Learning. Saya tidak akan melewatkannya jika saya adalah Anda! Sampai jumpa di
bab selanjutnya!
Bab 40–Pengantar Jaringan Saraf
Konvolusional

Di bab-bab pertama buku ini, kami mengajarkan jaringan syaraf kami untuk melakukan pekerjaan yang baik dalam mengenali
gambar digit tulisan tangan:

Kami melakukan ini menggunakan jaringan di mana lapisan yang berdekatan sepenuhnya terhubung satu sama lain. Artinya,
semua neuron di jaringan terhubung ke semua neuron di lapisan yang berdekatan:

Secara khusus, untuk setiap piksel dalam gambar masukan, kami mengkodekan intensitas piksel sebagai nilai dari
sebuah neuron yang sesuai di lapisan input. Untuk gambar berukuran 28 × 28 piksel yang kami gunakan,
Ini berarti bahwa jaringan kami memiliki 784 (= 28 × 28) neuron masukan. Kemudian, kami melatih bobot dan
vieses jaringan agar keluaran jaringan dapat mengidentifikasi gambar masukan dengan benar: '0', '1', '2', …, '8'
ou '9'.

Jaringan kami sebelumnya berfungsi dengan sangat baik: kami memperoleh akurasi klasifikasi lebih dari 98%,
menggunakan data pelatihan dan pengujian dari kumpulan data digit tangan MNIST. Tetapi, setelah
refleksi, adalah aneh menggunakan jaringan dengan lapisan yang sepenuhnya terhubung untuk mengklasifikasikan gambar. Alasanya adalah bahwa
arsitektur jaringan tidak memperhatikan struktur spasial dari gambar. Misalnya, ia memperlakukan piksel dari
entri yang berada jauh dan dekat tepat pada tingkat yang sama. Konsep struktur ruang seperti itu
harus disimpulkan dari data pelatihan. Tapi bagaimana jika, alih-alih mulai dengan arsitektur yang
rede yang dangkal, kita menggunakan arsitektur yang mencoba memanfaatkan struktur spasial? Di sinilah masuk
jaringan saraf konvolusional.

Jaringan ini menggunakan arsitektur khusus yang sangat cocok untuk mengklasifikasikan gambar.
penggunaan arsitektur ini membuat jaringan konvolusional cepat untuk dilatih. Ini, pada gilirannya, membantu kita untuk melatih
jaringan dalam dengan banyak lapisan, yang sangat baik dalam klasifikasi gambar. Hari ini, jaringan saraf
konvolusional atau varian dekat digunakan di sebagian besar jaringan saraf untuk pengenalan
gambar.

Asal usul jaringan saraf konvolusional dapat ditelusuri kembali ke tahun 70-an. Namun, artikel seminal yang menetapkan
tema modern pada jaringan konvolusi adalah sebuah artikel dari tahun 1998,“Pembelajaran berbasis gradien diterapkan pada
pengakuan dokumen“, oleh Yann LeCun, Léon Bottou, Yoshua Bengio, dan Patrick Haffner. Sejak itu,
LeCun membuat pengamatan menarik tentang terminologi untuk jaringan konvolusional: "Inspirasinya
neural [biológica] dalam model seperti jaringan konvolusi sangat samar. Itu sebabnya saya menyebutnya
‘jaringan konvolusional’ dan bukan ‘jaringan saraf konvolusional’, dan oleh karena itu saya menyebut simpulnya sebagai ‘unit’ dan bukan
‘neuron’ “. Meskipun pengamatan ini, jaringan konvolusional menggunakan banyak ide yang sama seperti yang
jaringan saraf yang telah kita pelajari sampai sekarang: ide-ide seperti backpropagation, gradient descent, regularisasi,
fungsi aktivasi non linier dan seterusnya. Jadi, mari kita mengikuti praktik umum dan mempertimbangkannya
sejenis jaringan saraf. Saya akan menggunakan istilah "jaringan saraf konvolusional" dan "jaringan konvolusional"
secara bergantian. Saya juga akan menggunakan istilah "neuron [buatan]" dan "unit" secara bergantian.

Definição

Jaringan Saraf Konvolusional (ConvNet / Jaringan Saraf Konvolusional / CNN) adalah sebuah algoritma dari
Pembelajaran Mendalam yang dapat menangkap gambar masukan, memberikan bobot dan bias yang penting.
dapat dipelajari) berbagai aspek / objek dari gambar dan mampu membedakan satu sama lain. Pra-
proses yang dibutuhkan dalam ConvNet jauh lebih kecil dibandingkan dengan algoritma lainnya
klasifikasi. Sementara pada metode primitif filter dibuat secara manual, dengan pelatihan yang cukup,
ConvNets memiliki kemampuan untuk mempelajari filter / fitur ini.

Arsitektur ConvNet mirip dengan pola konektivitas neuron di otak

manusia dan terinspirasi oleh organisasi Korteks Visual. Neuron individu merespons rangsangan
hanya di daerah terbatas dari lapangan visual yang dikenal sebagai Lapangan Resptif. Sekumpulan ini
bidang saling tumpang tindih untuk menutupi seluruh area visual. Kita akan melihat ini secara rinci nanti!

Mengapa menggunakan ConvNets dan bukan jaringan feed-forward?

Sebuah gambar tidak lebih dari sekadar matriks nilai piksel, kan? Jadi, mengapa tidak hanya meratakannya
gambar (misalnya, mengonversi matriks 3×3 menjadi vektor 9×1. Jika gambar adalah matriks, tidak ada
masalah dalam mengonversi menjadi vektor) dan memberikannya ke Perceptron Multi-Lapisan untuk tujuan
classificação? Na verdade não.

Dalam kasus gambar biner yang sangat dasar, metode ini dapat menunjukkan skor akurasi
media selama prediksi kelas, tetapi akan memiliki sedikit atau tidak ada akurasi ketika berurusan dengan gambar
kompleks dengan ketergantungan piksel di mana-mana.

Sebuah ConvNet mampu menangkap dengan sukses ketergantungan ruang dan waktu dalam sebuah gambar
melalui penerapan filter yang relevan. Arsitektur melakukan penyesuaian yang lebih baik terhadap kumpulan data dari
gambar karena pengurangan jumlah parameter yang terlibat dan kemampuan untuk menggunakan kembali bobot.
Dengan kata lain, jaringan dapat dilatih untuk memahami dengan lebih baik kecanggihan gambar.
Pada gambar di atas, kita memiliki gambar RGB (Merah–Hijau–Biru) yang telah dipisahkan oleh ketiga channelnya.
coloridos–Merah, Hijau dan Biru. Terdapat berbagai ruang warna di mana terdapat gambar–
Skala abu-abu, RGB, HSV, CMYK dll.

Anda bisa membayangkan betapa intensifnya komputasi begitu gambar mencapai dimensi,
katakanlah, 8K (7680 × 4320). Fungsi ConvNet adalah untuk mengurangi gambar menjadi bentuk yang lebih mudah untuk
memproses, tanpa kehilangan sumber daya yang kritis untuk mendapatkan perkiraan yang baik. Ini penting ketika
kami ingin merancang arsitektur yang tidak hanya baik dalam sumber daya pembelajaran, tetapi juga
seja escalável para conjuntos de dados massivos.

Ini adalah salah satu arsitektur Deep Learning yang paling menakjubkan dan memiliki banyak aplikasi praktis, dan kami akan mendedikasikan
beberapa bab pada arsitektur ini.

Jaringan saraf konvolusional menggunakan tiga ide dasar: bidang reseptif lokal, bobot yang dibagikan dan
penggabungan. Mari kita lihat setiap ide ini? Jadi jangan lewatkan bab-bab selanjutnya!

Bab 41–Bidang Reseptor Lokal di

Jaringan Saraf Konvolusional

Mari kita mempelajari secara rinci mulai sekarang Jaringan Syaraf Konvolusional, salah satu yang utama
arsitektur Deep Learning, yang banyak digunakan dalam Penglihatan Komputer. Dan kita akan mulai
memahami apa itu Lapangan Reseptif Lokal. Tapi sebelumnya, apa itu Penglihatan Komputer,
secara luas digunakan dalam aplikasi Kecerdasan Buatan?
Apa itu Visi Komputer?

Bayangkan situasi berikut: Anda berada di sebuah ruangan dengan dua orang lainnya. Salah satu dari mereka melempar bola.
dan Anda mengambilnya dengan tangan. Tidak ada yang bisa lebih sederhana, bukan?

Salah. Sebenarnya, ini adalah salah satu proses paling kompleks yang pernah kami coba pahami, yaitu bagaimana
otak memproses penglihatan sedemikian rupa sehingga kita tahu persis apa itu bola dan kapan ia datang.
arah kita? Dan mengajarkan sebuah mesin yang mampu melihat dengan cara yang sama seperti kita manusia adalah sebuah
tugas yang benar-benar sulit, bukan hanya karena sulit untuk membuat komputer melakukan perhitungan matematis yang
Menghasilkan penglihatan manusia, tetapi mengapa kita tidak sepenuhnya yakin tentang proses penglihatan.
benar-benar berfungsi.

Pertama-tama kita akan menjelaskan secara singkat dan mendekati bagaimana proses penglihatan terjadi pada kasus
arremesso bola: gambar bola melewati matanya dan mencapai retina, yang melakukan analisis tertentu
elemen dasar dan mengirimkan hasilnya ke otak, di mana korteks visual menganalisis gambar lebih dalam. Di
setelah itu, ia mengirimkan ke sisa korteks, yang membandingkan dengan semua yang sudah diketahui, mengklasifikasikan objek dan dimensi
e, akhirnya, memutuskan untuk melakukan sesuatu: mengangkat tangan dan mengambil bola (setelah memprediksi jalannya). Itu
terjadi dalam sekejap mata, dengan hampir tidak ada usaha sadar dan hampir tidak pernah gagal.
Dengan demikian, menciptakan kembali visi manusia bukan hanya masalah yang sulit, tetapi merupakan sekumpulan masalah, masing-masing dari yang
tergantung pada orang lain.

AVisi Komputerini adalah proses pemodelan dan replikasi visi manusia menggunakan perangkat lunak dan
perangkat keras. Visi Komputer adalah disiplin yang mempelajari bagaimana membangun kembali, menghentikan dan
memahami sebuah adegan 3d berdasarkan gambar 2dnya dalam hal sifat-sifat struktur yang ada di dalamnya
cena.

Visi Komputer dan pengenalan gambar adalah istilah yang sering digunakan sebagai sinonim,
tetapi yang pertama mencakup lebih dari sekadar menganalisis gambar. Ini karena, bahkan untuk manusia,
"ver" juga melibatkan persepsi di banyak aspek lainnya, bersama dengan serangkaian analisis. Setiap
Manusia menggunakan sekitar dua pertiga dari otaknya untuk pemrosesan visual, jadi itu bukan hal yang aneh.
kejutan bahwa komputer perlu menggunakan lebih dari sekadar pengenalan gambar untuk mendapatkan
pandangan Anda dengan cara yang benar.

Pengakuan gambar itu sendiri–analisis piksel dan pola gambar–adalah bagian integral dari
proses Visi Komputer yang melibatkan segala sesuatu, mulai dari pengenalan objek dan karakter hingga
analisis teks dan perasaan. Pengakuan gambar saat ini, masih sebagian besar, hanya mengidentifikasi
objek dasar seperti "sebuah pisang atau sebuah sepeda dalam sebuah gambar." Bahkan anak-anak pun bisa melakukannya.
tetapi potensi Penglihatan Komputer adalah di atas manusia: mampu melihat jelas dalam kegelapan, melalui
dinding, dalam jarak jauh dan memproses semua data ini dengan cepat dan dalam volume besar.

Visi Komputer dalam arti paling penuh sedang digunakan dalam kehidupan sehari-hari dan bisnis untuk
melakukan semua jenis tugas, termasuk mengidentifikasi penyakit medis dalam sinar-x, mengidentifikasi produk dan
di mana membelinya, iklan dalam gambar editorial, antara lain. Penglihatan Komputer dapat
digunakan untuk mendigitalkan platform media sosial untuk menemukan gambar relevan yang tidak dapat ditemukan
ditemukan melalui penelitian tradisional. Teknologi itu kompleks dan, seperti semua tugas
di atas disebutkan, memerlukan lebih dari sekadar pengenalan gambar, tetapi juga analisis semantik
dari kumpulan data besar. Dan Visi Komputer adalah teknik utama di balik kendaraan
otonom, yang harus mengubah dunia sepenuhnya seperti yang kita kenal.

Tidak ada yang pernah mengatakan bahwa ini akan mudah. Kecuali, mungkin, Marvin Minsky, pelopor Kecerdasan Buatan,
yang, pada tahun 1966, menginstruksikan seorang mahasiswa pascasarjana untuk "menghubungkan kamera ke komputer dan melakukan
dengan menggambarkan apa yang dilihatnya”. Tetapi kenyataannya adalah bahwa 50 tahun kemudian, kita masih bekerja pada ini,
Namun sekarang ada perbedaan (atau mungkin dua): kita memiliki Big Data dan Pemrosesan Paralel di GPU.
percayalah. Ini benar-benar membuat perbedaan.
Jaringan Saraf Konvolusional merupakan salah satu arsitektur Deep Learning yang paling banyak digunakan
em tarefas de Visão Computacional e reconhecimento de imagens e a partir de agora vamos compreender
kenapa.

Bidang Penerimaan Lokal

Pada lapisan yang sepenuhnya terhubung yang ditunjukkan di bab sebelumnya, masukan diwakili sebagai
sebuah garis vertikal neuron. Dengan kata lain, kami mengubah gambar 28 x 28 (yang merupakan sebuah matriks) menjadi sebuah vektor
hanya satu dimensi (kami akan membahas ini lebih lanjut). Tapi untuk memahami apa itu sebuah medan
receptivo lokal, mari kita pertimbangkan gambar dengan formaat standar 28x 28 (ukuran gambar di
dataset MNIST). Dalam sebuah gambar, setiap piksel adalah nilai numerik yang mewakili intensitas warna dari
sesuai dengan skala warna yang digunakan, seperti RGB (Merah–Hijau–Biru), misalnya, atau hanya intensitas
dalam skala abu-abu untuk gambar hitam dan putih.

Seperti biasa, kita akan menghubungkan piksel masukan ke lapisan neuron tersembunyi. Tapi kita tidak akan
menghubungkan semua piksel input ke setiap neuron tersembunyi. Sebaliknya, kami hanya membuat koneksi di
wilayah kecil dan terlokalisasi dari gambar masuk.

Untuk lebih tepatnya, setiap neuron di lapisan tersembunyi pertama akan terhubung ke suatu area kecil dari
neuron input, katakanlah, misalnya, daerah 5 × 5, yang sesuai dengan 25 piksel input.
Dengan demikian, untuk neuron tersembunyi tertentu, kita dapat memiliki koneksi yang terlihat seperti ini:

Wilayah ini dalam gambar masukan disebut sebagai bidang penerima lokal untuk neuron tersembunyi.
jendela kecil pada piksel masukan. Setiap sambungan mempelajari suatu bobot dan neuron tersembunyi juga belajar
sebuah bias umum. Anda dapat memikirkan neuron tersembunyi khusus ini sebagai belajar menganalisisnya
bidang reseptif lokal spesifik.

Selanjutnya, kami menggeser bidang reseptif lokal di seluruh gambar masuk. Untuk setiap bidang reseptif
lokal, ada neuron tersembunyi yang berbeda di lapisan tersembunyi pertama. Untuk menggambarkan ini secara konkret,
Mari kita mulai dengan suatu bidang penerimaan lokal di sudut kiri atas:

Jadi, kami menggeser bidang reseptif lokal satu piksel ke kanan (yaitu, ke satu neuron), untuk
menghubungkan ke neuron tersembunyi kedua:

Dan seterusnya, membangun lapisan tersembunyi pertama. Perhatikan bahwa, jika kita memiliki gambar masukan
28 × 28 dan bidang penerimaan lokal 5 × 5, akan ada 24 × 24 neuron di lapisan tersembunyi. Ini terjadi karena hanya
kita bisa menggerakkan bidang reseptif lokal 23 neuron ke samping (atau 23 neuron ke bawah), sebelum
bertabrakan dengan sisi kanan (atau bawah) dari gambar masukan.

Kami menunjukkan bidang reseptif lokal yang bergerak satu piksel sekali. Sebenarnya, kadang-kadang, satu
panjang langkah yang berbeda digunakan. Misalnya, kita dapat menggerakkan bidang reseptif lokal 2 piksel
ke kanan (atau ke bawah), di mana kita akan mengatakan bahwa panjang langkah sebesar 2 digunakan. Itu adalah
salah satu hyperparameter dari jaringan saraf konvolusional, yang disebut panjang langkah. Dalam contoh di atas
menggunakan panjang langkah 1, tetapi perlu diketahui bahwa orang-orang kadang-kadang mengalami panjang
passada diferentes.

Seperti yang dilakukan di bab-bab sebelumnya, jika kita tertarik untuk menguji panjang langkah
berbeda, kita bisa menggunakan data validasi untuk memilih panjang langkah yang menawarkan
kinerja yang lebih baik. Pendekatan yang sama juga dapat digunakan untuk memilih ukuran bidang
receptivo lokal – tentu saja, tidak ada yang istimewa tentang penggunaan lapangan receptivo lokal 5 × 5. Secara umum,
bidang reseptor lokal yang lebih besar cenderung berguna ketika gambar masukan menjadi signifikan
lebih besar daripada gambar MNIST berukuran 28 × 28 piksel.

Saya sudah berkata bahwa setiap neuron tersembunyi memiliki sebuah bias dan bobot 5 × 5 yang terhubung ke bidang reseptif lokalnya.
yang belum saya sebutkan adalah bahwa kita akan menggunakan bobot dan bias yang sama untuk masing-masing dari 24 × 24 neuron
tersembunyi. Ingin tahu bagaimana kami akan melakukan ini secara matematis? Jadi jangan lewatkan bab berikutnya!

Bab 42–Berbagi Beban di

Jaringan Saraf Konvolusional

Mari kita lanjutkan belajar Deep Learning dan menyelidiki bagaimana Cara Kerja Berbagi Bobot dalam
Jaringan Saraf Konvolusional.

Kami sudah mengatakan bahwa setiap neuron memiliki bias dan bobot 5 × 5 yang terhubung ke nyalapangan reseptif lokal. Apa yang saya
kami tidak menyebutkan bahwa kami akan menggunakan bobot dan bias yang sama untuk setiap 24 × 24 neuron tersembunyi.
Dengan kata lain, untuk neuron tersembunyi, keluarnya adalah:

Ini berarti bahwa semua neuron di lapisan tersembunyi pertama mendeteksi fitur yang persis sama,
hanya di lokasi yang berbeda dalam gambar input. Untuk memahami mengapa ini masuk akal, anggaplah bahwa
pesos dan bias sedemikian rupa sehingga neuron tersembunyi dapat memilih, katakanlah, tepi vertikal dalam sebuah
bidang reseptif lokal khusus. Kemampuan ini juga berguna di tempat lain dalam gambar. Oleh karena itu, itu adalah
berguna untuk menerapkan detektor fitur yang sama di seluruh gambar. Untuk meletakkan konsep ini dalam istilah
sedikit lebih abstrak, jaringan konvolusional sangat cocok untuk ketidakberdayaan translasi gambar:
memutar foto seekor kucing 90 derajat, tetap menjadikannya gambar seekor kucing, meskipun piksel sekarang
diatur dengan cara yang berbeda.

Oleh karena itu, kadang-kadang kami menyebut peta lapisan input ke lapisan tersembunyi sebagai peta
resources. Kami menyebut bobot yang mendefinisikan peta sumber daya sebagai bobot bersama. Dan kami menyebut
viés digunakan di peta sumber daya dengan cara viés bersama. Bobot dan viés yang dibagikan
costumam definir sebuah kernel atau filter. Dalam literatur, orang terkadang menggunakan istilah-istilah ini dengan cara yang
sedikit berbeda dan nanti kita akan melihat beberapa contoh konkret.

Struktur jaringan yang kami deskripsikan sejauh ini hanya dapat mendeteksi satu jenis sumber daya yang terlokalisasi.
Untuk melakukan pengenalan gambar, kita perlu lebih dari satu peta fitur. Dan dengan demikian, sebuah lapisan
konvolusional lengkap terdiri dari berbagai peta sumber daya, berbeda:
Dalam contoh yang ditunjukkan di atas, terdapat 3 peta sumber daya. Setiap peta sumber daya didefinisikan oleh sebuah
sekumpulan bobot bersama berukuran 5 × 5 dan satu bias bersama. Hasilnya adalah bahwa jaringan dapat
mendeteksi tiga jenis sumber daya yang berbeda, di mana setiap sumber daya dapat dideteksi di seluruh gambar.

No exemplo temos apenas 3 mapas de recursos, para manter o diagrama acima simples. No entanto, na
praktik, jaringan konvolusional dapat menggunakan lebih banyak (dan mungkin jauh lebih banyak) peta fitur. Salah satu dari
jaringan konvolusional pertama, aLeNet-5, gunakan 6 peta sumber daya, masing-masing terkait dengan bidang
receptif lokal 5 × 5, untuk mengenali digit MNIST. Jadi, contoh yang diilustrasikan di atas sudah baik
dekat dengan LeNet-5. Dalam contoh-contoh yang akan kita kembangkan lebih lanjut di buku ini, kita akan menggunakan lapisan
konvolusional dengan 20 dan 40 peta sumber daya. Mari kita lihat sekilas beberapa sumber daya yang
diajarkan:

Sebanyak 20 gambar sesuai dengan 20 peta sumber daya (atau filter atau kernel) yang berbeda. Setiap peta adalah
diwakili sebagai gambar 5 × 5, yang sesuai dengan bobot 5 × 5 di kolam reseptif lokal. Blok
tetapi putih berarti berat yang lebih ringan (biasanya, lebih negatif), jadi peta sumber daya
respon lebih sedikit terhadap pixel input yang sesuai. Blok yang lebih gelap berarti bobot yang lebih besar,
Oleh karena itu, peta sumber daya lebih merespons piksel masukan yang sesuai. Sangat kasar,
Gambar di atas menunjukkan jenis karakteristik yang direspon oleh lapisan konvolusional.

Jadi, apa yang bisa kita simpulkan dari peta sumber daya ini? Jelas bahwa ada struktur spasial di sini selain dari
apa yang kita harapkan secara kebetulan: banyak dari sumber daya memiliki sub-wilayah cahaya dan kegelapan yang jelas. Ini menunjukkan bahwa
jaringan kami benar-benar belajar hal-hal yang terkait dengan struktur ruang. Namun, selain itu, adalah
sulit untuk melihat apa yang dipelajari oleh detektor sumber daya ini. Sebenarnya, sekarang ada banyak pekerjaan untuk
memahami lebih baik sumber daya yang dipelajari oleh jaringan konvolusional. Jika Anda tertarik pada
untuk mengikuti pekerjaan ini, saya sarankan untuk memulai dengan artikelMemvisualisasikan dan Memahami Jaringan
Konvoluside Matthew Zeiler e Rob Fergus (2013) ou entãoVisi Komputer dan Pengenalan
de Imagens.

Salah satu keuntungan besar dari berbagi bobot dan bias adalah bahwa hal itu secara signifikan mengurangi jumlah yang
parameter yang terlibat dalam jaringan konvolusional. Untuk setiap peta fitur, kita membutuhkan 5 × 5 = 25
berbagi pesos, selain dari satu bias yang dibagikan. Oleh karena itu, setiap peta sumber daya memerlukan 26
parameter. Jika kita memiliki 20 peta sumber daya, total 20 × 26 = 520 parameter mendefinisikan lapisan
konvolusional. Sebagai perbandingan, anggaplah kita memiliki lapisan pertama yang sepenuhnya terhubung,
com 784 = 28 × 28 neuron masukan dan 30 neuron tersembunyi yang relatif modis, seperti yang kami gunakan di
banyak dari contoh-contoh sebelumnya di buku. Ini total 784 × 30 peso, ditambah ekstra 30 bias,
untuk total 23.550 parameter. Dengan kata lain, lapisan terhubung penuh akan memiliki lebih dari 40
lebih banyak parameter daripada lapisan konvolusional.

Tentu saja kita tidak bisa membuat perbandingan langsung antara jumlah parameter, karena keduanya
model memiliki perbedaan dalam hal yang esensial. Namun, secara intuitif, tampaknya mungkin bahwa penggunaan invariansi
dari terjemahan melalui lapisan konvolusional mengurangi jumlah parameter yang diperlukan untuk mendapatkan yang sama
kinerja yang sepenuhnya terhubung. Ini, pada gilirannya, akan menghasilkan pelatihan yang lebih cepat
untuk model konvolusional dan, pada akhirnya, akan membantu kita membangun jaringan dalam menggunakan lapisan
konvolusional.

Ngomong-ngomong, nama konvolusional berasal dari fakta bahwa operasi dalam persamaan yang ditunjukkan di awal ini
kapitel kadang-kadang dikenal sebagai suatu konvolusi. Sedikit lebih tepat, orang kadang-kadang
tuliskan persamaan ini sebagai a1 = σ (b + w∗ a0), di mana a1 menunjukkan kumpulan aktivasi keluaran dari sebuah
peta sumber daya, a0 adalah kumpulan aktivasi input dan∗ disebut sebagai operasi konvolusi.

Di bab berikutnya kita akan mempelajari tempat tidur Pooling, ‘rahasia’ lain di balik Jaringan Saraf
Konvolusional dan kemudian kita akan siap untuk menggabungkan semua ini.

Bab 43–Lapisan Pooling dalam Jaringan

Neurais Konvolusional

Selain lapisan konvolusional yang baru saja kami deskripsikan di bab-bab sebelumnya, jaringan saraf
konvolusional juga mengandung lapisan pengelompokan (atau Pooling). Lapisan Pooling secara umum
digunakan segera setelah lapisan konvolusional dan apa yang mereka lakukan adalah menyederhanakan informasi pada keluaran dari
lapisan konvolusional. Mari kita lihat apa itu dan bagaimana cara kerja Lapisan Pooling dalam Jaringan Saraf
Koneksi dan selanjutnya kita akan menggabungkan semua lapisan untuk memahami bagaimana cara kerjanya.
seluruh proses dalam arsitektur Deep Learning yang penting ini.

Lapisan Pooling

Sebuah lapisan pooling menerima setiap keluaran dari peta fitur dari lapisan konvolusional dan mempersiapkan
sebuah peta karakteristik yang terkompresi. Misalnya, setiap unit di lapisan pooling dapat merangkum
sebuah wilayah (katakanlah) 2 × 2 neuron di lapisan sebelumnya. Sebagai contoh konkret, sebuah
prosedur umum untuk pooling dikenal sebagai pool maksimum (atau Max-Pooling). Dalam Max-Pooling,
sebuah unit pooling hanya menghasilkan aktivasi maksimum di daerah input 2 × 2, seperti
ilustrasi pada diagram berikut:

Perhatikan bahwa, karena kita memiliki 24 × 24 neuron yang dihasilkan dari lapisan konvolusional, setelah pengelompokan, kita memiliki 12
× 12 neuron.

Seperti yang disebutkan di atas, lapisan konvolusional biasanya melibatkan lebih dari satu peta tunggal
karakteristik. Kami menerapkan Max-Pooling untuk setiap peta sumber daya secara terpisah. Oleh karena itu, jika ada
tiga peta sumber daya, lapisan yang digabungkan, konvolusional dan Max-Pooling, akan terlihat seperti:

Kita bisa berpikir tentang Max-Pooling sebagai cara jaringan bertanya apakah fitur tertentu adalah
ditemukan di mana saja di suatu daerah gambar. Kemudian, menghapus informasi posisi
tepat. Intuisi adalah bahwa, setelah sumber daya ditemukan, lokasi tepatnya tidak begitu
penting seperti lokasi Anda yang dekat dengan sumber daya lainnya. Salah satu keuntungan besar adalah ada
jauh lebih sedikit sumber daya yang dikelompokkan dan, oleh karena itu, ini membantu mengurangi jumlah parameter yang diperlukan di dalam
lapisan belakang. Genial, bukan?

Max-Pooling bukan satu-satunya teknik yang digunakan untuk pooling. Pendekatan umum lainnya dikenal sebagai
Pooling L2. Di sini, alih-alih mengambil aktivasi maksimum dari daerah 2 × 2 neuron, kita mengambil akar
kuadrat dari jumlah kuadrat aktivasi di wilayah 2 × 2. Meskipun detailnya berbeda, a
intuisinya mirip dengan pengelompokan maksimum: Pooling L2 adalah cara untuk memadatkan informasi dari
lapisan konvolusional. Dalam praktiknya, kedua teknik tersebut telah banyak digunakan. Dan kadang-kadang orang-orang
gunakan jenis operasi Pooling lainnya. Jika Anda benar-benar mencoba mengoptimalkan kinerja,
anda dapat menggunakan data validasi untuk membandingkan berbagai pendekatan berbeda terhadap Pooling dan memilih yang
pendekatan yang bekerja lebih baik.

Menggabungkan Segalanya

Kita sekarang dapat menggabungkan semua ide ini untuk membentuk jaringan saraf konvolusional yang lengkap. Ini mirip
arsitektur yang sedang kami pelajari di bab-bab sebelumnya, tetapi ada penambahan lapisan 10
neuron yang keluar, sesuai dengan 10 nilai yang mungkin untuk digit MNIST ('0', '1', '2', dll):

Jaringan dimulai dengan 28 × 28 neuron input (setiap gambar dari setiap digit pada dataset MNIST memiliki 28 x 28)
piksel), yang digunakan untuk mengkodekan intensitas piksel untuk sebuah gambar dalam dataset MNIST. Ini adalah
jadi diikuti oleh lapisan konvolusional menggunakan bidang reseptif lokal 5 x 5 dan tiga peta dari
karakteristik. Hasilnya adalah lapisan 3 × 24 × 24 neuron tersembunyi. Langkah berikutnya adalah sebuah lapisan
de Max-Pooling, diterapkan pada wilayah 2 × 2, di masing-masing dari tiga peta sumber daya. Hasilnya adalah sebuah
lapisan 3 × 12 × 12 neuron tersembunyi.

Lapisan akhir koneksi di jaringan adalah lapisan yang sepenuhnya terhubung. Artinya, lapisan ini menghubungkan
semua neuron pada lapisan max-pooling terhubung dengan masing-masing dari 10 neuron keluaran. Arsitektur ini
sepenuhnya terhubung adalah sama dengan yang kami gunakan di bab-bab sebelumnya. Namun, perhatikan bahwa di diagram
di atas, saya menggunakan satu panah saja, untuk kesederhanaan, daripada menunjukkan semua koneksi. Tentu saja, Anda bisa
mudah membayangkan koneksinya.

Artinya, kita memiliki sebuah jaringan yang terdiri dari banyak unit sederhana, yang perilakunya ditentukan oleh
berat dan bias Anda. Dan tujuan umumnya tetap sama: menggunakan data pelatihan untuk melatih berat dan
variasi dari jaringan agar jaringan dapat melakukan pekerjaan yang baik dalam mengklasifikasikan digit masukan.

Secara khusus, sama seperti di awal buku, kita akan melatih jaringan kita menggunakan penurunan stokastik dari
gradien dan retropropagasi. Ini terjadi terutama dengan cara yang sama seperti di bab-bab sebelumnya. Di
Sementara itu, kita perlu melakukan beberapa modifikasi pada prosedur retropropagasi. Alasannya adalah bahwa kami
derivasi sebelumnya dari retropropagasi adalah untuk jaringan dengan lapisan yang sepenuhnya terhubung. Untungnya, itu
sederhana memodifikasi turunan untuk lapisan konvolusi dan max-pooling.

Ingin melihat semua ini berfungsi dalam bahasa Python? Maka jangan lewatkan bab selanjutnya!
Bab 44–Pengenalan Gambar dengan
Jaringan Syaraf Konvolusional di Python–Bagian
1

Tugas kita sederhana: kita akan memberikan sebuah gambar kepada model Deep Learning dan model tersebut harus
klasifikasikan apakah gambar itu adalah anjing atau kucing! Tampaknya mudah, bukan? Sebenarnya, tidak!
fungsi kita perlu membangun dan melatih model Deep Learning, yang melibatkan pengetahuan tentang
Matematika, Statistik, Pemrograman, Penglihatan Komputer, Pra-Pemrosesan gambar, dan lain-lain
area. Tapi kita akan melakukan ini bersama-sama. Di bab-bab berikutnya kita akan membangun dan melatih sebuah model dari
Deep Learning untuk Pengenalan Gambar dengan Jaringan Saraf Konvolusional di Python. Ini akan menjadi
kesempatan yang sangat baik untuk mempraktikkan segala yang telah kita pelajari di buku hingga saat ini dan mempersiapkan Anda untuk bab-bab selanjutnya
lebih maju dari buku ini, ketika kita akan mempelajari arsitektur Deep Learning lainnya. Mari kita mulai?

Plano de Trabalho

Untuk memulai, kita perlu mendefinisikan dengan jelas masalah yang harus diselesaikan dan bagaimana kita akan menyelesaikannya.

Masalah: Diberikan sebuah gambar, apakah itu anjing atau kucing?

Hal pertama yang kita butuhkan adalah banyak gambar anjing dan kucing, untuk bisa melatih sebuah algoritma
de Pembelajaran Mendalam. Oleh karena itu, kita akan menggunakan pendekatan pembelajaran terawasi, di mana
kami akan memperkenalkan algoritme kepada berbagai gambar, yang telah diberi label sebagai gambar anjing dan kucing
dan kemudian kita akan melatih algoritme tersebut. Di akhir pelatihan, kita akan memiliki model yang dapat menerima data baru
gambar (kali ini tidak ditandai sebelumnya) dan kemudian model harus dapat mengklasifikasikannya sebagai
gambar anjing atau kucing.

Untuk tugas ini, kita akan menggunakan arsitektur Jaringan Saraf Konvolusional, yang sama dengan yang kita pelajari di
bab sebelumnya. Arsitektur ini menggunakan metode konvolusi untuk dapat memprediksi karakteristik
spesifik dari sebuah gambar sesuai dengan apa yang dipelajari dalam kumpulan pelatihan. Misalnya,
kita bisa mengatakan bahwa mungkin untuk merasakan perbedaan saat mencari kumis pada kucing atau moncong panjang di
seeking many other features based on what we have
dalam satu set pelatihan.

Solusi: Menggunakan Jaringan Saraf Konvolusional untuk mempelajari fitur gambar dan dengan demikian memprediksi apakah suatu
gambar berisi seekor anjing atau kucing.

Definisi Data

Ilmu Data, Pembelajaran Mendalam, Pembelajaran Mesin, Kecerdasan Buatan. Tidak ada yang masuk akal tanpa data,
banyak data (karena inioData Besarsemakin penting di zaman sekarang). Dan untuk tugas ini, kita akan memiliki
data berikut:

Conjunto de dados de treino: Teremos 12.500 imagens de cães e 12.500 imagens de gatos para o conjunto de
pelatihan.

Conjunto data validasi: Kami akan memiliki 12.500 gambar anjing dan kucing.

Kumpulan data tes: Kami akan memiliki 1.000 gambar anjing dan kucing.
Ini adalah sebuah pertanyaan di mana para pemula memiliki banyak keraguan. Mengapa kita membutuhkan data pelatihan, validasi
e tes tes? Kami menggunakan data pelatihan untuk melatih algoritma dan kemudian membuat model prediktif. Kami menggunakan
data validasi, untuk menilai model selama pelatihan. Kami menggunakan data pengujian untuk memvalidasi
kinerja model yang sudah dilatih, yaitu kami menyajikan data kepada model yang tidak pernah dilihatnya selama
pelatihan, untuk memastikan bahwa dia mampu membuat prediksi.

Struktur Kerja

Mari kita lakukan kegiatan berikut dalam pembangunan model Pengenalan Gambar dengan Jaringan
Neuron Jaringan Konvolusional di Python:

1- Visualisasi Data

Kita akan memulai pekerjaan kita dengan tugas visualisasi data dan analisis eksplorasi. Kita perlu
memahami data sebelum hal lain, seperti dimensi gambar, skala warna,
rincian bayangan dan jika gambar memiliki lebih banyak rincian yang tidak terkait langsung dengan anjing atau
kucing, seperti pada gambar di bawah ini! Lagipula, model harus belajar bahwa anjing yang berpakaian Hello
Kitty masih anjing!

2- Membangun Jaringan Syaraf Konvolusional

Langkah berikutnya adalah membangun arsitektur jaringan. Kami akan menentukan berapa banyak lapisan yang akan digunakan,
lapisan konvolusi dan pooling, fungsi aktivasi, metrik evaluasi, penurunan gradien dengan
backpropagation dan rincian lainnya. Kami akan membahas mengapa kami membuat pilihan kami.
3- Pelatihan

Dengan arsitektur yang telah ditentukan, kita dapat melatih jaringan kita, yang terdiri dari menyajikan data kepada
algoritma untuk agar pembelajaran berlangsung. Kami akan mendefinisikan hiperparameter dan berapa lama kami akan melatihnya
Mari kita manfaatkan dan berdiskusi tentang teknik untuk menghindari overfitting (ketika model terlalu menyesuaikan diri)
data latihan).

4- Membuat Prediksi

Akhirnya, kami akan menggunakan model yang dilatih untuk melakukan klasifikasi. Kami akan memberikan gambar baru kepada model.
dia ia harus mengklasifikasikan apakah gambar itu adalah anjing atau kucing! Dalam praktiknya, model tidak pernah membuat
klasifikasi dengan 100% kepastian. Apa yang dia lakukan adalah sebuah prediksi (agar lebih tepat, sebuah
inferensi) dan pekerjaan kami adalah memastikan bahwa prediksi ini memiliki tingkat akurasi setinggi mungkin.

Alat

Untuk pekerjaan ini, kita akan menggunakan, tentu saja, bahasa Python dengan Keras dan TensorFlow. Kami akan menjelaskan kepada Anda
apa saja pilihan framework dan setiap baris kode akan dijelaskan secara rinci. Mari kita pertimbangkan bahwa
Anda sudah mengenal bahasa Python dan tahu cara menjalankan Jupyter Notebook.

Bab 45–Pengenalan Gambar dengan

Jaringan Saraf Konvolusional dalam Python–Bagian
2

Mari kita mulai pekerjaan Pengakuan Gambar kita dengan Jaringan Saraf Konvolusional di
Python menjaga bahan mentah kita: data. Kita perlu mengunduh gambar dan mengorganisasikannya.
para então iniciar o trabalho.

Kita akan menggunakan dataset terkenal sebagai sumber [Link] dan Kucingditawarkan oleh Kaggle, portal tentang
Kompetisi Data Science, di mana bahkan Data Science Academy mempromosikannya di antara para siswa
terdaftar dalam Formasi Kompetisi DSA Machine Learning. Kaggle menawarkan berbagai dataset
publik yang dapat digunakan untuk Anda mengembangkan proyek Anda dan menyertakannya dalam portofolio Anda, sebuah yang sangat baik
cara untuk menunjukkan keterampilan Anda dalam Data Science dan Machine Learning. Kami menunjukkan cara membangun sebuah
portofolio proyek Data Science di sini: Persiapan Untuk Karir sebagai Ilmuwan Data.

Anda dapat mengunduh gambar di alamat inio:Anjing vs. Kucing. Tapi kami sudah mengunduh dan
kami sediakan untuk Anda bersama dengan Jupyter Notebook di repositori buku initidakGithub. Seperti ini
dataset ini cukup terkenal, sebagai alternatif, Anda dapat mengunduh yang ditawarkan oleh Microsoft Research
di alamat ini: Dataset Kucing dan Anjing Kaggle.

Setelah mengunduh gambar (Anda akan memerlukan sekitar 1 GB ruang disk untuk
gambar), kita perlu mengorganisir berkas-berkas dalam struktur direktori sebagai berikut:
Buat sebuah direktori (misalnya Cap45, tetapi bisa dengan nama apa pun yang Anda inginkan). Di dalamnya, buat 3 direktori lagi.
pastas: dataset_treino, dataset_validation dan dataset_teste. Jangan gunakan spasi dalam nama dan juga tidak ada aksen
dalam kata-kata, karena ini menyebabkan berbagai masalah dalam pemrograman.

Di dalam folder dataset_treino, buat dua folder lagi, cats (yang akan menerima 12.500 gambar kucing) dan
anjing (yang akan menerima 12.500 gambar anjing).

Di folder dataset_validation dan dataset_teste tidak perlu membuat subfolder dan di dalamnya kita akan menempatkan
12.500 gambar validasi dan 1.000 gambar uji, masing-masing. Gambar validasi akan
digunakan untuk mengevaluasi model selama pelatihan dan gambar pengujian akan digunakan untuk mengevaluasi model
setelah pelatihan.

Kita sekarang dapat melihat beberapa gambar menggunakan Jupyter Notebook, yang dapat Anda temukan di repositori
deste livro noGithub. Jika Anda tidak terbiasa dengan Jupyter Notebook, akses Bab 1 dari kursus
gratuitoPython Dasar-dasar Untuk Analisis Data.

Jika Anda telah membuat struktur direktori dengan benar, maka selanjutnya akan menunjukkan beberapa dari
imagens:
Jika gambar ditampilkan dengan benar, maka data siap untuk dieksplorasi. Itu adalah
apa yang akan kita lakukan di bab selanjutnya! Sampai saat itu.
Bab 46–Pengenalan Gambar dengan
Jaringan Saraf Konvolusional di Python–Bagian
3

Salah satu pertanyaan utama bagi mereka yang baru memulai di Machine Learning dan menghadapi Jaringan Saraf
Konvolusional, ini tentang bagaimana pembelajaran parameter (apa yang sebenarnya dilakukan algoritma
belajar selama pelatihan). Apa yang sebenarnya dilakukan ketika kita mempersembahkan sebuah gambar kepada sebuah
algoritma Jaringan Saraf Konvolusional?

Kami tahu bahwa di setiap lapisan konvolusi, jaringan mencoba memahami pola dasar. Sebagai contoh: Di
lapisan konvolusi pertama, jaringan mencoba mempelajari pola dan tepi gambar. Di lapisan kedua,
dia mencoba memahami bentuk / warna dan hal-hal lainnya. Sebuah lapisan akhir yang disebut lapisan sumber / lapisan
sepenuhnya terhubung mencoba mengklasifikasikan gambar.
Sebelum kita menyiapkan skrip dengan jaringan konvolusional kita, mari kita memahami bagaimana kita mendefinisikan
arsitektur jaringan dan pada lapisan mana parameter dipelajari.

Lapisan Masukan (Input Layer): Yang dilakukan oleh lapisan masukan adalah membaca gambar. Oleh karena itu, tidak ada
parameter yang harus dipelajari di sini.

Lapisan Konvolusional: pertimbangkan sebuah lapisan konvolusional yang menggunakan peta

dari sumber daya "l" sebagai masukan dan memiliki peta sumber daya "k" sebagai keluaran. Ukuran filter adalah "n * m".

Di sini, input memiliki l = 32 peta sumber daya sebagai input, k = 64 peta sumber daya sebagai output dan
ukuran filter adalah n = 3 dan m = 3. Penting untuk dipahami bahwa kita tidak hanya memiliki satu filter 3 * 3, tetapi, di dalam
benar, kami memiliki filter 3 * 3 * 32, karena input kami memiliki 32 dimensi. Dan sebagai keluaran dari yang pertama
lapisan konvolusional, kami mempelajari 64 filter berbeda 3 * 3 * 32 dengan total berat 'n * m * k * l'. Setelah itu,
ada sebuah istilah yang disebut bias untuk setiap peta sumber daya. Jadi, jumlah total parameter adalah "(n * m * l
+ 1) * k”.

Lapisan Pooling (Pooling Layer): Tidak ada parameter yang perlu dipelajari di lapisan pooling. Lapisan ini adalah
digunakan hanya untuk mengurangi ukuran dimensi gambar.

Obs: Kita dapat memiliki berbagai kombinasi lapisan konvolusi / lapisan pooling dalam arsitektur kita,
menjadi keputusan Ilmuwan Data atau Insinyur Kecerdasan Buatan.

Lapisan Terhubung Penuh (Fully Connected Layer): Di lapisan ini, semua unit masukan
memiliki bobot terpisah untuk setiap unit keluaran. Untuk masukan "n" dan keluaran "m", jumlah bobot adalah
n * m. Selain itu, lapisan ini memiliki bias untuk setiap simpul keluaran, jadi parameter yang dipelajari
(n + 1) * m

Lapisan Keluaran (Output Layer): Lapisan ini terhubung sepenuhnya, sehingga parameternya
(n + 1) m

Kesulitan utama dalam mendefinisikan arsitektur CNN adalah lapisan pertama yang sepenuhnya terhubung. Tidak
kita tahu dimensi dari lapisan yang sepenuhnya terhubung. Untuk menghitung ini, kita harus mulai dengan
ukuran gambar masukan dan menghitung ukuran setiap lapisan konvolusional.

Dalam kasus sederhana, ukuran lapisan yang sepenuhnya terhubung dihitung sebagai "ukuran_input - (ukuran_filter -
1)”. Misalnya, jika ukuran citra masukan adalah (50,50) dan filter adalah (3,3), maka (50 - (3-1)) = 48.
Namun ukuran gambar masukan dari jaringan konvolusional tidak boleh lebih kecil dari masukan, jadi
kita perlu mendefinisikan padding.
Untuk menghitung padding kita gunakan: ukuran_input + 2 * ukuran_padding - (ukuran_filter - 1). Untuk kasus di atas, (50 + (2
* 1)–(3–1) = 52–2 = 50) yang memberikan ukuran input yang sama. Sempurna, karena dengan cara ini kita tidak kehilangan
tidak ada detail dari gambar. Jika kita ingin secara eksplisit memperkecil gambar selama konvolusi,
kita dapat mendefinisikan sebuah langkah (stride).

Akhirnya, untuk menghitung jumlah parameter yang akan dipelajari jaringan, kita menggunakan: (n * m * k + 1) * f.
Kita akan melihat semua ini dalam kode Python di bab berikutnya!

Jika Anda menginginkan lebih banyak detail tentang cara menentukan arsitektur jaringan, silakan merujuk pada makalah terkenal dan luar biasa dari
AlexNet: Klasifikasi ImageNet dengan Jaringan Saraf Konvolusional Dalam.