Tutorial Keras: Deep Learning di Python

Tutorial Keras ini memperkenalkan Anda pada deep learning di Python: pelajari cara melakukan prapemrosesan data, memodelkan, mengevaluasi, dan mengoptimalkan jaringan saraf.

Diperbarui 28 Sep 2026 · 15 mnt Baca

Jelajahi bersama AI

ChatGPT Claude Perplexity

Sampai di titik ini, Anda mungkin sudah mengenal machine learning, cabang ilmu komputer yang mempelajari perancangan algoritma yang dapat belajar. Hari ini, Anda akan berfokus pada deep learning, subbidang machine learning yang merupakan sekumpulan algoritma yang terinspirasi oleh struktur dan fungsi otak. Algoritma ini biasanya disebut Artificial Neural Networks (ANN). Deep learning adalah salah satu bidang terpanas dalam data science dengan banyak studi kasus yang menghasilkan temuan mencengangkan di robotika, pengenalan gambar, dan Kecerdasan Buatan (AI).

Salah satu pustaka Python paling kuat dan mudah digunakan untuk mengembangkan dan mengevaluasi model deep learning adalah Keras; Pustaka ini membungkus pustaka komputasi numerik Theano dan TensorFlow yang efisien. Keuntungannya terutama adalah Anda dapat mulai bekerja dengan jaringan saraf dengan cara yang mudah dan menyenangkan.

banner jalur keterampilan deep learning di python

Tutorial Keras untuk pemula hari ini akan memperkenalkan Anda pada dasar-dasar deep learning Python:

Pertama, Anda akan mempelajari apa itu Artificial Neural Network
Kemudian, tutorial akan menunjukkan langkah demi langkah cara menggunakan Python dan pustakanya untuk memahami, mengeksplorasi, dan memvisualisasikan data,
Cara melakukan prapemrosesan data: Anda akan belajar cara membagi data menjadi train dan test set serta menstandarkan data,
Cara membangun multi-layer perceptron untuk tugas klasifikasi,
Cara mengompilasi dan memasangkan (fit) data ke model tersebut,
Cara menggunakan model untuk memprediksi nilai target, dan
Cara mengevaluasi model yang telah Anda bangun.
Terakhir, Anda juga akan melihat cara membangun model untuk tugas regresi, dan mempelajari cara menyetel halus model yang telah Anda bangun.

Ingin mengikuti kursus tentang Keras dan deep learning di Python? Pertimbangkan untuk mengambil Deep Learning in Python dari DataCamp!

Jangan lewatkan juga lembar contekan Keras, yang menunjukkan enam langkah yang perlu Anda lalui untuk membangun jaringan saraf di Python beserta contoh kodenya!

Mengenal Artificial Neural Network

Sebelum masuk lebih dalam ke Keras dan cara menggunakannya untuk mulai belajar deep learning di Python, sebaiknya Anda mengetahui beberapa hal tentang jaringan saraf. Seperti yang sekilas Anda baca di bagian sebelumnya, jaringan saraf mendapatkan inspirasi dari biologi, di mana istilah “jaringan saraf” juga digunakan untuk neuron. Otak manusia adalah contoh jaringan saraf seperti itu, yang tersusun dari sejumlah neuron.

Dan, seperti yang kita semua tahu, otak mampu melakukan komputasi yang cukup kompleks, dan inilah sumber inspirasi untuk Artificial Neural Network. Jaringan secara keseluruhan adalah alat pemodelan yang kuat.

Perceptron

Jaringan saraf paling sederhana adalah “perceptron”, yang dalam bentuk paling sederhana terdiri dari satu neuron. Mirip dengan neuron biologis yang memiliki dendrit dan akson, neuron buatan tunggal adalah struktur pohon sederhana yang memiliki node input dan satu node output yang terhubung ke setiap node input. Berikut perbandingan visual keduanya:

diagram neuron biologis versus jaringan saraf buatan

Seperti yang terlihat pada gambar, ada enam komponen pada neuron buatan. Dari kiri ke kanan, yaitu:

Node input. Setiap node input diasosiasikan dengan nilai numerik, yang bisa berupa bilangan real apa pun. Ingat bahwa bilangan real mencakup seluruh rentang bilangan: bisa positif atau negatif, bilangan bulat atau desimal.
Koneksi. Demikian pula, setiap koneksi yang berangkat dari node input memiliki bobot yang terkait, dan ini juga bisa berupa bilangan real apa pun.
Berikutnya, semua nilai node input dan bobot koneksi digabungkan: nilai-nilai ini digunakan sebagai masukan untuk jumlah berbobot: \(y = f(\sum_{i=1}^{D} w_i*x_i)\), atau, dengan kata lain, \(y = f(w_1*x_1 + w_2*x_2 + ... w_D*x_D)\).
Hasil ini akan menjadi masukan untuk fungsi transfer atau aktivasi. Dalam kasus paling sederhana namun sepele, fungsi transfer ini adalah fungsi identitas, \(f(x)=x\) atau \(y=x\). Dalam hal ini, \(x\) adalah jumlah berbobot dari node input dan koneksi. Namun, seperti halnya neuron biologis hanya “menembak” ketika ambang tertentu terlampaui, neuron buatan juga hanya “menembak” ketika jumlah masukan melampaui ambang batas, katakanlah 0. Hal ini tidak tercermin dalam fungsi identitas! Cara paling intuitif yang dapat dipikirkan adalah dengan menyusun sistem seperti berikut:
\(f(x) = 0\) jika \(x<0\)
\(f(x) = 0.5\) jika \(x=0\)
\(f(x) = 1\) jika \(x>0\)
Tentu, Anda bisa membayangkan bahwa outputnya tidak akan berupa garis mulus: ia akan menjadi fungsi tak kontinu. Karena ini dapat menimbulkan masalah dalam pemrosesan matematis, varian kontinu yaitu fungsi sigmoid sering digunakan. Contoh fungsi sigmoid yang mungkin sudah Anda kenal adalah fungsi logistik. Menggunakan fungsi ini menghasilkan hasil yang jauh lebih mulus!
Hasilnya, Anda memiliki node output, yang diasosiasikan dengan fungsi (seperti fungsi sigmoid) dari jumlah berbobot node input. Perlu dicatat bahwa fungsi sigmoid adalah fungsi matematis yang menghasilkan kurva berbentuk “S”; Anda akan membaca lebih lanjut tentang ini nanti.
Terakhir, perceptron mungkin memiliki parameter tambahan yang disebut bias, yang dapat Anda anggap sebagai bobot yang terkait dengan node input tambahan yang secara permanen diset ke 1. Nilai bias penting karena memungkinkan Anda menggeser fungsi aktivasi ke kiri atau kanan, yang dapat menentukan keberhasilan pembelajaran Anda.

Konsekuensi logis dari model ini adalah perceptron hanya bekerja dengan data numerik. Ini berarti Anda harus mengonversi data nominal apa pun ke format numerik.

Sekarang setelah Anda tahu bahwa perceptron bekerja dengan ambang batas, langkah menggunakannya untuk tujuan klasifikasi tidaklah jauh: perceptron dapat menetapkan bahwa output di atas ambang tertentu menunjukkan bahwa sebuah instance termasuk ke suatu kelas, sedangkan output di bawah ambang tersebut mungkin berarti input termasuk kelas lainnya. Garis lurus tempat output sama dengan ambang menjadi batas antara dua kelas.

Multi-Layer Perceptron

Jaringan dari perceptron disebut multi-layer perceptron, dan inilah yang akan diimplementasikan tutorial ini di Python dengan bantuan Keras! Multi-layer perceptron juga dikenal sebagai “feed-forward neural network”. Seperti yang mungkin sudah Anda duga, jaringan ini lebih kompleks daripada perceptron, karena terdiri dari banyak neuron yang diorganisasi dalam layer. Jumlah layer biasanya dibatasi pada dua atau tiga, tetapi secara teoretis tidak ada batasnya!

Layer bertindak mirip dengan neuron biologis yang Anda baca di atas: output satu layer menjadi input untuk layer berikutnya.

Di antara layer, Anda dapat membedakan layer input, layer tersembunyi, dan layer output. Multi-layer perceptron sering kali sepenuhnya terhubung. Ini berarti ada koneksi dari setiap perceptron di suatu layer ke setiap perceptron di layer berikutnya. Meski keterhubungan bukanlah keharusan, ini biasanya terjadi.

Perhatikan bahwa sementara perceptron hanya dapat merepresentasikan pemisahan linear antar kelas, multi-layer perceptron mengatasi keterbatasan itu dan dapat merepresentasikan batas keputusan yang lebih kompleks.

Memprediksi Jenis Wine di Python dengan Keras

Untuk tutorial ini, Anda akan menggunakan dataset kualitas wine yang dapat Anda temukan di dataset kualitas wine dari UCI Machine Learning Repository. Idealnya, Anda melakukan deep learning pada dataset yang lebih besar, tetapi untuk tujuan tutorial ini, Anda akan menggunakan dataset yang lebih kecil. Ini terutama karena tujuannya adalah membuat Anda mulai menggunakan pustaka ini dan membiasakan diri dengan cara kerja jaringan saraf.

