Pengantar Pembelajaran Mesin

Kursus lengkap dalam bahasa Rusia dapat ditemukan di tautan ini .
Kursus bahasa Inggris asli tersedia di tautan ini .



Kuliah baru dijadwalkan setiap 2-3 hari.

Wawancara dengan Sebastian Trun, CEO Udacity

"Halo lagi, aku Paige dan kamu adalah tamuku hari ini, Sebastian."
- Hai, saya Sebastian!
- ... seorang pria yang memiliki karir yang luar biasa, yang berhasil melakukan banyak hal luar biasa! Anda adalah salah satu pendiri Udacity, Anda mendirikan Google X, Anda adalah profesor di Stanford. Anda telah melakukan penelitian luar biasa dan pembelajaran mendalam sepanjang karir Anda. Apa yang paling memberi Anda kepuasan dan di bidang mana Anda menerima imbalan paling banyak untuk pekerjaan yang dilakukan?
- Terus terang, saya sangat suka berada di Lembah Silikon! Saya suka berada di sebelah orang-orang yang jauh lebih pintar daripada saya, dan saya selalu menganggap teknologi sebagai alat yang mengubah aturan main dalam berbagai cara - dari pendidikan hingga logistik, perawatan kesehatan, dll. Semua ini berubah begitu cepat, dan ada keinginan yang luar biasa untuk menjadi peserta dalam perubahan ini, untuk mengamatinya. Anda melihat sekeliling Anda dan memahami bahwa sebagian besar yang Anda lihat di sekitar tidak berfungsi sebagaimana mestinya - Anda selalu dapat menemukan sesuatu yang baru!
- Nah, ini adalah pandangan yang sangat optimis tentang teknologi! Apa eureka terbesar sepanjang karir Anda?
- Tuhan, ada banyak sekali! Saya ingat suatu hari ketika Larry Page menelepon saya dan menyarankan untuk membuat mobil autopilot yang dapat melewati semua jalan di California. Pada saat itu saya dianggap ahli, saya mendapat peringkat di antara mereka dan, saya adalah orang yang mengatakan "tidak, ini tidak bisa dilakukan." Setelah itu, Larry meyakinkan saya bahwa, pada prinsipnya, adalah mungkin untuk melakukan ini, Anda hanya perlu memulai dan mencoba. Dan kami berhasil! Ini adalah saat ketika saya menyadari bahwa bahkan para ahli pun salah dan mengatakan "tidak" kita 100% pesimistis. Saya pikir kita harus lebih terbuka terhadap yang baru.
- Atau, misalnya, jika Larry Page memanggil Anda dan berkata, "Hei, lakukan hal yang keren seperti Google X" dan Anda mendapatkan sesuatu yang sangat keren!
- Ya, itu sudah pasti, tidak perlu mengeluh! Maksud saya, semua ini adalah proses yang melewati banyak diskusi tentang cara implementasi. Saya benar-benar beruntung bisa bekerja dan saya bangga akan hal itu, di Google X dan proyek lainnya.
- Luar biasa! Jadi, kursus ini adalah tentang bekerja dengan TensorFlow. Apakah Anda memiliki pengalaman menggunakan TensorFlow atau mungkin Anda kenal (dengar) dengannya?
- Ya! Saya benar-benar menyukai TensorFlow, tentu saja! Di laboratorium saya sendiri, kami sering menggunakannya dan banyak, salah satu karya paling signifikan berdasarkan TensorFlow dirilis sekitar dua tahun lalu. Kami belajar bahwa iPhone dan Android bisa lebih efektif dalam mendeteksi kanker kulit daripada dokter kulit terbaik di dunia. Kami menerbitkan penelitian kami di Nature dan ini menciptakan semacam keributan di bidang kedokteran.
- Kedengarannya luar biasa! Jadi, Anda tahu dan cinta TensorFlow, yang sangat bagus! Sudahkah Anda bekerja dengan TensorFlow 2.0?
- Tidak, sayangnya saya belum punya waktu.
- Dia akan luar biasa! Semua siswa dalam kursus ini akan bekerja dengan versi ini.
- Aku iri pada mereka! Saya pasti akan mencobanya!
- Hebat! Dalam kursus kami ada banyak siswa yang dalam kehidupan mereka tidak pernah terlibat dalam pembelajaran mesin, dari kata "sepenuhnya". Bagi mereka, bidang mungkin baru, mungkin bagi seseorang pemrograman itu sendiri akan baru. Apa saran Anda untuk mereka?
- Saya ingin mereka tetap terbuka - untuk ide, teknik, solusi, posisi baru. Pembelajaran mesin sebenarnya lebih mudah daripada pemrograman. Dalam proses pemrograman, Anda perlu memperhitungkan setiap kasus dalam sumber data, mengadaptasi logika program dan aturan untuk itu. Pada saat ini, menggunakan TensorFlow dan pembelajaran mesin, Anda pada dasarnya melatih komputer menggunakan contoh, membiarkan komputer menemukan aturannya sendiri.
- Ini sangat menarik! Saya tidak sabar untuk memberi tahu siswa dalam kursus ini sedikit lebih banyak tentang pembelajaran mesin! Sebastian, terima kasih telah meluangkan waktu untuk datang kepada kami hari ini!
- terima kasih Tetap berkomunikasi!

Apa itu pembelajaran mesin?

Jadi, mari kita mulai dengan tugas berikut - memberikan nilai input dan output.



Ketika Anda memiliki nilai 0 sebagai nilai input, maka 32 sebagai nilai output. Ketika Anda memiliki 8 sebagai nilai input, maka 46,4 sebagai nilai output. Ketika Anda memiliki 15 sebagai nilai input, maka 59 sebagai nilai output, dan seterusnya.

Lihatlah lebih dekat nilai-nilai ini dan izinkan saya mengajukan pertanyaan kepada Anda. Bisakah Anda menentukan apa yang akan dihasilkan jika kita mendapatkan 38 di input?



Jika Anda menjawab 100,4, maka Anda benar!



Jadi, bagaimana kita bisa menyelesaikan masalah ini? Jika Anda melihat dengan cermat nilai-nilai itu, Anda bisa melihat bahwa itu terkait dengan ekspresi:



Di mana C - derajat Celcius (nilai input), F - Fahrenheit (nilai output).

Apa yang baru saja dilakukan otak Anda - membandingkan nilai input dan nilai output dan menemukan model umum (koneksi, ketergantungan) di antaranya - inilah yang dilakukan pembelajaran mesin.

Berdasarkan nilai input dan output, algoritma pembelajaran mesin akan menemukan algoritma yang sesuai untuk mengubah nilai input menjadi output. Ini dapat direpresentasikan sebagai berikut:



Mari kita lihat sebuah contoh. Bayangkan kita ingin mengembangkan sebuah program yang akan mengubah derajat Celsius ke derajat Fahrenheit menggunakan rumus F = C * 1.8 + 32 .



Solusinya, ketika mendekati dari sudut pandang pengembangan perangkat lunak tradisional, dapat diimplementasikan dalam bahasa pemrograman apa pun menggunakan fungsi:



Jadi apa yang kita miliki? Fungsi mengambil nilai input C, kemudian menghitung nilai output F menggunakan algoritma eksplisit, dan kemudian mengembalikan nilai yang dihitung.



Di sisi lain, dalam pendekatan pembelajaran mesin, kami hanya memiliki nilai input dan output, tetapi bukan algoritma itu sendiri:



Pendekatan pembelajaran mesin bergantung pada penggunaan jaringan saraf untuk menemukan hubungan antara nilai input dan output.



Anda dapat menganggap jaringan saraf sebagai tumpukan lapisan, yang masing-masing terdiri dari matematika (rumus) yang sebelumnya diketahui dan variabel internal. Nilai input memasuki jaringan saraf dan melewati tumpukan lapisan neuron. Saat melewati lapisan, nilai input dikonversi sesuai dengan matematika (rumus yang diberikan) dan nilai-nilai variabel internal lapisan, menghasilkan nilai output.

Agar jaringan saraf dapat mempelajari dan menentukan hubungan yang benar antara nilai input dan output, kita perlu melatihnya - melatih.

Kami melatih jaringan saraf melalui upaya berulang untuk mencocokkan nilai input dengan yang output.



Dalam proses pelatihan, "fitting" (pemilihan) dari nilai-nilai variabel internal di lapisan jaringan saraf terjadi sampai jaringan belajar untuk menghasilkan nilai-nilai output yang sesuai dengan nilai input yang sesuai.

Seperti yang akan kita lihat nanti, untuk melatih jaringan saraf dan memungkinkannya untuk memilih nilai-nilai variabel internal yang paling cocok, ribuan atau puluhan ribu iterasi (pelatihan) dilakukan.