Anda mungkin sudah mengenal dataset ini, karena ini salah satu dataset paling populer untuk mulai belajar menyelesaikan masalah machine learning. Dalam kasus ini, dataset ini akan membantu Anda memulai deep learning di Python dengan Keras.

Mari mulai sekarang!

Memahami Data

Sebelum mulai memuat data, ada baiknya memeriksa seberapa banyak Anda benar-benar tahu tentang wine (terkait dataset, tentu saja). Kebanyakan dari Anda akan tahu bahwa secara umum ada dua jenis wine yang sangat populer: merah dan putih.

(Saya yakin ada banyak jenis lain, tetapi demi kesederhanaan dan karena pengetahuan saya tentang wine terbatas, saya batasi di sini. Mohon maaf jika mengecewakan para penikmat sejati di antara Anda :)).

Mengetahui ini sudah satu hal, tetapi jika Anda ingin menganalisis data ini, Anda perlu tahu sedikit lebih banyak.

Pertama, lihat folder deskripsi data untuk melihat variabel mana yang disertakan. Ini biasanya langkah pertama untuk memahami data Anda. Kunjungi halaman ini untuk melihat deskripsinya atau lanjutkan membaca untuk mengenal data Anda lebih baik.

Data terdiri dari dua dataset yang terkait dengan varian merah dan putih dari wine Portugis “Vinho Verde”. Seperti dinyatakan dalam deskripsi, Anda hanya akan menemukan variabel fisikokimia dan sensorik dalam dataset ini. Berkas deskripsi data mencantumkan 12 variabel yang disertakan, namun bagi yang, seperti saya, juga bukan ahli kimia, berikut deskripsi singkat setiap variabel:

Fixed acidity: asam adalah properti utama wine dan sangat berkontribusi pada rasa wine. Biasanya, total keasaman dibagi menjadi dua kelompok: asam volatil dan asam nonvolatil atau tetap. Di antara asam tetap yang dapat Anda temukan dalam wine adalah: tartarat, malat, sitrat, dan suksinat. Variabel ini dinyatakan dalam g(\(tartaric acid\))/\(dm^3\) pada dataset.
Volatile acidity: pada dasarnya adalah proses wine berubah menjadi cuka. Di AS, batas legal Volatile Acidity adalah 1,2 g/L untuk red table wine dan 1,1 g/L untuk white table wine. Dalam dataset ini, volatile acidity dinyatakan dalam g(\(acetic acid\))/\(dm^3\).
Citric acid adalah salah satu asam tetap yang Anda temukan dalam wine. Dinytakan dalam g/\(dm^3\) pada kedua dataset.
Residual sugar umumnya merujuk pada gula yang tersisa setelah fermentasi berhenti, atau dihentikan. Dinytakan dalam g/\(dm^3\) pada data red dan white.
Chlorides dapat berkontribusi signifikan pada rasa asin di wine. Di sini, dinyatakan dalam g(\(sodium chloride\))/\(dm^3\).
Free sulfur dioxide: bagian dari sulfur dioksida yang ditambahkan ke wine dan yang terikat di dalamnya disebut bound, sementara bagian aktif disebut free. Pembuat wine selalu berusaha mendapatkan proporsi sulfur bebas setinggi mungkin untuk mengikat. Variabel ini dinyatakan dalam mg/\(dm^3\) pada data.
Total sulfur dioxide adalah jumlah sulfur dioksida (SO2) bound dan free. Di sini dinyatakan dalam mg/\(dm^3\). Ada batas legal untuk kadar sulfur dalam wine: di UE, red wine hanya boleh memiliki 160 mg/L, sedangkan white dan rosé sekitar 210 mg/L. Wine manis diizinkan memiliki 400 mg/L. Untuk AS, batas legal ditetapkan 350 mg/L, dan untuk Australia 250 mg/L.
Density umumnya digunakan sebagai ukuran konversi gula menjadi alkohol. Di sini dinyatakan dalam g/\(cm^3\).
pH atau potensial hidrogen adalah skala numerik untuk menyatakan keasaman atau kebasaan wine. Seperti yang mungkin Anda ketahui, larutan dengan pH kurang dari 7 bersifat asam, sedangkan pH lebih dari 7 bersifat basa. Dengan pH 7, air murni bersifat netral. Kebanyakan wine memiliki pH antara 2,9 dan 3,9 sehingga bersifat asam.
Sulfates bagi wine seperti gluten bagi makanan. Anda mungkin sudah mengenal sulfite dari sakit kepala yang dapat ditimbulkannya. Ini merupakan bagian reguler dari pembuatan wine di seluruh dunia dan dianggap perlu. Dalam kasus ini, dinyatakan dalam g(\(potassium sulphate\))/\(dm^3\).
Alcohol: wine adalah minuman beralkohol, dan seperti yang Anda tahu, persentase alkohol dapat bervariasi antar wine. Tidak mengherankan variabel ini disertakan di dataset, dinyatakan dalam % vol.
Quality: pakar wine menilai kualitas wine antara 0 (sangat buruk) hingga 10 (sangat baik). Angka akhir adalah median dari setidaknya tiga evaluasi oleh pakar yang sama.

Semua ini tentu adalah informasi dasar yang mungkin Anda perlukan untuk memulai. Jika Anda seorang penikmat wine sejati, Anda mungkin sudah mengetahui semua ini dan lebih banyak lagi!

Sekarang, saatnya mengambil data Anda!

Memuat Data

Ini dapat dilakukan dengan mudah menggunakan pustaka manipulasi data Python, Pandas. Ikuti konvensi impor dan impor paket dengan alias pd.

Selanjutnya, gunakan fungsi read_csv() untuk membaca file CSV tempat data disimpan. Selain itu, gunakan argumen sep untuk menentukan bahwa pemisah dalam kasus ini adalah titik koma, bukan koma biasa.

Coba di chunk DataCamp Light di bawah ini:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IHBhbmRhcyBcbmltcG9ydCBwYW5kYXMgYXMgcGRcblxuIyBSZWFkIGluIHdoaXRlIHdpbmUgZGF0YSBcbndoaXRlID0gX19fX19fX19fX18oXCJodHRwOi8vYXJjaGl2ZS5pY3MudWNpLmVkdS9tbC9tYWNoaW5lLWxlYXJuaW5nLWRhdGFiYXNlcy93aW5lLXF1YWxpdHkvd2luZXF1YWxpdHktd2hpdGUuY3N2XCIsIHNlcD0nOycpXG5cbiMgUmVhZCBpbiByZWQgd2luZSBkYXRhIFxucmVkID0gX19fX19fX19fX18oXCJodHRwOi8vYXJjaGl2ZS5pY3MudWNpLmVkdS9tbC9tYWNoaW5lLWxlYXJuaW5nLWRhdGFiYXNlcy93aW5lLXF1YWxpdHkvd2luZXF1YWxpdHktcmVkLmNzdlwiLCBzZXA9JzsnKSIsInNvbHV0aW9uIjoiIyBJbXBvcnQgcGFuZGFzIFxuaW1wb3J0IHBhbmRhcyBhcyBwZFxuXG4jIFJlYWQgaW4gd2hpdGUgd2luZSBkYXRhIFxud2hpdGUgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS13aGl0ZS5jc3ZcIiwgc2VwPSc7JylcblxuIyBSZWFkIGluIHJlZCB3aW5lIGRhdGEgXG5yZWQgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS1yZWQuY3N2XCIsIHNlcD0nOycpIiwic2N0IjoiRXgoKS50ZXN0X2ltcG9ydChcInBhbmRhc1wiKVxuRXgoKS50ZXN0X29iamVjdChcIndoaXRlXCIpXG5FeCgpLnRlc3Rfb2JqZWN0KFwicmVkXCIpXG5zdWNjZXNzX21zZz1cIlBlcmZlY3QhIFlvdSdyZSByZWFkeSB0byBnbyFcIiJ9

Keren! Mudah sekali, bukan?

Anda mungkin sudah melakukan ini berkali-kali, tetapi ini selalu langkah penting untuk memulai. Sekarang Anda siap sepenuhnya untuk mulai mengeksplorasi, memanipulasi, dan memodelkan data Anda!

Eksplorasi Data

Dengan data di tangan, mudah bagi Anda untuk mempelajari lebih lanjut tentang wine ini! Salah satu hal pertama yang mungkin ingin Anda lakukan adalah mendapatkan gambaran cepat atas kedua DataFrame Anda:

Sekarang saatnya memeriksa apakah impor Anda berhasil: periksa ulang apakah data memuat semua variabel yang dijanjikan oleh berkas deskripsi data dari UCI Machine Learning Repository. Selain jumlah variabel, periksa juga kualitas impor: apakah tipe data sudah benar? Apakah semua baris masuk? Adakah nilai null yang perlu Anda perhitungkan saat membersihkan data?

Anda mungkin juga ingin memeriksa data dengan lebih dari sekadar info():

Ringkasan singkat fungsi-fungsi pandas ini: head(), tail(), dan sample() sangat berguna karena memberi Anda cara cepat untuk memeriksa data tanpa repot.

Selanjutnya, describe() menawarkan statistik ringkas tentang data Anda yang dapat membantu menilai kualitas data. Anda melihat beberapa variabel memiliki perbedaan besar pada nilai min dan max. Ini akan Anda tangani nanti, namun saat ini penting untuk menyadarinya.

Terakhir, Anda telah memeriksa ulang keberadaan nilai null di red dengan bantuan isnull(). Fungsi ini selalu berguna saat Anda masih ragu setelah membaca hasil info().

Tip: periksa juga apakah data wine memiliki nilai null. Anda bisa melakukannya dengan menggunakan shell IPython di chunk DataCamp Light tepat di atas.

Sekarang setelah Anda memeriksa data untuk memastikan impor berhasil dan benar, saatnya menggali lebih dalam.

Memvisualisasikan Data

Salah satu caranya adalah melihat distribusi beberapa variabel dalam dataset dan membuat scatter plot untuk melihat kemungkinan korelasi. Tentu saja, Anda dapat membawa ini ke tingkat yang jauh lebih tinggi jika menggunakan data ini untuk proyek Anda sendiri.

Alcohol

Salah satu variabel yang menarik dilihat pertama kali adalah alcohol. Ini mungkin salah satu hal pertama yang menarik perhatian saat Anda memeriksa dataset wine. Anda dapat memvisualisasikan distribusi dengan pustaka visualisasi data apa pun, tetapi dalam kasus ini, tutorial menggunakan matplotlib untuk memplot distribusi dengan cepat:

Seperti terlihat pada gambar di bawah, level alkohol antara red dan white wine sebagian besar sama: keduanya sekitar 9% alkohol. Tentu, ada juga banyak observasi dengan 10% atau 11% alkohol.

distribusi alkohol untuk model jaringan saraf

Perhatikan bahwa Anda dapat memeriksa ulang ini jika menggunakan fungsi histogram() dari paket numpy untuk menghitung histogram data white dan red, seperti ini:

Jika Anda tertarik dengan tutorial matplotlib, pastikan untuk melihat tutorial Matplotlib untuk pemula dan tutorial Melihat Data Volumetrik 3D, yang menunjukkan cara memanfaatkan event handler API Matplotlib.

Sulfates

Berikutnya, satu hal yang menarik bagi saya adalah hubungan antara sulfates dan kualitas wine. Seperti yang Anda baca di atas, sulfates dapat menyebabkan sakit kepala, dan saya bertanya-tanya apakah ini memengaruhi kualitas wine. Selain itu, saya sering mendengar bahwa khususnya perempuan enggan minum wine karena menyebabkan sakit kepala. Mungkin ini memengaruhi penilaian untuk red wine?

Mari kita lihat.

Seperti terlihat pada gambar di bawah, red wine tampaknya mengandung lebih banyak sulfates daripada white wine, yang memiliki lebih sedikit sulfates di atas 1 g/\(dm^3\). Untuk white wine, hanya ada beberapa pengecualian yang sedikit di atas 1 g/\(dm^3\), sedangkan untuk red wine jumlahnya jelas lebih banyak. Ini mungkin menjelaskan anggapan umum bahwa red wine menyebabkan sakit kepala, tetapi bagaimana dengan kualitasnya?

Anda dapat melihat jelas bahwa ada white wine dengan jumlah sulfates relatif rendah yang mendapat skor 9, tetapi selain itu, saat ini sulit menafsirkan data dengan benar.

Tentu, Anda perlu mempertimbangkan bahwa perbedaan jumlah observasi juga dapat memengaruhi grafik dan cara Anda menafsirkannya.

deep learning python dengan keras

Keasaman

Selain sulfates, keasaman adalah salah satu karakteristik utama dan penting dari wine yang diperlukan untuk mencapai wine berkualitas. Wine yang unggul sering menyeimbangkan keasaman, tanin, alkohol, dan manis. Beberapa literatur menyebutkan bahwa pada kisaran 0,2 hingga 0,4 g/L, volatile acidity tidak memengaruhi kualitas wine. Namun pada level yang lebih tinggi, volatile acidity dapat memberikan sensasi tajam seperti cuka. Volatile acidity yang ekstrem menandakan wine yang cacat serius.

Mari uji data dan buat scatter plot yang memplot alkohol terhadap volatile acidity. Titik data harus diberi warna sesuai rating atau label quality:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuaW1wb3J0IG51bXB5IGFzIG5wXG5ucC5yYW5kb20uc2VlZCg3KVxud2hpdGUgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS13aGl0ZS5jc3ZcIiwgc2VwPSc7JylcbnJlZCA9IHBkLnJlYWRfY3N2KFwiaHR0cDovL2FyY2hpdmUuaWNzLnVjaS5lZHUvbWwvbWFjaGluZS1sZWFybmluZy1kYXRhYmFzZXMvd2luZS1xdWFsaXR5L3dpbmVxdWFsaXR5LXJlZC5jc3ZcIiwgc2VwPSc7JykiLCJzYW1wbGUiOiJpbXBvcnQgbWF0cGxvdGxpYi5weXBsb3QgYXMgcGx0XG5pbXBvcnQgbnVtcHkgYXMgbnBcblxubnAucmFuZG9tLnNlZWQoNTcwKVxuXG5yZWRsYWJlbHMgPSBucC51bmlxdWUocmVkWydxdWFsaXR5J10pXG53aGl0ZWxhYmVscyA9IG5wLnVuaXF1ZSh3aGl0ZVsncXVhbGl0eSddKVxuXG5pbXBvcnQgbWF0cGxvdGxpYi5weXBsb3QgYXMgcGx0XG5maWcsIGF4ID0gcGx0LnN1YnBsb3RzKDEsIDIsIGZpZ3NpemU9KDgsIDQpKVxucmVkY29sb3JzID0gbnAucmFuZG9tLnJhbmQoNiw0KVxud2hpdGVjb2xvcnMgPSBucC5hcHBlbmQocmVkY29sb3JzLCBucC5yYW5kb20ucmFuZCgxLDQpLCBheGlzPTApXG5cbmZvciBpIGluIHJhbmdlKGxlbihyZWRjb2xvcnMpKTpcbiAgICByZWR5ID0gcmVkWydhbGNvaG9sJ11bcmVkLnF1YWxpdHkgPT0gcmVkbGFiZWxzW2ldXVxuICAgIHJlZHggPSByZWRbJ3ZvbGF0aWxlIGFjaWRpdHknXVtyZWQucXVhbGl0eSA9PSByZWRsYWJlbHNbaV1dXG4gICAgYXhbMF0uc2NhdHRlcihyZWR4LCByZWR5LCBjPXJlZGNvbG9yc1tpXSlcbmZvciBpIGluIHJhbmdlKGxlbih3aGl0ZWNvbG9ycykpOlxuICAgIHdoaXRleSA9IHdoaXRlWydhbGNvaG9sJ11bd2hpdGUucXVhbGl0eSA9PSB3aGl0ZWxhYmVsc1tpXV1cbiAgICB3aGl0ZXggPSB3aGl0ZVsndm9sYXRpbGUgYWNpZGl0eSddW3doaXRlLnF1YWxpdHkgPT0gd2hpdGVsYWJlbHNbaV1dXG4gICAgYXhbMV0uc2NhdHRlcih3aGl0ZXgsIHdoaXRleSwgYz13aGl0ZWNvbG9yc1tpXSlcbiAgICBcbmF4WzBdLnNldF90aXRsZShcIlJlZCBXaW5lXCIpXG5heFsxXS5zZXRfdGl0bGUoXCJXaGl0ZSBXaW5lXCIpXG5heFswXS5zZXRfeGxpbShbMCwxLjddKVxuYXhbMV0uc2V0X3hsaW0oWzAsMS43XSlcbmF4WzBdLnNldF95bGltKFs1LDE1LjVdKVxuYXhbMV0uc2V0X3lsaW0oWzUsMTUuNV0pXG5heFswXS5zZXRfeGxhYmVsKFwiVm9sYXRpbGUgQWNpZGl0eVwiKVxuYXhbMF0uc2V0X3lsYWJlbChcIkFsY29ob2xcIilcbmF4WzFdLnNldF94bGFiZWwoXCJWb2xhdGlsZSBBY2lkaXR5XCIpXG5heFsxXS5zZXRfeWxhYmVsKFwiQWxjb2hvbFwiKSBcbiNheFswXS5sZWdlbmQocmVkbGFiZWxzLCBsb2M9J2Jlc3QnLCBiYm94X3RvX2FuY2hvcj0oMS4zLCAxKSlcbmF4WzFdLmxlZ2VuZCh3aGl0ZWxhYmVscywgbG9jPSdiZXN0JywgYmJveF90b19hbmNob3I9KDEuMywgMSkpXG4jZmlnLnN1cHRpdGxlKFwiQWxjb2hvbCAtIFZvbGF0aWxlIEFjaWRpdHlcIilcbmZpZy5zdWJwbG90c19hZGp1c3QodG9wPTAuODUsIHdzcGFjZT0wLjcpXG5cbnBsdC5zaG93KCkifQ==