Sebagai versi sederhana untuk memahami pembelajaran mesin, Anda dapat membayangkan algoritma pembelajaran mesin sebagai fungsi yang memilih nilai-nilai variabel internal sehingga nilai input yang benar sesuai dengan nilai output yang benar.

Ada banyak jenis arsitektur jaringan saraf. Namun, apa pun arsitektur yang Anda pilih, matematika di dalamnya (perhitungan mana yang dilakukan dan dalam urutan apa) akan tetap tidak berubah selama pelatihan. Alih-alih mengubah matematika, variabel internal (bobot dan offset) berubah selama pelatihan.

Misalnya, dalam tugas mengkonversi dari derajat Celcius ke Fahrenheit, model dimulai dengan mengalikan nilai input dengan angka tertentu (berat) dan menambahkan nilai lain (offset). Pelatihan model terdiri dari menemukan nilai-nilai yang cocok untuk variabel-variabel ini, tanpa mengubah operasi multiplikasi dan penambahan yang dilakukan.

Tapi satu hal keren untuk dipikirkan! Jika Anda memecahkan masalah konversi derajat Celcius ke Fahrenheit, yang ditunjukkan dalam video dan dalam teks di bawah ini, Anda mungkin menyelesaikannya karena Anda memiliki pengalaman atau pengetahuan sebelumnya tentang cara melakukan konversi semacam ini dari derajat Celcius ke Fahrenheit. Misalnya, Anda mungkin tahu bahwa 0 derajat Celcius sesuai dengan 32 derajat Fahrenheit. Di sisi lain, sistem berbasis pembelajaran mesin tidak memiliki pengetahuan pendukung sebelumnya untuk menyelesaikan masalah. Mereka belajar untuk memecahkan masalah seperti itu tidak berdasarkan pengetahuan sebelumnya dan dalam ketidakhadiran lengkap mereka.

Cukup bicara - beralihlah ke bagian praktis dari perkuliahan!

CoLab: konversikan derajat Celcius ke derajat Fahrenheit

Versi Rusia dari kode sumber CoLab dan versi bahasa Inggris dari kode sumber CoLab .

Dasar-dasar: mempelajari model pertama

Selamat datang di CoLab, tempat kami akan melatih model pembelajaran mesin pertama kami!

Kami akan berusaha menjaga kesederhanaan materi yang disajikan dan hanya memperkenalkan konsep dasar yang diperlukan untuk pekerjaan itu. CoLabs selanjutnya akan berisi teknik yang lebih maju.

Tugas yang akan kita selesaikan adalah konversi derajat Celcius ke derajat Fahrenheit. Rumus konversi adalah sebagai berikut:

$$

$$f = c \ kali 1,8 + 32$$

Tentu saja, akan lebih mudah untuk hanya menulis fungsi konversi dengan Python atau bahasa pemrograman lain yang akan melakukan perhitungan langsung, tetapi dalam hal ini tidak akan menjadi pembelajaran mesin :)

Sebagai gantinya, kami memasukkan input TensorFlow derajat input kami yang tersedia Celcius (0, 8, 15, 22, 38) dan derajat Fahrenheit yang sesuai (32, 46, 59, 72, 100). Kemudian kita akan melatih model sedemikian rupa sehingga kira-kira sesuai dengan rumus di atas.

Ketergantungan Impor

Hal pertama yang kami impor adalah TensorFlow . Di sini dan di bawah ini kami menyebutnya dengan singkat tf . Kami juga mengonfigurasi tingkat kesalahan hanya logging.

Selanjutnya, impor NumPy sebagai np . Numpy membantu kami menyajikan data sebagai daftar berperforma tinggi.

 from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf tf.logging.set_verbosity(tf.logging.ERROR) import numpy as np 

Persiapan data pelatihan

Seperti yang kita lihat sebelumnya, teknik pembelajaran mesin dengan guru didasarkan pada pencarian algoritma untuk mengkonversi data input ke output. Karena tugas CoLab ini adalah membuat model yang dapat menghasilkan hasil konversi derajat Celcius ke derajat Fahrenheit, kami akan membuat dua daftar - celsius_q dan fahrenheit_a , yang kami gunakan saat melatih model kami.

 celsius_q = np.array([-40, -10, 0, 8, 15, 22, 38], dtype=float) fahrenheit_a = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=float) for i,c in enumerate(celsius_q): print("{}   = {}  ".format(c, fahrenheit_a[i])) 

-40.0 = -40.0
-10.0 = 14.0
0.0 = 32.0
8.0 = 46.0
15.0 = 59.0
22.0 = 72.0
38.0 = 100.0

Beberapa terminologi pembelajaran mesin:

• Properti adalah nilai input dari model kami. Dalam hal ini, nilai satuan adalah derajat Celcius.
• Label adalah nilai output yang diprediksi model kami. Dalam hal ini, nilai satuan adalah derajat Fahrenheit.
• Contohnya adalah sepasang nilai input-output yang digunakan untuk pelatihan. Dalam kasus ini, ini adalah sepasang nilai dari celsius_q dan fahrenheit_a bawah indeks tertentu, misalnya, (22,72).

Buat model

Selanjutnya kita buat model. Kami akan menggunakan model yang paling disederhanakan - model jaringan yang sepenuhnya terhubung (jaringan Dense ). Karena tugasnya cukup sepele, jaringan juga akan terdiri dari satu lapisan dengan satu neuron.

Membangun jaringan

Kami akan memberi nama layer l0 ( l ayer dan nol) dan membuatnya dengan menginisialisasi tf.keras.layers.Dense dengan parameter berikut:

• input_shape=[1] - parameter ini menentukan dimensi parameter input - nilai tunggal. 1 × 1 matriks dengan nilai tunggal. Karena ini adalah lapisan pertama (dan satu-satunya), dimensi data input sesuai dengan dimensi keseluruhan model. Satu-satunya nilai adalah nilai floating point yang mewakili derajat Celcius.
• units=1 - parameter ini menentukan jumlah neuron dalam lapisan. Jumlah neuron menentukan berapa banyak variabel lapisan internal yang akan digunakan untuk pelatihan dalam menemukan solusi untuk masalah tersebut. Karena ini adalah lapisan terakhir, dimensinya sama dengan dimensi hasil - nilai keluaran model - angka titik-mengambang tunggal yang mewakili derajat Fahrenheit. (Dalam jaringan multilayer, ukuran dan bentuk lapisan input_shape harus sesuai dengan ukuran dan bentuk lapisan berikutnya).

 l0 = tf.keras.layers.Dense(units=1, input_shape=[1]) 

Ubah layer menjadi model

Setelah lapisan didefinisikan mereka perlu dikonversi ke model. Sequential mengambil argumen daftar lapisan dalam urutan di mana mereka harus diterapkan - dari nilai input ke nilai output.

Model kami hanya memiliki satu lapisan - l0 .

 model = tf.keras.Sequential([l0]) 

Catatan
Cukup sering, Anda akan menemukan definisi layer secara langsung dalam fungsi model, daripada deskripsi awal dan penggunaan selanjutnya:

 model = tf.keras.Sequential([ tf.keras.layers.Dense(units=1, input_shape=[1]) ]) 

Kami mengkompilasi model dengan fungsi kehilangan dan optimisasi

Sebelum pelatihan, model harus dikompilasi (dirakit). Saat menyusun untuk pelatihan, Anda perlu:

• fungsi kerugian - cara mengukur seberapa jauh nilai prediksi dari nilai output yang diinginkan (perbedaan terukur disebut "kerugian").
• fungsi optimasi - cara untuk menyesuaikan variabel internal untuk mengurangi kerugian.

 model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(0.1)) 

Fungsi kerugian dan fungsi optimisasi digunakan selama pelatihan model ( model.fit(...) disebutkan di bawah) untuk melakukan perhitungan awal pada setiap titik dan kemudian mengoptimalkan nilainya.

Tindakan menghitung kerugian saat ini dan peningkatan selanjutnya dari nilai-nilai ini dalam model adalah pelatihan apa (satu iterasi).

Selama pelatihan, fungsi optimisasi digunakan untuk menghitung penyesuaian nilai-nilai variabel internal. Tujuannya adalah untuk menyesuaikan nilai-nilai variabel internal sedemikian rupa dalam model (dan ini, pada kenyataannya, adalah fungsi matematika) sehingga mereka mencerminkan sedekat mungkin ekspresi yang ada untuk mengkonversi derajat Celcius ke derajat Fahrenheit.

TensorFlow menggunakan analisis numerik untuk melakukan operasi optimasi semacam ini, dan semua kompleksitas ini tersembunyi dari mata kami, jadi kami tidak akan membahas detail dalam kursus ini.

Apa yang berguna untuk diketahui tentang opsi-opsi ini:

Fungsi kerugian (kesalahan standar) dan fungsi optimisasi (Adam) yang digunakan dalam contoh ini adalah standar untuk model sederhana seperti itu, tetapi banyak yang lain tersedia di samping mereka. Pada tahap ini, kami tidak peduli bagaimana fungsi ini bekerja.

Yang harus Anda perhatikan adalah fungsi optimasi dan parameternya adalah koefisien learning rate , yang dalam contoh kami adalah 0.1 . Ini adalah ukuran langkah yang digunakan ketika menyesuaikan nilai internal variabel. Jika nilainya terlalu kecil, akan membutuhkan terlalu banyak iterasi pelatihan untuk melatih model. Terlalu banyak - akurasi turun. Menemukan nilai yang baik untuk koefisien tingkat pembelajaran memerlukan beberapa coba-coba, biasanya terletak pada kisaran 0.01 (secara default) hingga 0.1 .

Kami melatih model

Pelatihan model dilakukan dengan metode fit .

Selama pelatihan, model menerima derajat Celcius pada input, melakukan transformasi menggunakan nilai-nilai variabel internal (disebut "bobot") dan mengembalikan nilai yang harus sesuai dengan derajat Fahrenheit. Karena nilai awal bobot diatur secara sewenang-wenang, nilai yang dihasilkan akan jauh dari nilai yang benar. Perbedaan antara hasil yang diinginkan dan aktual dihitung menggunakan fungsi kerugian, dan fungsi optimisasi menentukan bagaimana bobot harus disesuaikan.

Siklus perhitungan, perbandingan, dan penyesuaian ini dikendalikan dalam metode fit . Argumen pertama adalah nilai input, argumen kedua adalah nilai output yang diinginkan. Argumen epochs menentukan berapa kali siklus pelatihan ini harus diselesaikan. Argumen verbose mengontrol level logging.

 history = model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False) print("  ") 

Dalam video-video berikut, kami akan menyelami rincian tentang bagaimana semua ini bekerja dan bagaimana tepatnya lapisan yang terhubung sepenuhnya (lapisan Dense ) "di bawah tenda".

Tampilkan statistik pelatihan

Metode fit mengembalikan objek yang berisi informasi tentang perubahan kerugian dengan setiap iterasi berikutnya. Kita dapat menggunakan objek ini untuk membuat jadwal kerugian yang sesuai. Kehilangan tinggi berarti bahwa derajat Fahrenheit yang diprediksi oleh model jauh dari nilai sebenarnya dalam array fahrenheit_a .

Untuk visualisasi, kita akan menggunakan Matplotlib . Seperti yang Anda lihat, model kami meningkat dengan sangat cepat di awal, dan kemudian mencapai peningkatan yang stabil dan lambat sampai hasilnya menjadi "dekat" -sempurna di akhir pelatihan.

 import matplotlib.pyplot as plt plt.xlabel('Epoch') plt.ylabel('Loss') plt.plot(history.history['loss']) 

Kami menggunakan model untuk prediksi.

Sekarang kami memiliki model yang telah dilatih tentang nilai input celsius_q dan nilai output fahrenheit_a untuk menentukan hubungan di antara mereka. Kita dapat menggunakan metode prediksi untuk menghitung derajat Fahrenheit yang sebelumnya kita tidak tahu derajat Celsius yang sesuai.

Misalnya, berapa 100,0 derajat Celcius Fahrenheit? Coba tebak sebelum Anda menjalankan kode di bawah ini.

 print(model.predict([100.0])) 

Kesimpulan:

[[211.29639]]


Jawaban yang benar adalah 100 × 1,8 + 32 = 212, jadi model kami melakukannya dengan cukup baik!

Ulasan

• Kami membuat model menggunakan layer Dense .
• Kami melatihnya dengan 3.500 contoh (7 pasang nilai, 500 iterasi pelatihan)

Model kami menyesuaikan nilai-nilai variabel internal (bobot) di lapisan Dense sedemikian rupa untuk mengembalikan nilai derajat Fahrenheit yang benar ke nilai input sembarang derajat Celcius.

Kami melihat bobotnya

Mari kita tampilkan nilai-nilai variabel internal layer Dense .

 print("   : {}".format(l0.get_weights())) 

Kesimpulan:

    : [array([[1.8261501]], dtype=float32), array([28.681389], dtype=float32)] 