Perhatikan bahwa warna pada gambar ini dipilih secara acak dengan bantuan modul random dari NumPy. Anda selalu dapat mengubahnya dengan memberikan daftar ke variabel redcolors atau whitecolors. Pastikan keduanya sama (kecuali 1 karena data white wine memiliki satu nilai quality unik lebih banyak daripada data red wine), jika tidak legenda Anda tidak akan cocok!

Lihat grafik penuh di sini:

Pada gambar di atas, Anda melihat bahwa level yang Anda baca sebelumnya terutama berlaku untuk white wine: sebagian besar wine dengan label 8 memiliki tingkat volatile acidity 0,5 atau di bawahnya, tetapi apakah ini berdampak pada kualitas terlalu sulit untuk disimpulkan, karena semua titik data sangat rapat ke satu sisi grafik.

Ini hanya eksplorasi data cepat. Jika Anda tertarik memperluas langkah ini dalam proyek Anda sendiri, pertimbangkan artikel eksplorasi data DataCamp, seperti tutorial Exploratory Data Analysis Python dan Python Data Profiling, yang akan memandu Anda melalui dasar-dasar EDA.

Menutup Exploratory Data Analysis

Mungkin ini cukup banyak untuk dicerna, jadi tidak ada salahnya rekap singkat hal-hal yang Anda lihat selama EDA yang bisa penting untuk kelanjutan tutorial ini:

Beberapa variabel di dataset Anda memiliki nilai yang cukup berjauhan. Anda dapat dan akan menanganinya di bagian berikutnya dari tutorial.
Anda memiliki skenario ideal: tidak ada nilai null di dataset.
Kebanyakan wine yang termasuk di dataset memiliki kadar alkohol sekitar 9%.
Red wine tampaknya mengandung lebih banyak sulphates daripada white wine, yang memiliki lebih sedikit sulphates di atas 1 g/\(dm^3\).
Anda melihat sebagian besar wine memiliki volatile acidity 0,5 dan di bawahnya. Saat ini, belum ada hubungan langsung dengan kualitas wine.

Sampai sekarang, Anda melihat data white wine dan red wine secara terpisah. Keduanya tampak berbeda jika melihat beberapa variabel dari dekat, dan pada kasus lain, keduanya tampak sangat mirip. Menurut Anda, mungkinkah ada cara untuk mengklasifikasikan entri berdasarkan variabelnya menjadi white atau red wine?

Hanya ada satu cara untuk mengetahuinya: lakukan prapemrosesan data dan pemodelan sedemikian rupa sehingga Anda dapat melihat hasilnya!

Prapemrosesan Data

Sekarang setelah Anda mengeksplorasi data, saatnya bertindak berdasarkan wawasan yang Anda peroleh! Mari praproses data agar Anda dapat mulai membangun jaringan saraf Anda sendiri!

Anda menyetel ignore_index ke True dalam kasus ini karena Anda tidak ingin mempertahankan label indeks dari white saat menambahkan data ke red: Anda ingin label berlanjut dari titik terakhir di red, bukan menduplikasi label indeks akibat menggabungkan kedua dataset.

Intermezzo: Matriks Korelasi

Sekarang setelah Anda memiliki dataset lengkap, ada baiknya juga melakukan eksplorasi cepat; Anda sudah tahu beberapa hal dari melihat dua dataset secara terpisah, dan sekarang saatnya mengumpulkan wawasan yang mungkin lebih solid.

Karena grafik bisa agak sulit ditafsirkan, ada baiknya juga memplot matriks korelasi. Ini akan memberi wawasan lebih cepat tentang variabel mana yang berkorelasi:

Seperti yang Anda harapkan, ada beberapa variabel yang berkorelasi, seperti density dan residual sugar. Juga volatile acidity dan type lebih terkait daripada yang awalnya Anda duga saat melihat dua dataset secara terpisah, dan cukup bisa diprediksi bahwa free sulfur dioxide dan total sulfur dioxide akan berkorelasi.

korelasi data kualitas wine

Sangat menarik!

Train dan Test Set

Data tidak seimbang umumnya mengacu pada masalah pada klasifikasi ketika kelas tidak terwakili secara setara. Kebanyakan dataset klasifikasi tidak memiliki jumlah instance yang sama persis di setiap kelas, tetapi perbedaan kecil sering kali tidak masalah. Jadi Anda perlu memastikan bahwa kedua kelas wine ada dalam model pelatihan. Selain itu, jumlah instance dari kedua jenis wine harus kurang lebih seimbang agar Anda tidak memihak salah satu kelas dalam prediksi.

Dalam kasus ini, tampaknya ada ketidakseimbangan, tetapi untuk saat ini Anda akan lanjut dengan kondisi ini. Setelahnya, Anda dapat mengevaluasi model dan jika performanya kurang baik, Anda bisa melakukan undersampling atau oversampling untuk menutup perbedaan jumlah observasi.

Untuk saat ini, impor train_test_split dari sklearn.model_selection dan tetapkan data dan label target ke variabel X dan y. Anda akan melihat bahwa Anda perlu meratakan array label target agar sepenuhnya siap menggunakan variabel X dan y sebagai input untuk fungsi train_test_split(). Ayo mulai, kerjakan di chunk DataCamp Light di bawah!

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuaW1wb3J0IG51bXB5IGFzIG5wXG5ucC5yYW5kb20uc2VlZCg3KVxud2hpdGUgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS13aGl0ZS5jc3ZcIiwgc2VwPSc7JylcbnJlZCA9IHBkLnJlYWRfY3N2KFwiaHR0cDovL2FyY2hpdmUuaWNzLnVjaS5lZHUvbWwvbWFjaGluZS1sZWFybmluZy1kYXRhYmFzZXMvd2luZS1xdWFsaXR5L3dpbmVxdWFsaXR5LXJlZC5jc3ZcIiwgc2VwPSc7JylcbnJlZFsndHlwZSddID0gMVxud2hpdGVbJ3R5cGUnXSA9IDBcbndpbmVzID0gcmVkLmFwcGVuZCh3aGl0ZSwgaWdub3JlX2luZGV4PVRydWUpIiwic2FtcGxlIjoiIyBJbXBvcnQgYHRyYWluX3Rlc3Rfc3BsaXRgIGZyb20gYHNrbGVhcm4ubW9kZWxfc2VsZWN0aW9uYFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdFxuXG4jIFNwZWNpZnkgdGhlIGRhdGEgXG5YPXdpbmVzLml4WzosMDoxMV1cblxuIyBTcGVjaWZ5IHRoZSB0YXJnZXQgbGFiZWxzIGFuZCBmbGF0dGVuIHRoZSBhcnJheSBcbnk9bnAucmF2ZWwod2luZXMudHlwZSlcblxuIyBTcGxpdCB0aGUgZGF0YSB1cCBpbiB0cmFpbiBhbmQgdGVzdCBzZXRzXG5YX3RyYWluLCBYX3Rlc3QsIHlfdHJhaW4sIHlfdGVzdCA9IHRyYWluX3Rlc3Rfc3BsaXQoWCwgeSwgdGVzdF9zaXplPTAuMzMsIHJhbmRvbV9zdGF0ZT00MikiLCJzb2x1dGlvbiI6IiMgSW1wb3J0IGB0cmFpbl90ZXN0X3NwbGl0YCBmcm9tIGBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbmBcbmZyb20gc2tsZWFybi5tb2RlbF9zZWxlY3Rpb24gaW1wb3J0IHRyYWluX3Rlc3Rfc3BsaXRcblxuIyBTcGVjaWZ5IHRoZSBkYXRhIFxuWD13aW5lcy5peFs6LDA6MTldXG5cbiMgU3BlY2lmeSB0aGUgdGFyZ2V0IGxhYmVscyBhbmQgZmxhdHRlbiB0aGUgYXJyYXlcbnk9IG5wLnJhdmVsKHdpbmVzLnR5cGUpXG5cbiMgU3BsaXQgdGhlIGRhdGEgdXAgaW4gdHJhaW4gYW5kIHRlc3Qgc2V0c1xuWF90cmFpbiwgWF90ZXN0LCB5X3RyYWluLCB5X3Rlc3QgPSB0cmFpbl90ZXN0X3NwbGl0KFgsIHksIHRlc3Rfc2l6ZT0wLjMzLCByYW5kb21fc3RhdGU9NDIpIiwic2N0IjoiRXgoKS50ZXN0X2ltcG9ydChcInNrbGVhcm4ubW9kZWxfc2VsZWN0aW9uLnRyYWluX3Rlc3Rfc3BsaXRcIilcbkV4KCkudGVzdF9vYmplY3QoXCJYXCIpXG5FeCgpLnRlc3Rfb2JqZWN0KFwieVwiKVxuRXgoKS50ZXN0X29iamVjdChcIlhfdHJhaW5cIilcbkV4KCkudGVzdF9vYmplY3QoXCJYX3Rlc3RcIilcbkV4KCkudGVzdF9vYmplY3QoXCJ5X3RyYWluXCIpXG5FeCgpLnRlc3Rfb2JqZWN0KFwieV90ZXN0XCIpIn0=