Nilai variabel pertama mendekati ~ 1,8, dan yang kedua hingga ~ 32. Nilai-nilai ini (1,8 dan 32) adalah nilai langsung dalam rumus untuk mengkonversi derajat Celcius ke derajat Fahrenheit.

Ini benar-benar sangat dekat dengan nilai aktual dalam rumus! Kami akan mempertimbangkan hal ini secara lebih rinci dalam video berikutnya, di mana kami menunjukkan cara kerja lapisan Dense , tetapi untuk sekarang Anda hanya perlu tahu bahwa satu neuron dengan input dan output tunggal berisi matematika sederhana - y = mx + b (sebagai persamaan direct), yang tidak lebih dari rumus kami untuk mengonversi derajat Celsius ke derajat Fahrenheit, f = 1.8c + 32 .

Karena representasi yang sama, nilai-nilai variabel internal model harus menyatu dengan yang disajikan dalam rumus aktual, yang terjadi pada akhirnya.

Dengan adanya neuron tambahan, nilai input tambahan dan nilai output, formula menjadi sedikit lebih rumit, tetapi esensinya tetap sama.

Sedikit eksperimen

Untuk bersenang-senang! Apa yang terjadi jika kita membuat lebih banyak lapisan Dense dengan lebih banyak neuron, yang pada gilirannya akan mengandung lebih banyak variabel internal?

 l0 = tf.keras.layers.Dense(units=4, input_shape=[1]) l1 = tf.keras.layers.Dense(units=4) l2 = tf.keras.layers.Dense(units=1) model = tf.keras.Sequential([l0, l1, l2]) model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(0.1)) model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False) print("  ") print(model.predict([100.0])) print(" ,  100    {}  ".format(model.predict([100.0]))) print("    l0: {}".format(l0.get_weights())) print("    l1: {}".format(l1.get_weights())) print("    l2: {}".format(l2.get_weights())) 

Kesimpulan:

    [[211.74748]]  ,  100    [[211.74748]]       l0: [array([[-0.5972079 , -0.05531882, -0.00833384, -0.10636603]], dtype=float32), array([-3.0981746, -1.8776944, 2.4708805, -2.9092448], dtype=float32)]     l1: [array([[ 0.09127654, 1.1659832 , -0.61909443, 0.3422218 ], [-0.7377194 , 0.20082018, -0.47870865, 0.30302727], [-0.1370897 , -0.0667181 , -0.39285263, -1.1399261 ], [-0.1576551 , 1.1161333 , -0.15552482, 0.39256814]], dtype=float32), array([-0.94946504, -2.9903848 , 2.9848468 , -2.9061244 ], dtype=float32)]     l2: [array([[-0.13567649], [-1.4634581 ], [ 0.68370366], [-1.2069695 ]], dtype=float32), array([2.9170544], dtype=float32)] 

Seperti yang mungkin Anda perhatikan, model saat ini juga mampu memprediksi derajat Fahrenheit dengan cukup baik. Namun, jika kita melihat nilai-nilai variabel internal (bobot) neuron demi lapis, maka kita tidak akan melihat nilai apa pun yang mirip dengan 1,8 dan 32. Kompleksitas tambahan dari model menyembunyikan bentuk "sederhana" dari konversi derajat Celcius ke derajat Fahrenheit.

Tetap terhubung dan di bagian selanjutnya kita akan melihat bagaimana lapisan padat bekerja "di bawah tenda".

Ringkasan Singkat

Selamat! Anda baru saja melatih model pertama Anda. Dalam praktiknya, kami melihat bagaimana, dengan nilai input dan output, model belajar mengalikan nilai input dengan 1,8 dan menambahkan 32 untuk mendapatkan hasil yang benar.



Ini sangat mengesankan, mengingat berapa banyak baris kode yang perlu kami tulis:

 l0 = tf.keras.layers.Dense(units=1, input_shape=[1]) model = tf.keras.Sequential([l0]) model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(0.1)) history = model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False) model.predict([100.0]) 

Contoh di atas adalah rencana umum untuk semua program pembelajaran mesin. Anda akan menggunakan konstruksi serupa untuk membuat dan melatih jaringan saraf dan untuk memecahkan masalah berikutnya.

Proses pelatihan

Proses pelatihan (berlangsung dalam metode model.fit(...)) terdiri dari urutan tindakan yang sangat sederhana, yang hasilnya harus berupa nilai variabel internal yang memberikan hasil sedekat mungkin dengan aslinya. Proses optimasi dimana hasil tersebut dicapai, disebut gradient descent , menggunakan analisis numerik untuk menemukan nilai yang paling cocok untuk variabel internal model.

Untuk terlibat dalam pembelajaran mesin, Anda, pada prinsipnya, tidak perlu memahami detail ini. Tetapi bagi mereka yang masih tertarik untuk belajar lebih banyak: penurunan gradien melalui iterasi mengubah nilai parameter sedikit, "menarik" mereka ke arah yang benar sampai hasil terbaik diperoleh. Dalam hal ini, "hasil terbaik" (nilai terbaik) berarti bahwa setiap perubahan parameter selanjutnya hanya akan memperburuk hasil model. Fungsi yang mengukur seberapa baik atau buruk model pada setiap iterasi disebut “fungsi kerugian”, dan tujuan dari setiap “tarikan” (penyesuaian nilai internal) adalah untuk mengurangi nilai fungsi kerugian.

Proses pelatihan dimulai dengan blok "distribusi langsung", di mana parameter input pergi ke input jaringan saraf, ikuti neuron tersembunyi dan kemudian pergi ke akhir pekan. Model kemudian menerapkan transformasi internal pada nilai input dan variabel internal untuk memprediksi respons.

Dalam contoh kami, nilai input adalah suhu dalam derajat Celcius dan model memperkirakan nilai yang sesuai dalam derajat Fahrenheit.



Segera setelah nilainya diprediksi, perbedaan antara nilai yang diprediksi dan yang benar dihitung. Perbedaannya disebut "kehilangan" dan merupakan bentuk pengukuran seberapa baik model bekerja. Nilai kerugian dihitung oleh fungsi kerugian, yang kami tentukan oleh salah satu argumen saat memanggil metode model.compile(...).

Setelah menghitung nilai kerugian, variabel internal (bobot dan perpindahan) dari semua lapisan jaringan saraf disesuaikan untuk meminimalkan nilai kehilangan untuk memperkirakan nilai output ke nilai referensi awal yang benar.



Proses pengoptimalan ini disebut gradient descent . Algoritma optimisasi spesifik digunakan untuk menghitung nilai baru untuk setiap variabel internal ketika metode dipanggil model.compile(...). Dalam contoh di atas, kami menggunakan algoritme pengoptimalan Adam.

Memahami prinsip-prinsip proses pelatihan tidak diperlukan untuk kursus ini, namun, jika Anda cukup ingin tahu Anda dapat menemukan informasi lebih lanjut tentang Google Crash Course(Terjemahan dan bagian praktis dari seluruh kursus diatur dalam rencana penulis untuk publikasi).

Pada titik ini, Anda harus sudah mengenal istilah-istilah berikut:

• Properti : nilai input dari model kami;
• Contoh : pasangan input + output;
• Tag : nilai output model;
• Layers : kumpulan node yang bergabung bersama dalam jaringan saraf;
• Model : representasi jaringan saraf Anda;
• Padat dan terhubung sepenuhnya : setiap simpul dalam satu lapisan terhubung ke setiap simpul dari lapisan sebelumnya.
• Bobot dan offset : model variabel internal;
• Kehilangan : perbedaan antara nilai output yang diinginkan dan nilai output aktual dari model;
• MSE : , , , .
• : , - ;
• : ;
• : «» ;
• : ;
• : ;
• : ;
• Kembali propagasi : menghitung nilai-nilai variabel internal sesuai dengan algoritma optimasi mulai dari lapisan keluaran dan menuju lapisan input melalui semua lapisan menengah.

Sense layers

Pada bagian sebelumnya, kami menciptakan model yang mengubah derajat Celsius ke derajat Fahrenheit, menggunakan jaringan saraf sederhana untuk menemukan hubungan antara derajat Celcius dan derajat Fahrenheit.

Jaringan kami terdiri dari satu lapisan yang sepenuhnya terhubung. Tapi apa itu lapisan yang terhubung sepenuhnya? Untuk mengetahuinya, mari buat jaringan saraf yang lebih kompleks dengan 3 parameter input, satu layer tersembunyi dengan dua neuron dan satu layer output dengan satu neuron.



Ingatlah bahwa jaringan saraf dapat dibayangkan sebagai seperangkat lapisan, yang masing-masing terdiri dari node yang disebut neuron. Neuron pada setiap level dapat dihubungkan ke neuron dari setiap lapisan berikutnya. Jenis lapisan di mana setiap neuron dari satu lapisan terhubung satu sama lain neuron dari lapisan berikutnya disebut sepenuhnya terhubung (sepenuhnya terhubung) atau lapisan padat ( Dense-pemain).