Anda sudah berada di jalur yang tepat untuk membangun jaringan saraf pertama Anda, tetapi masih ada satu hal yang perlu diurus! Masih ingat apa yang Anda temukan saat melihat ringkasan data white dan red?

Benar, beberapa nilainya cukup berjauhan. Masuk akal untuk melakukan standardisasi di sini.

Menstandarkan Data

Standardisasi adalah cara untuk menangani nilai-nilai yang letaknya sangat berjauhan. Paket scikit-learn menawarkan cara cepat dan hebat untuk menstandarkan data Anda: impor modul StandardScaler dari sklearn.preprocessing dan Anda siap melakukan penskalaan pada data train dan test!

# Import `StandardScaler` dari `sklearn.preprocessing`
from sklearn.preprocessing import StandardScaler

# Definisikan scaler 
scaler = StandardScaler().fit(X_train)

# Skala train set
X_train = scaler.transform(X_train)

# Skala test set
X_test = scaler.transform(X_test)

Sekarang setelah data Anda dipraproses, Anda bisa lanjut ke pekerjaan utama: membangun jaringan saraf sendiri untuk mengklasifikasikan wine.

Memodelkan Data

Sebelum mulai memodelkan, kembali ke pertanyaan awal: dapatkah Anda memprediksi apakah sebuah wine adalah red atau white dengan melihat sifat kimianya, seperti volatile acidity atau sulphates?

Karena Anda hanya memiliki dua kelas, yaitu white dan red, Anda akan melakukan klasifikasi biner. Seperti yang bisa Anda bayangkan, “biner” berarti 0 atau 1, ya atau tidak. Karena jaringan saraf hanya dapat bekerja dengan data numerik, Anda sudah mengenkode red sebagai 1 dan white sebagai 0.

Jenis jaringan yang berkinerja baik pada masalah seperti ini adalah multi-layer perceptron. Seperti yang Anda baca di awal tutorial ini, tipe jaringan saraf ini sering sepenuhnya terhubung. Artinya, Anda akan membangun tumpukan layer fully-connected yang cukup sederhana untuk menyelesaikan masalah ini. Untuk fungsi aktivasi yang akan digunakan, sebaiknya gunakan salah satu yang paling umum untuk tujuan membiasakan diri dengan Keras dan jaringan saraf, yaitu fungsi aktivasi relu.

Bagaimana memulai membangun multi-layer perceptron? Cara cepat untuk mulai adalah menggunakan model Sequential Keras: ini adalah tumpukan linear layer. Anda dapat dengan mudah membuat model dengan meneruskan daftar instance layer ke konstruktor, yang Anda siapkan dengan menjalankan model = Sequential().

Selanjutnya, ingat kembali struktur multi-layer perceptron seperti yang dibahas di awal: Anda memiliki layer input, beberapa layer tersembunyi, dan layer output. Saat membuat model, penting untuk memperhitungkan bahwa layer pertama perlu menjelaskan bentuk input. Model perlu mengetahui bentuk input yang diharapkan dan itulah mengapa Anda akan selalu menemukan argumen input_shape, input_dim, input_length, atau batch_size dalam dokumentasi layer dan contoh praktisnya.

Dalam kasus ini, Anda akan menggunakan layer Dense, yaitu layer fully connected. Layer Dense mengimplementasikan operasi berikut: output = activation(dot(input, kernel) + bias). Perhatikan bahwa tanpa fungsi aktivasi, layer Dense Anda hanya akan terdiri dari dua operasi linear: perkalian dot dan penjumlahan.

Pada layer pertama, argumen activation bernilai relu. Selanjutnya, Anda juga melihat bahwa input_shape telah didefinisikan. Ini adalah input dari operasi yang baru saja Anda lihat: model menerima input berupa array berdimensi (12,), atau (*, 12). Terakhir, Anda melihat bahwa layer pertama memiliki 12 sebagai nilai pertama untuk argumen units pada Dense(), yaitu dimensionalitas ruang output dan sebenarnya 12 unit tersembunyi. Ini berarti model akan menghasilkan array berdimensi (*, 12): inilah dimensionalitas ruang output. Jangan khawatir jika belum sepenuhnya paham sekarang, Anda akan membacanya lagi nanti!

Argumen units sebenarnya merepresentasikan kernel pada rumus di atas atau matriks bobot, yang terdiri dari semua bobot yang diberikan ke semua node input, yang dibuat oleh layer. Perhatikan bahwa Anda tidak menyertakan bias pada contoh di bawah, karena Anda tidak menyertakan argumen use_bias dan menyetelnya ke TRUE, yang juga memungkinkan.

Layer intermediate juga menggunakan fungsi aktivasi relu. Output layer ini akan berupa array berdimensi (*,8).

Anda menutup jaringan dengan layer Dense berukuran 1. Layer terakhir juga menggunakan fungsi aktivasi sigmoid sehingga output Anda sebenarnya berupa probabilitas; Ini berarti akan menghasilkan skor antara 0 dan 1, yang menunjukkan seberapa besar kemungkinan sampel memiliki target “1”, atau seberapa besar kemungkinan wine tersebut red.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IG51bXB5IGFzIG5wXG5ucC5yYW5kb20uc2VlZCg3KSIsInNhbXBsZSI6IiMgSW1wb3J0IGBTZXF1ZW50aWFsYCBmcm9tIGBrZXJhcy5tb2RlbHNgXG5mcm9tIGtlcmFzLm1vZGVscyBpbXBvcnQgU2VxdWVudGlhbFxuXG4jIEltcG9ydCBgRGVuc2VgIGZyb20gYGtlcmFzLmxheWVyc2BcbmZyb20ga2VyYXMubGF5ZXJzIGltcG9ydCBEZW5zZVxuXG4jIEluaXRpYWxpemUgdGhlIGNvbnN0cnVjdG9yXG5tb2RlbCA9IFNlcXVlbnRpYWwoKVxuXG4jIEFkZCBhbiBpbnB1dCBsYXllciBcbm1vZGVsLmFkZChEZW5zZSgxMiwgYWN0aXZhdGlvbj0ncmVsdScsIGlucHV0X3NoYXBlPSgxMSwpKSlcblxuIyBBZGQgb25lIGhpZGRlbiBsYXllciBcbm1vZGVsLmFkZChEZW5zZSg4LCBhY3RpdmF0aW9uPSdyZWx1JykpXG5cbiMgQWRkIGFuIG91dHB1dCBsYXllciBcbm1vZGVsLmFkZChEZW5zZSgxLCBhY3RpdmF0aW9uPSdzaWdtb2lkJykpIn0=

Secara keseluruhan, ada dua keputusan arsitektur kunci yang perlu Anda buat untuk menyusun model: berapa banyak layer yang akan digunakan dan berapa banyak “unit tersembunyi” yang akan dipilih untuk setiap layer.

Dalam kasus ini, Anda memilih 12 unit tersembunyi untuk layer pertama model: seperti dijelaskan di atas, ini adalah dimensionalitas ruang output. Dengan kata lain, Anda menetapkan tingkat kebebasan yang Anda izinkan untuk jaringan saat belajar representasi. Jika Anda mengizinkan lebih banyak unit tersembunyi, jaringan Anda akan dapat mempelajari representasi yang lebih kompleks tetapi juga akan menjadi operasi yang lebih mahal dan rentan overfitting.

Ingat bahwa overfitting terjadi ketika model terlalu kompleks: ia akan menggambarkan kesalahan acak atau noise, bukan hubungan mendasar yang perlu dijelaskan. Dengan kata lain, data pelatihan dimodelkan terlalu baik!

Perhatikan bahwa ketika Anda tidak memiliki banyak data pelatihan, sebaiknya gunakan jaringan kecil dengan sangat sedikit layer tersembunyi (biasanya hanya satu, seperti pada contoh di atas).

Jika Anda ingin mendapatkan informasi tentang model yang baru saja dibuat, Anda dapat menggunakan atribut output_shape atau fungsi summary(), dan lainnya. Beberapa yang paling dasar tercantum di bawah.

Coba jalankan untuk melihat hasilnya dan apa yang diberitahukan tentang model yang baru saja Anda buat:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IG51bXB5IGFzIG5wXG5ucC5yYW5kb20uc2VlZCg3KVxuZnJvbSBrZXJhcy5tb2RlbHMgaW1wb3J0IFNlcXVlbnRpYWxcbmZyb20ga2VyYXMubGF5ZXJzIGltcG9ydCBEZW5zZVxubW9kZWwgPSBTZXF1ZW50aWFsKClcbm1vZGVsLmFkZChEZW5zZSgxMixhY3RpdmF0aW9uPSdyZWx1JywgaW5wdXRfc2hhcGU9KDExLCkpKVxubW9kZWwuYWRkKERlbnNlKDgsYWN0aXZhdGlvbj0ncmVsdScpKVxubW9kZWwuYWRkKERlbnNlKDEsYWN0aXZhdGlvbj0nc2lnbW9pZCcpKSIsInNhbXBsZSI6IiMgTW9kZWwgb3V0cHV0IHNoYXBlXG5tb2RlbC5fX19fX19fX19fX1xuXG4jIE1vZGVsIHN1bW1hcnlcbm1vZGVsLl9fX19fX19fX19cblxuIyBNb2RlbCBjb25maWdcbm1vZGVsLmdldF9jb25maWcoKVxuXG4jIExpc3QgYWxsIHdlaWdodCB0ZW5zb3JzIFxubW9kZWwuZ2V0X3dlaWdodHMoKSIsInNvbHV0aW9uIjoiIyBNb2RlbCBvdXRwdXQgc2hhcGVcbm1vZGVsLm91dHB1dF9zaGFwZVxuXG4jIE1vZGVsIHN1bW1hcnlcbm9kZWwuc3VtbWFyeSgpXG5cbiMgTW9kZWwgY29uZmlnXG5tb2RlbC5nZXRfY29uZmlnKClcblxuIyBMaXN0IGFsbCB3ZWlnaHQgdGVuc29ycyBcbm1vZGVsLmdldF93ZWlnaHRzKCkifQ==

Kompilasi dan Fit

Berikutnya, saatnya mengompilasi model dan memasangkan model ke data: sekali lagi, gunakan compile() dan fit() untuk menyelesaikannya.