Jadi, ketika kita menggunakan lapisan yang terhubung penuh keras, kita semacam menginformasikan bahwa neuron dari lapisan ini harus terhubung ke semua neuron dari lapisan sebelumnya.

Untuk membuat jaringan saraf di atas, ekspresi berikut cukup bagi kami:

 hidden = tf.keras.layers.Dense(units=2, input_shape=[3]) output = tf.keras.layers.Dense(units=1) model = tf.keras.Sequential([hidden, output]) 

Jadi, kami menemukan apa itu neuron dan bagaimana mereka berhubungan. Tetapi bagaimana sebenarnya lapisan yang terhubung sepenuhnya berfungsi?

Untuk memahami apa yang sebenarnya terjadi di sana dan apa yang mereka lakukan, kita perlu melihat "di balik tudung" dan membongkar matematika internal neuron.



Bayangkan bahwa model kami menerima tiga parameter - 1, 2, 3, dan 1, 2 3- neuron jaringan kami. Ingat kami mengatakan bahwa neuron memiliki variabel internal? Jadi, w * dan b * adalah variabel internal yang sama dari neuron, juga dikenal sebagai bobot dan perpindahan. Nilai-nilai dari variabel-variabel ini yang disesuaikan dalam proses pembelajaran untuk mendapatkan hasil paling akurat dari membandingkan nilai input dengan output.



Yang pasti harus Anda ingat adalah bahwa matematika internal neuron tetap tidak berubah . Dengan kata lain, selama proses pelatihan, hanya bobot dan perpindahan yang berubah .

Ketika Anda mulai belajar pembelajaran mesin, mungkin terasa aneh - fakta bahwa itu benar-benar berfungsi, tetapi itulah cara pembelajaran mesin bekerja!

Mari kita kembali ke contoh konversi derajat Celsius ke derajat Fahrenheit.



Dengan satu neuron, kita hanya memiliki satu berat dan satu perpindahan. Apakah kamu tahu? Persis seperti inilah rumus untuk mengubah derajat Celsius ke derajat Fahrenheit. Jika kita mengganti w11nilainya 1.8, dan bukannya b1- 32, kita mendapatkan model transformasi akhir!

Jika kita kembali ke hasil model kita dari bagian praktis, kita memperhatikan fakta bahwa indikator bobot dan perpindahan “dikalibrasi” sedemikian rupa sehingga kira-kira sesuai dengan nilai-nilai dari formula.

Kami sengaja menciptakan contoh praktis untuk menunjukkan perbandingan yang tepat antara bobot dan offset. Dengan menerapkan pembelajaran mesin, kita tidak akan pernah bisa membandingkan nilai variabel dengan algoritma target dengan cara ini, seperti pada contoh di atas. Bagaimana kita bisa melakukan ini? Tidak mungkin, karena kami bahkan tidak tahu algoritma target!

Memecahkan masalah pembelajaran mesin, kami menguji berbagai arsitektur jaringan saraf dengan jumlah neuron yang berbeda di dalamnya - dengan coba-coba kami menemukan arsitektur dan model yang paling akurat dan berharap mereka memecahkan masalah dalam proses pembelajaran. Pada bagian praktis berikutnya, kita akan dapat mempelajari contoh-contoh spesifik dari pendekatan ini.

Tetap berkomunikasi, karena sekarang kesenangan dimulai!

Ringkasan

Dalam pelajaran ini kita belajar pendekatan dasar dalam pembelajaran mesin dan belajar bagaimana lapisan yang terhubung sepenuhnya ( Dense-layers) bekerja. Anda melatih model pertama Anda untuk mengonversi derajat Celsius ke derajat Fahrenheit. Anda juga mempelajari istilah dasar yang digunakan dalam pembelajaran mesin, seperti properti, contoh, label. Anda, antara lain, menulis baris utama kode dengan Python, yang merupakan tulang punggung dari algoritma pembelajaran mesin apa pun. Anda melihat bahwa dalam beberapa baris kode Anda dapat membuat, melatih dan meminta prediksi dari jaringan saraf menggunakan TensorFlowdan Keras.

... dan ajakan bertindak standar - daftar, beri nilai tambah, dan bagikan :)


YouTube: https://youtube.com/channel/ashmig
Telegram: https://t.me/ashmig
VK: https://vk.com/ashmig