model.compile(loss='binary_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])
                   
model.fit(X_train, y_train,epochs=20, batch_size=1, verbose=1)

Saat mengompilasi, Anda mengonfigurasi model dengan optimizer adam dan fungsi loss binary_crossentropy. Selain itu, Anda juga dapat memantau akurasi selama pelatihan dengan meneruskan ['accuracy'] ke argumen metrics.

optimizer dan loss adalah dua argumen yang diperlukan jika Anda ingin mengompilasi model. Beberapa algoritma optimisasi paling populer yang digunakan adalah Stochastic Gradient Descent (SGD), ADAM, dan RMSprop. Bergantung pada algoritma yang Anda pilih, Anda perlu menyetel parameter tertentu, seperti learning rate atau momentum. Pilihan fungsi loss bergantung pada tugas yang Anda hadapi: misalnya, untuk masalah regresi, Anda biasanya menggunakan Mean Squared Error (MSE). Seperti terlihat pada contoh ini, Anda menggunakan binary_crossentropy untuk masalah klasifikasi biner dalam menentukan apakah sebuah wine red atau white. Terakhir, untuk klasifikasi multikelas, Anda akan menggunakan categorical_crossentropy.

Setelah itu, Anda dapat melatih model selama 20 epoch atau iterasi atas semua sampel di X_train dan y_train, dalam batch berisi 1 sampel. Anda juga dapat menentukan argumen verbose. Dengan menyetelnya ke 1, Anda menunjukkan ingin melihat log progress bar.

Dengan kata lain, Anda harus melatih model untuk jumlah epoch tertentu atau paparan terhadap dataset pelatihan. Satu epoch adalah satu kali lintasan melalui seluruh train set, diikuti dengan pengujian pada verification set. Ukuran batch yang Anda tentukan pada kode di atas mendefinisikan jumlah sampel yang akan dipropagasikan melalui jaringan. Dengan cara ini, Anda juga mengoptimalkan efisiensi karena memastikan tidak memuat terlalu banyak pola input ke memori dalam waktu yang sama.

Memprediksi Nilai

Mari gunakan model Anda! Anda dapat membuat prediksi untuk label test set dengannya. Cukup gunakan predict() dan berikan test set untuk memprediksi label data. Dalam kasus ini, hasilnya disimpan di y_pred:

y_pred = model.predict(X_test)

Sebelum Anda mengevaluasi model, Anda dapat memperoleh gambaran cepat tentang akurasi dengan memeriksa bagaimana y_pred dan y_test dibandingkan:

y_pred[:5]

array([[0],
       [1],
       [0],
       [0],
       [0]], dtype=int32)

y_test[:5]

array([0, 1, 0, 0, 0])

Anda melihat nilai-nilai ini tampaknya cocok, tetapi semua ini belum lengkap tanpa angka yang pasti.

Evaluasi Model

Sekarang setelah Anda membangun model dan menggunakannya untuk membuat prediksi pada data yang belum pernah dilihat model, saatnya mengevaluasi performanya. Anda dapat membandingkan prediksi dengan label uji sebenarnya (y_test) secara visual, atau Anda dapat menggunakan berbagai metrik untuk menentukan kinerja yang sebenarnya. Dalam kasus ini, Anda akan menggunakan evaluate(). Berikan data uji dan label uji, dan jika ingin, setel argumen verbose ke 1. Anda akan melihat lebih banyak log muncul saat melakukan ini.

score = model.evaluate(X_test, y_test,verbose=1)

print(score)

[0.025217213829228164, 0.99487179487179489]

Score adalah daftar yang memuat kombinasi loss dan akurasi. Dalam kasus ini, Anda melihat keduanya tampak sangat baik, tetapi ingat bahwa data Anda agak tidak seimbang: Anda memiliki lebih banyak observasi white wine daripada red wine. Akurasi mungkin hanya merefleksikan distribusi kelas data karena model akan cenderung memprediksi white karena observasinya melimpah!

Sebelum Anda mengatur ulang data dan menyusunnya dengan cara berbeda, selalu merupakan ide bagus untuk mencoba metrik evaluasi lain. Untuk ini, Anda dapat mengandalkan scikit-learn (yang Anda impor sebagai sklearn, seperti sebelumnya saat membuat train dan test set).

Dalam kasus ini, Anda akan mencoba beberapa teknik evaluasi klasifikasi dasar, seperti:

Confusion matrix, yaitu rincian prediksi ke dalam tabel yang menunjukkan prediksi benar dan jenis prediksi salah yang dibuat. Idealnya, Anda hanya akan melihat angka pada diagonal, yang berarti semua prediksi Anda benar!
Precision adalah ukuran ketepatan sebuah classifier. Semakin tinggi precision, semakin akurat classifier.
Recall adalah ukuran kelengkapan sebuah classifier. Semakin tinggi recall, semakin banyak kasus yang tercakup oleh classifier.
F1 Score atau F-score adalah rata-rata tertimbang dari precision dan recall.
Kappa atau Cohen’s kappa adalah akurasi klasifikasi yang dinormalisasi terhadap ketidakseimbangan kelas dalam data.

# Impor modul dari `sklearn.metrics`
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, cohen_kappa_score

# Confusion matrix
confusion_matrix(y_test, y_pred)

array([[1585,    3],
       [   8,  549]])

# Precision 
precision_score(y_test, y_pred)

0.994565217391

# Recall
recall_score(y_test, y_pred)

0.98563734290843807

# F1 score
f1_score(y_test,y_pred)

0.99008115419296661

# Cohen's kappa
cohen_kappa_score(y_test, y_pred)

0.98662321692498967

Semua skor ini sangat baik! Anda telah membuat model yang cukup akurat meskipun jumlah baris bertipe white wine jauh lebih banyak.

Kerja bagus!

Beberapa Percobaan Lain

Anda telah berhasil membangun model pertama, tetapi Anda bisa melangkah lebih jauh lagi. Mengapa tidak mencoba hal-hal berikut dan melihat dampaknya? Seperti yang Anda baca, dua keputusan arsitektur kunci yang perlu dibuat melibatkan layer dan node tersembunyi. Ini adalah titik awal yang bagus:

Anda menggunakan 1 layer tersembunyi. Cobalah gunakan 2 atau 3 layer tersembunyi;
Gunakan layer dengan lebih banyak atau lebih sedikit unit tersembunyi;
Ambil kolom quality sebagai label target dan sisa data (termasuk kolom type yang telah dienkode!) sebagai data Anda. Sekarang Anda memiliki masalah klasifikasi multikelas!

Mengapa tidak mencoba juga mengubah fungsi aktivasi? Alih-alih relu, cobalah menggunakan fungsi aktivasi tanh dan lihat hasilnya!

Memprediksi Kualitas Wine

Model klasifikasi Anda tampil sangat baik untuk percobaan pertama!

Namun masih banyak yang bisa Anda lakukan selain naik tingkat dan mencoba struktur yang lebih kompleks daripada multi-layer perceptron. Mengapa tidak mencoba membuat jaringan saraf untuk memprediksi kualitas wine?

Dalam kasus ini, tutorial mengasumsikan bahwa quality adalah variabel kontinu: tugasnya bukan klasifikasi biner melainkan regresi ordinal. Ini adalah jenis regresi yang digunakan untuk memprediksi variabel ordinal: nilai quality ada pada skala sewenang-wenang di mana urutan relatif antar nilai quality berbeda itu signifikan. Pada skala ini, skala kualitas 0–10 dari “sangat buruk” hingga “sangat baik” adalah salah satu contohnya.

Perhatikan bahwa Anda juga dapat melihat jenis masalah ini sebagai masalah klasifikasi dan menganggap label kualitas sebagai label kelas tetap.

Bagaimanapun, pengaturan situasi ini berarti label target Anda adalah kolom quality pada DataFrame red dan white untuk bagian kedua tutorial ini. Ini memerlukan prapemrosesan tambahan.

Prapemrosesan Data

Karena variabel quality menjadi kelas target Anda, sekarang Anda perlu mengisolasi label kualitas dari sisa dataset. Anda akan menempatkan wines.quality pada variabel berbeda y dan menempatkan data wine, kecuali kolom quality, pada variabel x.

Berikutnya, Anda siap membagi data menjadi train dan test set, tetapi Anda tidak akan mengikuti pendekatan ini kali ini (meskipun bisa!). Pada bagian kedua tutorial, Anda akan menggunakan validasi k-fold, yang mengharuskan Anda membagi data menjadi K partisi. Biasanya, K ditetapkan 4 atau 5. Selanjutnya, Anda membuat model identik dan melatih masing-masing pada satu partisi, sambil mengevaluasi pada partisi yang tersisa. Skor validasi untuk model kemudian adalah rata-rata dari K skor validasi yang diperoleh.

Anda akan melihat cara melakukannya nanti. Untuk saat ini, gunakan StandardScaler untuk memastikan data berada pada kondisi baik sebelum Anda memasangkan data ke model, seperti sebelumnya.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxud2hpdGUgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS13aGl0ZS5jc3ZcIiwgc2VwPSc7JylcbnJlZCA9IHBkLnJlYWRfY3N2KFwiaHR0cDovL2FyY2hpdmUuaWNzLnVjaS5lZHUvbWwvbWFjaGluZS1sZWFybmluZy1kYXRhYmFzZXMvd2luZS1xdWFsaXR5L3dpbmVxdWFsaXR5LXJlZC5jc3ZcIiwgc2VwPSc7JyklcbndpbmVzID0gcmVkLmFwcGVuZCh3aGl0ZSwgaWdub3JlX2luZGV4PVRydWUpIiwic2FtcGxlIjoiIyBJc29sYXRlIHRhcmdldCBsYWJlbHNcbnkgPSB3aW5lcy5fX19fX19fX1xuXG4jIElzb2xhdGUgZGF0YVxuWCA9IHdpbmVzLmRyb3AoJ3F1YWxpdHknLCBheGlzPV8pICIsInNvbHV0aW9uIjoiIyBJc29sYXRlIHRhcmdldCBsYWJlbHNcbnkgPSB3aW5lcy5xdWFsaXR5XG5cbiMgSXNvbGF0ZSBkYXRhXG5YID0gd2luZXMuZHJvcCgncXVhbGl0eScsIGF4aXM9MSkgIiwic2N0IjoiRXgoKS50ZXN0X29iamVjdChcInlcIilcbkV4KCkudGVzdF9vYmplY3QoXCJYXCIpIn0=

Ingat bahwa Anda juga perlu melakukan penskalaan lagi karena terdapat banyak perbedaan pada beberapa nilai data red, white (dan konsekuensinya juga wines).

Coba ini di chunk DataCamp Light di bawah. Semua pustaka yang diperlukan telah dimuat untuk Anda!

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxud2hpdGUgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS13aGl0ZS5jc3ZcIiwgc2VwPSc7JylcbnJlZCA9IHBkLnJlYWRfY3N2KFwiaHR0cDovL2FyY2hpdmUuaWNzLnVjaS5lZHUvbWwvbWFjaGluZS1sZWFybmluZy1kYXRhYmFzZXMvd2luZS1xdWFsaXR5L3dpbmVxdWFsaXR5LXJlZC5jc3ZcIiwgc2VwPSc7JylcbndpbmVzID0gcmVkLmFwcGVuZCh3aGl0ZSwgaWdub3JlX2luZGV4PVRydWUpXG55ID0gd2luZXMucXVhbGl0eVxuWCA9IHdpbmVzLmRyb3AoJ3F1YWxpdHknLCBheGlzPTEpIFxuZnJvbSBza2xlYXJuLnByZXByb2Nlc3NpbmcgaW1wb3J0IFN0YW5kYXJkU2NhbGVyIiwic2FtcGxlIjoiIyBTY2FsZSB0aGUgZGF0YSB3aXRoIGBTdGFuZGFyZFNjYWxlcmBcblggPSBfX19fX19fX19fX19fX19fLmZpdF90cmFuc2Zvcm0oWCkiLCJzb2x1dGlvbiI6IiMgU2NhbGUgdGhlIGRhdGEgd2l0aCBgU3RhbmRhcmRTY2FsZXJgXG5YID0gU3RhbmRhcmRTY2FsZXIoKS5maXRfdHJhbnNmb3JtKFgpIiwic2N0IjoiRXgoKS50ZXN0X29iamVjdChcIlhcIikifQ==

Sekarang Anda kembali ke titik beberapa langkah sebelumnya. Anda dapat kembali mulai memodelkan jaringan saraf!

Memodelkan Arsitektur Jaringan Saraf

Sekarang setelah Anda memproses data lagi, saatnya sekali lagi menyusun model jaringan saraf, yaitu multi-layer perceptron. Meskipun Anda akan menggunakannya untuk tugas regresi, arsitekturnya bisa terlihat sangat mirip, dengan dua layer Dense.

Jangan lupa bahwa layer pertama adalah layer input. Anda perlu meneruskan bentuk data input ke sana. Pada kasus ini, Anda akan menggunakan input_dim untuk meneruskan dimensi data input ke layer Dense.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdFxuZnJvbSBza2xlYXJuLnByZXByb2Nlc3NpbmcgaW1wb3J0IFN0YW5kYXJkU2NhbGVyXG53aGl0ZSA9IHBkLnJlYWRfY3N2KFwiaHR0cDovL2FyY2hpdmUuaWNzLnVjaS5lZHUvbWwvbWFjaGluZS1sZWFybmluZy1kYXRhYmFzZXMvd2luZS1xdWFsaXR5L3dpbmVxdWFsaXR5LXdoaXRlLmNzdlwiLCBzZXA9JzsnKVxucmVkID0gcGQucmVhZF9jc3YoXCJodHRwOi8vYXJjaGl2ZS5pY3MudWNpLmVkdS9tbC9tYWNoaW5lLWxlYXJuaW5nLWRhdGFiYXNlcy93aW5lLXF1YWxpdHkvd2luZXF1YWxpdHktcmVkLmNzdlwiLCBzZXA9JzsnKVxucmVkWyd0eXBlJ10gPSAxXG53aGl0ZVsndHlwZSddID0gMFxud2luZXMgPSByZWQuYXBwZW5kKHdoaXRlLCBpZ25vcmVfaW5kZXg9VHJ1ZSlcbnkgPSB3aW5lcy5xdWFsaXR5XG5YID0gd2luZXMuZHJvcCgncXVhbGl0eScsIGF4aXM9MSkgXG5YID0gU3RhbmRhcmRTY2FsZXIoKS5maXRfdHJhbnNmb3JtKFgpIiwic2FtcGxlIjoiIyBJbXBvcnQgYFNlcXVlbnRpYWxgIGZyb20gYGtlcmFzLm1vZGVsc2BcbmZyb20ga2VyYXMubW9kZWxzIGltcG9ydCBTZXF1ZW50aWFsXG5cbiMgSW1wb3J0IGBEZW5zZWAgZnJvbSBga2VyYXMubGF5ZXJzYFxuZnJvbSBrZXJhcy5sYXllcnMgaW1wb3J0IERlbnNlXG5cbiMgSW5pdGlhbGl6ZSB0aGUgbW9kZWxcbm1vZGVsID0gU2VxdWVudGlhbCgpXG5cbiMgQWRkIGlucHV0IGxheWVyIFxubW9kZWwuYWRkKERlbnNlKDY0LCBpbnB1dF9kaW09MTIsIGFjdGl2YXRpb249J3JlbHUnKSlcbiAgICBcbiMgQWRkIG91dHB1dCBsYXllciBcbm1vZGVsLmFkZChEZW5zZSgxKSkifQ==

Perhatikan lagi bahwa layer pertama yang Anda definisikan adalah layer input. Layer ini perlu mengetahui dimensi input data Anda. Anda meneruskan dimensi input, yang dalam kasus ini adalah 12 (jangan lupa Anda juga menghitung kolom Type yang Anda buat pada bagian pertama tutorial!). Anda kembali menggunakan fungsi aktivasi relu, tetapi sekali lagi tidak ada bias yang terlibat. Jumlah unit tersembunyi adalah 64.

Jaringan Anda diakhiri dengan satu unit Dense(1), dan tidak menyertakan aktivasi. Ini adalah susunan khas untuk regresi skalar, di mana Anda mencoba memprediksi satu nilai kontinu.

Kompilasi Model, Fit Data

Dengan model di tangan, Anda dapat kembali mengompilasinya dan memasangkan data. Tapi tunggu. Bukankah Anda membutuhkan partisi validasi K-fold yang dibahas sebelumnya? Benar.

import numpy as np
from sklearn.model_selection import StratifiedKFold

seed = 7
np.random.seed(seed)

kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=seed)
for train, test in kfold.split(X, Y):
    model = Sequential()
    model.add(Dense(64, input_dim=12, activation='relu'))
    model.add(Dense(1))
    model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
    model.fit(X[train], Y[train], epochs=10, verbose=1)

Gunakan fungsi compile() untuk mengompilasi model dan lalu gunakan fit() untuk memasangkan model ke data. Untuk mengompilasi model, pastikan Anda mendefinisikan setidaknya argumen optimizer dan loss. Dalam kasus ini, Anda dapat menggunakan rsmprop, salah satu algoritma optimisasi paling populer, dan mse sebagai fungsi loss, yang sangat lazim untuk masalah regresi seperti milik Anda.

Argumen tambahan metrics yang Anda definisikan sebenarnya adalah fungsi yang digunakan untuk menilai performa model. Untuk masalah regresi, lazim menggunakan Mean Absolute Error (MAE) sebagai metrik. Anda akan membaca lebih lanjut tentang ini di bagian berikutnya.

Masukkan data dan label train ke fit(), tentukan berapa banyak epoch yang ingin dijalankan, ukuran batch, dan jika ingin, Anda dapat menyetel argumen verbose ke 1 untuk mendapatkan lebih banyak log karena proses ini bisa memakan waktu.

Evaluasi Model

Seperti sebelumnya, Anda juga harus mengevaluasi model. Selain menambahkan y_pred = model.predict(X[test]) ke kode di atas, ada baiknya juga menggunakan beberapa metrik evaluasi dari sklearn, seperti yang telah Anda lakukan pada bagian pertama tutorial.

Untuk melakukannya, Anda dapat menggunakan Mean Squared Error (MSE) dan Mean Absolute Error (MAE). Yang pertama, juga disebut “mean squared deviation” (MSD), mengukur rata-rata kuadrat error atau deviasi. Dengan kata lain, ini mengukur perbedaan antara estimator dan yang diestimasi. Dengan cara ini, Anda mengetahui lebih banyak tentang kualitas estimator Anda: nilainya selalu non-negatif, dan nilai yang semakin mendekati nol semakin baik.

Metrik evaluasi kedua, MAE, adalah Mean Absolute Error: mengukur seberapa dekat prediksi terhadap hasil akhirnya.

Tambahkan baris ini ke chunk kode sebelumnya, dan hati-hati dengan indentasi:

mse_value, mae_value = model.evaluate(X[test], Y[test], verbose=0)

print(mse_value)
0.522478731072
print(mae_value)
0.561965950103

Perhatikan bahwa selain skor MSE dan MAE, Anda juga dapat menggunakan skor R2 atau fungsi skor regresi. Di sini, Anda menargetkan skor 1,0, yang terbaik. Namun, skornya juga bisa bernilai negatif!

from sklearn.metrics import r2_score

r2_score(Y[test], y_pred)
0.3125092543

Sekilas, angka-angka ini cukup buruk, bukan? Kabar baiknya, Anda sekarang bisa bereksperimen mengoptimalkan kode agar hasilnya menjadi sedikit lebih baik.

Itulah yang dibahas pada bagian terakhir berikut!

Penyetelan Halus Model

Menyetel halus model Anda mungkin akan sering Anda lakukan karena tidak semua masalah sesederhana yang Anda lihat pada bagian pertama tutorial ini. Seperti yang dibahas, ada dua keputusan penting yang mungkin ingin Anda atur: berapa banyak layer yang akan digunakan dan berapa banyak “unit tersembunyi” yang akan dipilih untuk setiap layer.

Pada awalnya, ini memang akan menjadi perjalanan.

Menambah Layer

Apa yang terjadi jika Anda menambah satu layer lagi pada model? Bagaimana jika tampilannya seperti ini?

model = Sequential()
model.add(Dense(64, input_dim=12, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(1))

Unit Tersembunyi

Cobalah juga efek menambah lebih banyak unit tersembunyi pada arsitektur model Anda dan pelajari dampaknya pada evaluasi, seperti berikut:

model = Sequential()
model.add(Dense(128, input_dim=12, activation='relu'))
model.add(Dense(1))

Ingat lagi bahwa, secara umum, karena Anda tidak memiliki banyak data, overfitting bisa menjadi lebih buruk. Itulah mengapa Anda sebaiknya menggunakan jaringan kecil.

Beberapa Percobaan Lagi: Parameter Optimisasi

Selain menambah layer dan bermain dengan unit tersembunyi, Anda juga dapat mencoba menyesuaikan (sebagian) parameter algoritma optimisasi yang Anda berikan ke fungsi compile(). Sejauh ini, Anda selalu meneruskan string, seperti rmsprop, ke argumen optimizer.

Tetapi tidak selalu harus seperti itu!

Cobalah misalnya mengimpor RMSprop dari keras.models dan sesuaikan learning rate lr. Anda juga dapat mengubah nilai default yang ditetapkan untuk parameter lain di RMSprop(), namun ini tidak direkomendasikan. Anda dapat memperoleh informasi lebih lanjut di sini.

from keras.optimizers import RMSprop
rmsprop = RMSprop(lr=0.0001)
model.compile(optimizer=rmsprop, loss='mse', metrics=['mae'])

Cobalah juga bereksperimen dengan algoritma optimisasi lain, seperti Stochastic Gradient Descent (SGD). Apakah Anda melihat efeknya?

from keras.optimizers import SGD, RMSprop
sgd=SGD(lr=0.1)
model.compile(optimizer=sgd, loss='mse', metrics=['mae'])

Lanjutkan!

Tutorial ini hanyalah permulaan perjalanan deep learning Anda dengan Python dan Keras. Masih banyak yang perlu dipelajari, jadi mengapa tidak mengambil kursus Deep Learning in Python dari DataCamp? Sambil menunggu, pastikan juga untuk memeriksa dokumentasi Keras, jika Anda belum melakukannya. Anda akan menemukan lebih banyak contoh dan informasi tentang semua fungsi, argumen, lebih banyak layer, dll. Ini pasti akan menjadi sumber yang tak tergantikan saat Anda belajar bekerja dengan jaringan saraf di Python! Jika Anda lebih suka membaca buku yang menjelaskan dasar-dasar deep learning (dengan Keras) sekaligus bagaimana penggunaannya dalam praktik, Anda pasti harus membaca buku Deep Learning in Python karya François Chollet.

Jalankan dan edit kode dari Tutorial ini secara online

Topik

Pelajari lebih jauh tentang Python dan Deep Learning

Kursus

Pengantar Deep Learning dengan Keras

4 jam

46.5K

Pelajari cara mulai membangun model deep learning dengan Keras.

Lihat Detail

Mulai Kursus

Kursus

Pemodelan Citra dengan Keras

4 jam

40K

Pelajari cara melakukan analisis gambar menggunakan Keras dengan Python dengan membangun, melatih, dan mengevaluasi jaringan saraf konvolusional.

Lihat Detail

Mulai Kursus

Kursus

Deep Learning Tingkat Lanjut dengan Keras

4 jam

35.1K

Pelajari cara mengembangkan model deep learning dengan Keras.

Lihat Detail

Mulai Kursus

Lihat Selengkapnya

Terkait

blogs

Tutorial Korelasi di R

Dapatkan pengenalan dasar-dasar korelasi di R: pelajari lebih lanjut tentang koefisien korelasi, matriks korelasi, plotting korelasi, dan sebagainya.

David Woods

13 mnt

blogs

40 Pertanyaan Wawancara DBMS Teratas di 2026

Kuasai pertanyaan wawancara basis data, dari konsep SQL dasar hingga skenario desain sistem tingkat lanjut. Panduan mendalam ini mencakup semua yang Anda perlukan untuk sukses di wawancara DBMS dan meraih peran berikutnya.

Dario Radečić

15 mnt

blogs

Spaghetti Plot dan Jalur Badai

Temukan alasan mengapa Anda sebaiknya (tidak) menggunakan spaghetti plot untuk menyampaikan ketidakpastian jalur prediksi badai serta dampaknya terhadap interpretasi.