Kecerdasan buatan dengan Python

Kecerdasan Buatan dengan Python @2022 Penulis Ali Mulyanto Nopiyanto Tukino Editor Joni Tesmanto, S.Sos., M.M. Cetakan 1, November 2022 ISBN: 978-623-90041-3-2 Panca Sakti Bekasi University Press Bekasi Jawa Barat, [email protected] https://psbupress.com/ [ ii ]

Kata Pengantar Puji Syukur kami panjatkan kehadirat Allah SWT yang karena karunianya kami dapat menyelesaian penyusuan buku dengan judul “Kecerdasan buatan dengan python”. Buku ini berisi lima bab yang membahas metode atau algoritma dalam kecerdasan buatan yang diimplemntasikan menggunakan program python. Bab 1 membahas membangun model prediksi sendiri, bab 2 membahas prediksi dengan Algoritma random forests, bab 3 membahas aplikasi untuk klasifikasi komentar, bab 4 membahas tentang Neural Network, dan bab 5 membahas tetang deep learning. Akhirnya penulis mengucapkan terima kasih kepada semua pihak yang telah membantu sehinga buku ini dapat diterbitkan sebagai bahan pelengkap ilmu pengetahuan, khususnya tentang teori kecerdasan buatan. Tim penulis juga berterima kasih kepada penerbit PSBUPRESS Bekasi atas kerjasama dalam penulisan dan penerbitan buku ini. Semoga buku ini dapat memberikan sumbangan yang berarti bagi perkembangan ilmu pengetahuan di Indonesia, Khusunya Universitas Panca Sakti dan Universitas Buana Perjuangan Karawang, Bekasi, 24 November 2022 Tim Penulis Ali Mulyanto, S.Kom.,M.Kom Nopiyanto, ST.,M.Kom Tukino, Ir., M.Si. [ iii ]

Daftar Isi Kata Pengantar .............................................................................................................. iii Daftar Isi ......................................................................................................................... iv 1 Membangun Model Prediksi Sendiri ..................................................................... 1 Evaluasi ........................................................................................................................ 3 Decision trees............................................................................................................... 7 Common API scikit-learn untuk klasifikasi.......................................................... 11 Prediksi yang melibatkan decision trees dan dataset kinerja siswa ................. 12 Ringkasan................................................................................................................... 23 2 Prediksi Dengan Random Forests.......................................................................... 24 Random forests ......................................................................................................... 24 Penggunaan random forests ................................................................................... 26 Memprediksi spesies burung dengan random forests........................................ 26 Membuat matriks konfusi untuk data ................................................................... 36 Ringkasan................................................................................................................... 47 3 Applikasi untuk Klasifikasi Komentar................................................................... 48 Klasifikasi teks........................................................................................................... 48 Teknik pembelajaran mesin .................................................................................... 50 Bag-of-words ............................................................................................................. 51 Mendeteksi spam komentar YouTube................................................................... 55 Model Word2Vec ...................................................................................................... 70 Doc2Vec...................................................................................................................... 72 vektor dokumen........................................................................................................ 73 Mendeteksi sentimen positif atau negatif dalam ulasan pengguna.................. 75 [ iv ]

Ringkasan................................................................................................................... 86 4 Neural Networks...................................................................................................... 87 Memahami jaringan saraf........................................................................................ 87 Feed-forward neural networks ................................................................................ 89 Mengidentifikasi genre musik dengan jaringan saraf......................................... 95 Memperbaiki deteksi spam menggunakan jaringan saraf ............................... 107 Ringkasan................................................................................................................. 117 5 Deep Learning ....................................................................................................... 118 Metode Deep Learning .......................................................................................... 119 Konvolusi dan penyatuan (pooling) .................................................................... 120 Mengidentifikasi simbol matematika tulisan tangan dengan CNN ............... 129 Meninjau kembali pengidentifikasi spesies burung untuk menggunakan gambar...................................................................................................................... 151 Ringkasan................................................................................................................. 164 Daftar pustaka ............................................................................................................ 166 Lampiran ..................................................................................................................... 167 Instal Anaconda dan Python................................................................................. 167 [v]

1 Membangun Model Prediksi Sendiri Masyarakat kita lebih maju secara teknologi dari sebelumnya. Teknologi Artificial Intelligence (AI) sudah menyebar ke seluruh dunia, mereplikasi umat manusia. Niat untuk menciptakan mesin yang dapat meniru aspek kecerdasan manusia seperti penalaran, pembelajaran, dan pemecahan masalah melahirkan perkembangan teknologi AI. AI benar-benar menyaingi sifat manusia. Dengan kata lain, AI membuat mesin berpikir dan berperilaku seperti manusia. Contoh terbaik yang dapat menunjukkan kekuatan teknologi ini adalah saran tag atau fitur pengenalan wajah Facebook. Melihat dampak luar biasa dari teknologi ini di dunia saat ini, AI pasti akan menjadi salah satu teknologi terhebat di tahun- tahun mendatang. Kita akan bereksperimen dengan proyek berbasis teknologi AI, mengeksplorasi klasifikasi menggunakan algoritma pembelajaran mesin bersama dengan bahasa pemrograman Python. Kita juga akan mengeksplorasi beberapa contoh untuk pemahaman yang lebih baik. Dalam bab ini, kita akan mengeksplorasi topik menarik berikut:  Gambaran umum tentang teknik klasifikasi  Pustaka scikit Python klasifikasi dan teknik evaluasi AI memberi kita berbagai teknik klasifikasi yang luar biasa, tetapi klasifikasi pembelajaran mesin akan menjadi yang terbaik untuk memulai karena ini adalah klasifikasi yang paling umum dan termudah untuk dipahami oleh pemula. Dalam kehidupan kita sehari-hari, mata kita menangkap jutaan gambar: baik itu di buku, di layar tertentu, atau mungkin sesuatu yang Anda tangkap di sekitar

Anda. Gambar-gambar ini ditangkap oleh mata kita membantu kita mengenali dan mengklasifikasikan objek. Aplikasi kita didasarkan pada logika yang sama. Di sini, kita membuat aplikasi yang akan mengidentifikasi gambar menggunakan algoritma pembelajaran mesin. Bayangkan kita memiliki gambar apel dan jeruk, dengan melihat aplikasi kita yang akan membantu mengidentifikasi apakah gambar itu apel atau jeruk. Jenis klasifikasi ini dapat disebut sebagai klasifikasi biner, yang berarti mengklasifikasikan objek dari himpunan yang diberikan menjadi dua kelompok. Kita akan membutuhkan sejumlah gambar apel dan jeruk, dan algoritma pembelajaran mesin yang akan diatur sedemikian rupa sehingga aplikasi dapat mengklasifikasikan kedua jenis gambar tersebut. Dengan kata lain, kita membuat algoritma ini mempelajari perbedaan antara dua objek untuk membantu mengklasifikasikan semua contoh dengan benar. Hal ini dikenal sebagai pembelajaran terawasi. Sekarang mari kita bandingkan pembelajaran yang diawasi dengan pembelajaran tanpa pengawasan. Mari kita asumsikan bahwa kita tidak mengetahui label data yang sebenarnya (yang berarti kita tidak tahu apakah gambar tersebut adalah contoh apel atau jeruk). Dalam kasus seperti itu, klasifikasi tidak akan banyak membantu. Metode pengelompokan selalu dapat meringankan skenario seperti itu. Hasilnya akan menjadi model yang dapat digunakan dalam aplikasi, dan akan berfungsi seperti yang terlihat pada diagram berikut. Aplikasi ini akan mengingat fakta tentang perbedaan antara apel dan jeruk dan mengenali gambar sebenarnya menggunakan algoritma pembelajaran mesin. Jika kita mengambil input baru, model akan memberi tahu kita tentang keputusannya apakah inputnya apel atau oranye. Dalam contoh ini, aplikasi yang kita buat dapat mengidentifikasi gambar apel dengan tingkat kepercayaan 75%: [2]

Terkadang, kita ingin mengetahui tingkat kepercayaan, dan di lain waktu kita hanya ingin jawaban akhir, yaitu pilihan model yang paling percaya diri. Evaluasi Kita dapat mengevaluasi seberapa baik model bekerja dengan mengukur akurasinya. Akurasi akan didefinisikan sebagai persentase kasus yang diklasifikasikan dengan benar. Kita dapat menganalisis kesalahan yang dibuat oleh model, atau tingkat kekeliruan, menggunakan matriks Konfusi (confusion matrix). Matriks konfusi mengacu pada kekeliruan dalam model, tetapi matriks konfusi ini dapat menjadi sedikit sulit untuk dipahami ketika menjadi sangat besar. Mari kita lihat contoh klasifikasi biner berikut, yang menunjukkan berapa kali model membuat prediksi objek yang benar: [3]

Pada tabel sebelumnya, deretan apel dan Jeruk mengacu pada kasus di mana objek sebenarnya adalah apel atau sebenarnya jeruk. Kolom mengacu pada prediksi yang dibuat oleh model. Kita melihat bahwa dalam contoh, ada 20 apel yang diprediksi dengan benar, sedangkan ada 5 apel yang salah diidentifikasi sebagai jeruk. Idealnya, matriks konfusi harus memiliki semua nol, kecuali diagonal. Di sini kita dapat menghitung akurasi dengan menambahkan angka-angka secara diagonal, sehingga ini semua adalah contoh yang diklasifikasikan dengan benar, dan membagi jumlah itu dengan jumlah semua angka dalam matriks: Di sini kita mendapatkan akurasi sebagai 84%. Untuk mengetahui lebih banyak tentang matriks kekeliruan, mari kita lihat contoh lain, yang melibatkan tiga kelas, seperti yang terlihat pada diagram berikut: [4]

Ada tiga spesies bunga iris yang berbeda. Matriks memberikan data mentah tentang prediksi yang benar dan salah. Jadi, setosa diprediksi dengan benar 13 kali dari semua contoh gambar setosa dari dataset. Di sisi lain, versicolor diprediksi dengan benar pada 10 kesempatan, dan ada 6 kesempatan di mana versicolor diprediksi sebagai virginica. Sekarang mari kita normalkan matriks kekeliruan kita dan tunjukkan persentase kasus yang memprediksi gambar dikoreksi atau salah. Dalam contoh kita, kita melihat bahwa spesies setosa diprediksi dengan benar semuanya: Selama evaluasi matriks konfusi, kita juga melihat bahwa sistem menjadi bingung antara dua spesies: versicolor dan virginica. Ini juga memberi kita kesimpulan bahwa sistem tidak dapat mengidentifikasi spesies virginica sepanjang waktu. Untuk contoh selanjutnya, kita perlu lebih menyadari bahwa kita tidak dapat memiliki akurasi yang sangat tinggi karena sistem akan dilatih dan diuji pada data yang sama. Ini akan menyebabkan menghafal set pelatihan dan overfitting model. Oleh karena itu, kita harus mencoba membagi data menjadi set pelatihan [5]

dan pengujian, pertama dalam 90/10% atau 80/20%. Kemudian kita harus menggunakan set pelatihan untuk mengembangkan model dan set tes untuk melakukan dan menghitung akurasi matriks konfusi. Kita perlu berhati-hati untuk tidak memilih set pengujian yang benar-benar baik atau set pengujian yang sangat buruk untuk mendapatkan akurasi. Oleh karena itu untuk memastikan kita menggunakan validasi yang dikenal sebagai validasi silang K-fold. Untuk memahaminya sedikit lebih baik, bayangkan validasi silang 5 kali lipat, di mana kita memindahkan set pengujian sebanyak 20 karena ada 5 baris. Kemudian kita memindahkan set yang tersisa dengan dataset dan menemukan rata-rata semua lipatan: Cukup membingungkan, bukan? Tetapi scikit-learn memiliki dukungan bawaan untuk validasi silang. Fitur ini akan menjadi cara yang baik untuk memastikan bahwa kita tidak melebih-lebihkan model kita dan kita tidak menjalankan model kita pada set pengujian yang buruk. [6]

Decision trees Di bagian ini, kita akan menggunakan Decision trees dan data kinerja siswa untuk memprediksi apakah seorang anak akan berprestasi baik di sekolah. Kita akan menggunakan teknik sebelumnya dengan beberapa kode scikit-learn. Sebelum memulai dengan prediksi, mari kita pelajari sedikit tentang apa itu decision trees. Decision trees adalah salah satu teknik paling sederhana untuk klasifikasi. Mereka dapat dibandingkan dengan permainan 20 pertanyaan, di mana setiap simpul di pohon adalah simpul daun atau simpul pertanyaan. Pertimbangkan kasus kemampuan bertahan Titanic, yang dibangun dari kumpulan data yang mencakup data tentang hasil kelangsungan hidup setiap penumpang Titanic. Pertimbangkan simpul pertama kita sebagai pertanyaan: Apakah penumpangnya laki-laki? Jika tidak, maka kemungkinan besar penumpang selamat. Jika tidak, kita akan memiliki pertanyaan lain untuk ditanyakan tentang penumpang pria: Apakah pria berusia di atas 9,5 tahun? (di mana 9,5 dipilih oleh prosedur pembelajaran decision trees sebagai pemisahan data yang ideal). Jika jawabannya Ya, maka kemungkinan besar penumpang tersebut tidak selamat. Jika jawabannya Tidak, maka akan menimbulkan pertanyaan lain: Apakah penumpang itu saudara kandung? Diagram berikut akan memberi Anda penjelasan singkat: [7]

Memahami decision trees tidak mengharuskan Anda menjadi ahli dalam proses pembelajaran decision trees. Seperti yang terlihat pada diagram sebelumnya, proses tersebut membuat pemahaman data menjadi sangat sederhana. Tidak semua model pembelajaran mesin semudah dipahami seperti decision trees. Sekarang mari kita memperdalam decision trees dengan mengetahui lebih banyak tentang proses pembelajaran decision trees. Menggunakan kumpulan data titanic yang sama yang kita gunakan sebelumnya, kita akan menemukan atribut terbaik untuk dibagi berdasarkan perolehan informasi, yang juga dikenal sebagai entropi: [8]

Perolehan informasi (Information gain) tertinggi hanya ketika hasilnya lebih dapat diprediksi setelah mengetahui nilai dalam kolom tertentu. Dengan kata lain, jika kita tahu apakah penumpang itu laki-laki atau perempuan, kita akan tahu apakah dia selamat, maka perolehan informasi tertinggi untuk kolom jenis kelamin. Kita tidak menganggap kolom usia terbaik untuk pemisahan pertama kita karena kita tidak tahu banyak tentang usia penumpang, dan bukan pemisahan pertama terbaik karena kita akan tahu lebih sedikit tentang hasilnya jika yang kita tahu hanyalah usia penumpang. Setelah dipecah pada kolom jenis kelamin sesuai dengan perolehan informasi, yang kita miliki sekarang adalah himpunan bagian perempuan dan laki-laki, seperti yang terlihat pada tangkapan layar berikut: [9]

Setelah split, kita memiliki satu ruas dan satu simpul pertanyaan, seperti yang terlihat pada tangkapan layar sebelumnya, dan dua jalur yang dapat diambil tergantung pada jawaban pertanyaan. Sekarang kita perlu menemukan atribut terbaik lagi di kedua himpunan bagian. Subset kiri, di mana semua penumpang adalah perempuan, tidak memiliki atribut yang baik untuk dibagi karena banyak penumpang yang selamat. Oleh karena itu, subset kiri hanya berubah menjadi simpul daun yang memprediksi kelangsungan hidup. Di sisi kanan, atribut BHF dipilih sebagai split terbaik, dengan Menggunakan nilai 9,5 tahun sebagai split. Kita mendapatkan dua subset lagi: usia lebih besar dari 9,5 dan usia lebih rendah dari 9,5: [ 10 ]

Ulangi proses pemisahan data menjadi dua himpunan bagian baru sampai tidak ada pemisahan yang baik, atau tidak ada atribut yang tersisa, dan simpul daun dibentuk sebagai pengganti simpul pertanyaan. Sebelum kita mulai dengan model prediksi kita , beri tahu kita sedikit lebih banyak tentang paket scikit-learn. Common API scikit-learn untuk klasifikasi Di bagian ini, kita akan mempelajari cara membuat kode menggunakan paket scikit-learn untuk membangun dan menguji decision trees. Scikit-learn berisi banyak set fuction sederhana. Sebenarnya, kecuali untuk baris kode kedua yang dapat Anda lihat di tangkapan layar berikut, yaitu khusus tentang decision trees, kita juga akan menggunakan fuction yang sama untuk pengklasifikasi lain, seperti random forests: Sebelum kita melangkah lebih jauh ke bagian teknis, mari kita coba memahami apa yang dimaksud dengan baris kode. Dua baris kode pertama digunakan untuk menetapkan decision trees, tetapi kita dapat menganggap ini belum dibangun karena kita belum mengarahkan pohon ke set yang terlatih. Baris ketiga membangun pohon menggunakan fuction fit. Selanjutnya, kita menilai daftar contoh dan mendapatkan angka akurasi. Kedua baris kode ini akan digunakan untuk membangun decision trees. Setelah itu, kita memprediksi fuction dengan satu contoh, yang berarti kita akan mengambil baris data untuk [ 11 ]

melatih model dan memprediksi output dengan kolom bertahan. Terakhir, kita menjalankan validasi silang, memisahkan data dan membuat entri untuk setiap pemisahan pelatihan dan mengevaluasi pohon untuk setiap pemisahan pengujian. Saat menjalankan kode ini, hasil yang kita dapatkan adalah skor dan skor rata-rata kita. Di sini Anda akan memiliki pertanyaan: Kapan kita harus menggunakan decision trees? Jawabannya bisa sangat sederhana karena decision trees itu sederhana dan mudah diinterpretasikan dan memerlukan sedikit persiapan data. Anda dapat menunjukkan hasil decision trees kepada ahli materi pelajaran mana pun, seperti sejarawan Titanic (sebagai contoh kita). Bahkan para ahli yang tahu sedikit tentang pembelajaran mesin mungkin akan dapat mengikuti pertanyaan pohon dan mengukur apakah pohon itu akurat. Decision trees dapat berkinerja lebih baik ketika data memiliki sedikit atribut, tetapi dapat berkinerja buruk ketika data memiliki banyak atribut. Ini karena pohon mungkin tumbuh terlalu besar untuk dapat dimengerti dan dapat dengan mudah menyesuaikan data pelatihan dengan memperkenalkan cabang yang terlalu spesifik untuk data pelatihan dan tidak benar-benar berhubungan dengan data uji yang dibuat, ini dapat mengurangi kemungkinan mendapatkan hasil yang akurat. Karena, sekarang, Anda mengetahui dasar-dasar decision trees, kita sekarang siap untuk mencapai tujuan kita membuat model prediksi menggunakan data kinerja siswa. Prediksi yang melibatkan decision trees dan dataset kinerja siswa Di bagian ini, kita akan menggunakan decision trees untuk memprediksi kinerja siswa menggunakan siswa, data kinerja masa lalu. Kita akan menggunakan set data kinerja siswa, yang tersedia di penyimpanan pembelajaran mesin UC Irvine di https://archive.ics.uci.edu/ml/datasets/student+performance [ 12 ]

Berikut dataset student-por.csv [ 13 ]

Tujuan akhir kita adalah untuk memprediksi apakah siswa itu lulus atau gagal. Dataset berisi data sekitar 649 siswa, dengan 30 atribut untuk setiap siswa. Atribut yang terbentuk adalah campuran kategori kata dan frase, dan atribut numerik. Atribut campuran ini menyebabkan masalah kecil yang perlu diperbaiki. Kita perlu mengubah atribut kata dan frase tersebut menjadi angka. Tangkapan layar berikut menunjukkan paruh pertama atribut dari data: Terlihat beberapa atribut bersifat kategoris, seperti school; sex; Mjob, yaitu pekerjaan ibu; Fjob, yang merupakan pekerjaan ayah; reason; dan guardin. Lainnya, seperti age dan traveltime, bersifat numerik. Tangkapan layar berikut menunjukkan paruh kedua atribut dari data: [ 14 ]

Jelas bahwa beberapa atribut adalah prediktor yang baik, seperti absences dan failures, sementara atribut lain mungkin kurang prediktif, seperti romantic relationship atau gardians. Decision trees akan mencoba untuk mengidentifikasi atribut yang paling penting atau prediktif menggunakan perolehan informasi yang telah disediakan. Kita dapat melihat pohon yang dihasilkan dan mengidentifikasi atribut yang paling prediktif karena atribut yang paling prediktif akan menjadi pertanyaan paling awal. Dataset asli memiliki tiga nilai tes: G1, G2, dan G3. Dimana G1 akan menjadi kelas pertama, G2 menjadi kelas dua, dan G3 menjadi nilai akhir. Kita akan menyederhanakan masalah dengan hanya memberikan lulus atau gagal. Ini bisa dilakukan dengan menjumlahkan tiga nilai ini dan memeriksa apakah jumlahnya cukup besar yaitu 35. Hasilnya 50% siswa yang lulus dan gagal, memberi kita kumpulan data yang seimbang. Sekarang mari kita lihat kodenya: [ 15 ]

Kita mengimpor dataset (student-por.csv), yang dilengkapi dengan titik koma, bukan koma; karenanya, kita menyebutkan pemisah sebagai titik koma. Untuk verifikasi silang, kita akan menemukan jumlah baris dalam dataset. Menggunakan variabel panjang, kita dapat melihat bahwa ada baris. Selanjutnya kita tambahkan kolom untuk lulus dan gagal. Data dalam kolom ini akan berisi 1 atau 0, di mana 1 berarti lulus dan 0 berarti gagal. Kita akan melakukannya dengan menghitung dengan setiap baris berapa jumlah nilai tesnya. Ini akan dihitung seolah-olah jumlah tiga skor lebih besar dari atau sama dengan 35, 1 diberikan kepada siswa dan gagal untuk aturan itu 0 diberikan kepada siswa. Kita perlu menambahkan aturan ini pada setiap baris dataset, dan ini akan dilakukan dengan menggunakan function apply, yang merupakan fitur dari Pandas. Di sini axis=1 berarti gunakan berlaku per baris dan axis=0 berarti berlaku per kolom. Baris berikutnya berarti bahwa sebuah variabel perlu dihapus: baik G1, G2, G3. Tangkapan layar kode berikut akan memberi Anda gambaran tentang apa yang baru saja kita pelajari: Tangkapan layar berikut menunjukkan 5 baris pertama dari kumpulan data dan 31 kolom. Ada 31 kolom karena kita memiliki semua atribut ditambah kolom lulus dan gagal: [ 16 ]

Seperti disebutkan sebelumnya, beberapa kolom ini adalah kata atau frasa, seperti Mjob, Fjob, internet, dan romantics. Kolom-kolom ini perlu diubah menjadi angka, yang dapat dilakukan dengan menggunakan fuction get_dummies, yang merupakan fitur Pandas, dan kita perlu menyebutkan kolom mana yang ingin kita ubah menjadi bentuk numerik. Dalam kasus Mjob, misalnya, fuction itu akan melihat semua kemungkinan jawaban yang berbeda atau nilai di kolom itu dan itu akan memberi setiap nilai nama kolom. Kolom ini akan menerima nama seperti mengganti nama kolom menjadi Mjob at_home, Mjob health, atau Mjob. Kolom baru ini, misalnya, kolom Mjob at_home akan memiliki nilai 1 dan sisanya akan memiliki 0. Ini berarti hanya satu dari kolom baru yang dihasilkan akan memiliki satu. Ini dikenal sebagai one-hot-encoding. Alasan nama ini diberikan misalnya, bayangkan beberapa kabel masuk ke sirkuit. Misalkan di sirkuit ada lima kabel, dan Anda ingin menggunakan metode pengkodean satu-panas, Anda hanya perlu mengaktifkan salah satu kabel ini sambil menjaga sisa kabel mati. Saat melakukan fuction get_dummies pada dataset kita , Anda dapat melihat misalnya kolom activities_no dan activities_yes. Kolom yang awalnya terkait yang mengatakan tidak memiliki 1 sebagai nilai di bawah kolom activies_no diikuti oleh 0. Sama seperti untuk aktivitas_yes memiliki ya itu akan memiliki nilai 0 diikuti oleh 1 untuk yang lain. Hal ini menyebabkan pembuatan lebih banyak kolom baru sekitar 57 total tetapi ini membuat dataset kita penuh dengan data numerik. Tangkapan layar berikut menunjukkan kolom activity_yes dan kolom activities_no: [ 17 ]

Di sini kita perlu mengacak baris dan menghasilkan set pelatihan dengan 500 baris pertama dan sisanya 149 baris untuk set tes dan kemudian kita hanya perlu mendapatkan atribut dari set pelatihan yang berarti kita akan menyingkirkan kolom pass dan menyimpan kolom pass terpisah. Hal yang sama diulang untuk set pengujian. Kita akan menerapkan atribut ke seluruh dataset dan menyimpan kolom pass secara terpisah untuk seluruh dataset. Sekarang kita akan menemukan berapa banyak yang lulus dan gagal dari seluruh dataset. Ini dapat dilakukan dengan menghitung persentase jumlah lulus dan gagal yang akan memberi kita hasil 328 dari 649. Ini adalah persentase lulus yang kira-kira sekitar 50% dari dataset. Ini merupakan kumpulan data yang seimbang: [ 18 ]

Selanjutnya, kita mulai membangun decision trees menggunakan function DecisionTreeClassifier dari paket scikit-learn, yang merupakan kelas yang mampu melakukan klasifikasi multi-kelas pada kumpulan data. Di sini kita akan menggunakan entropi atau metrik perolehan informasi untuk memutuskan kapan harus membagi. Kita akan membagi pada kedalaman lima pertanyaan, dengan menggunakan max_depth=5 sebagai kedalaman pohon awal untuk merasakan bagaimana pohon menyesuaikan data: Untuk mendapatkan gambaran umum dari dataset kita, kita perlu membuat representasi visual dari pohon. Ini dapat dicapai dengan menggunakan satu fuction lagi dari paket scikit-learn: expoert_graphviz. Tangkapan layar berikut menunjukkan representasi pohon di Jupyter Notebook: Untuk mendapatkan gambaran umum tentang dataset kita , kita perlu membuat representasi visual pohon. Ini dapat dicapai dengan menggunakan satu fuction lagi dari paket scikit-learn: expoert_graphviz. Tangkapan layar berikut menunjukkan representasi pohon di Notebook Jupyter: [ 19 ]

Sangat mudah untuk memahami representasi sebelumnya bahwa dataset dibagi menjadi dua bagian. Mari kita coba menafsirkan pohon dari atas. Dalam hal ini jika kegagalan lebih besar atau sama dengan 0,5, itu berarti benar dan ditempatkan di sisi kiri pohon. Pertimbangkan pohon selalu benar di sisi kiri dan salah di sisi kanan, yang berarti tidak ada kegagalan sebelumnya. Dalam representasi kita dapat melihat sisi kiri pohon sebagian besar berwarna biru yang berarti memprediksi lulus meskipun ada beberapa pertanyaan dibandingkan dengan kegagalan maksimal 5 pertanyaan. Pohon berada di sebelah kanan jika kegagalan kurang dari 0,5, hal ini membuat siswa gagal, yang berarti pertanyaan pertama salah. Prediksi gagal jika dalam warna oranye tetapi karena berlanjut ke lebih banyak pertanyaan karena kita telah menggunakan max_depth=5. Blok kode berikut menunjukkan metode untuk mengekspor representasi visual dengan mengklik Ekspor dan simpan ke PDF atau format apa pun jika Anda ingin memvisualisasikannya nanti: [ 20 ]

Selanjutnya kita cek skor pohon menggunakan testing set yang kita buat tadi: Hasil yang kita dapatkan adalah sekitar 60%. Sekarang mari kita verifikasi silang hasilnya untuk memastikan bahwa dataset dilatih dengan sempurna: Melakukan cross-validation pada seluruh dataset yang akan membagi data pada basis 20/80, dimana 20% pada testing set dan 80% pada train ing set. Hasil rata- rata adalah 67%. Ini menunjukkan bahwa kita memiliki dataset yang seimbang. Di sini kita memiliki berbagai pilihan terkait max_depth: [ 21 ]

Kita menggunakan berbagai nilai max_depth dari 1 hingga 20, Mengingat kita membuat pohon dengan satu pertanyaan atau dengan 20 pertanyaan memiliki nilai kedalaman 20 yang akan memberi kita pertanyaan lebih dari 20 yaitu Anda harus turun 20 langkah untuk mencapai simpul daun. Di sini kita kembali melakukan validasi silang, menyimpan dan mencetak jawaban kita. Ini akan memberikan akurasi dan perhitungan yang berbeda. Pada analisa didapatkan bahwa pada kedalaman 2 dan 3,nilai akurasi adalah yang terbaik dibandingkan akurasi dari rata-rata yang ditemukan sebelumnya. Tangkapan layar berikut menunjukkan data yang akan kita gunakan untuk membuat grafik: [ 22 ]

Bilah kesalahan yang ditunjukkan pada tangkapan layar berikut adalah standar deviasi dalam skor, yang menyimpulkan bahwa kedalaman 2 atau 3 ideal untuk kumpulan data ini, dan asumsi kita tentang 5 salah: Model kita menunjukkan bahwa memiliki lebih banyak kedalaman tidak selalu membantu, juga tidak memiliki satu pertanyaan tentang apakah Anda gagal sebelumnya? memberi kita jumlah informasi yang sama seperti yang diberikan dua atau tiga pertanyaan kepada kita . Ringkasan Dalam bab ini kita belajar tentang klasifikasi dan teknik untuk evaluasi, dan belajar secara mendalam tentang decision trees. Kita juga membuat model untuk memprediksi kinerja siswa. Di bab berikutnya, kita akan mempelajari lebih lanjut tentang random forests dan menggunakan pembelajaran mesin dan random forests untuk memprediksi spesies burung. [ 23 ]

2 Prediksi Dengan Random Forests Dalam bab ini, kita akan melihat teknik klasifikasi dengan random forests. Kita akan menggunakan scikit-learn, seperti yang kita lakukan di bab sebelumnya. Kita akan melihat contoh memprediksi spesies burung dari atribut deskriptif dan kemudian menggunakan matriks kekeliruan pada mereka. Berikut daftar detail topiknya:  Klasifikasi dan teknik evaluasi  Memprediksi spesies burung dengan random forests Confusion matrix Random forests Random forests adalah perpanjangan dari decision trees dan merupakan semacam metode ensemble. Metode ensemble dapat mencapai akurasi tinggi dengan membangun beberapa pengklasifikasi dan menjalankan masing-masing pengklasifikasi secara independen. Saat pengklasifikasi membuat keputusan, Anda dapat menggunakan keputusan paling umum dan rata-rata. Jika kita menggunakan metode yang paling umum, itu disebut voting. Berikut adalah diagram yang menggambarkan metode ensemble: [ 24 ]

Anda dapat menganggap setiap pengklasifikasi sebagai khusus untuk perspektif unik pada data. Setiap pengklasifikasi mungkin tipe yang berbeda. Misalnya, Anda dapat menggabungkan decision trees dan regresi logistik dan jaringan saraf, atau pengklasifikasi mungkin bertipe sama tetapi dilatih pada bagian atau subset data pelatihan yang berbeda. Random forests adalah kumpulan atau ansambel decision trees. Setiap pohon dilatih pada subset acak dari atribut, seperti yang ditunjukkan pada diagram berikut: Decision trees ini adalah decision trees yang khas, tetapi ada beberapa di antaranya. Perbedaannya, dibandingkan dengan decision trees tunggal, [ 25 ]

khususnya di random forests, adalah bahwa setiap pohon hanya diperbolehkan untuk melihat beberapa atribut, biasanya sejumlah kecil relatif terhadap jumlah total atribut yang tersedia. Setiap pohon dikhususkan hanya untuk atribut tersebut. Pohon-pohon khusus ini dikumpulkan dan masing-masing menawarkan suara untuk prediksinya. Hasil mana pun yang mendapat suara terbanyak dari ansambel pohon khusus adalah pemenangnya. Itulah prediksi terakhir dari random forest. Penggunaan random forests Kita harus Menggunakanuntuk menggunakan random forests ketika ada cukup banyak atribut untuk membuat pohon dan akurasinya sangat penting. Ketika ada lebih sedikit pohon, interpretasinya sulit dibandingkan dengan decision trees tunggal. Anda harus menghindari penggunaan random forests jika interpretasi penting karena jika terlalu banyak pohon, modelnya cukup besar dan dapat memakan banyak memori selama pelatihan dan prediksi. Oleh karena itu, lingkungan dengan sumber daya terbatas mungkin tidak dapat menggunakan random forests. Bagian selanjutnya akan menjelaskan prediksi jenis burung menggunakan random forests. Memprediksi spesies burung dengan random forests Di sini kita akan menggunakan random forests untuk memprediksi spesies burung. Kita akan menggunakan Caltech-Dataset UC San Diego (http://www.vision.caltech.edu/datasets/cub_200_2011/), yang berisi sekitar 12.000 foto burung dari 200 spesies berbeda. Di sini kita tidak akan melihat gambar-gambarnya karena itu akan membutuhkan jaringan saraf convolutional (CNN) dan ini akan dibahas dalam bab-bab selanjutnya. CNN dapat menangani gambar jauh lebih baik daripada random forests. Sebagai gantinya, kita akan menggunakan atribut burung seperti ukuran, bentuk, dan warna. Berikut adalah beberapa spesies dalam dataset: [ 26 ]

Beberapa, seperti American Crow dan Fish Crow, hampir tidak bisa dibedakan, setidaknya secara visual. Atribut untuk setiap foto, seperti warna dan ukuran, sebenarnya telah diberi label oleh manusia. Caltech dan UCSD menggunakan pekerja manusia di Mechanical Turk Amazon untuk memberi label dataset. Peneliti sering menggunakan Mechanical Turk, yang merupakan layanan situs web di mana seseorang dibayar sejumlah kecil uang untuk setiap foto yang mereka beri label untuk meningkatkan dataset menggunakan wawasan manusia daripada prediksi mesin. Jika Anda memiliki dataset Anda sendiri yang membutuhkan banyak label yang disediakan oleh manusia, Anda mungkin Menggunakanuntuk mengeluarkan sejumlah uang untuk Mechanical Turk untuk menyelesaikan tugas itu. Berikut ini contoh satu foto dan labelnya: . [ 27 ]

Kita dapat melihat bahwa Tanager Musim Panas ditandai memiliki tenggorokan merah, pola perut padat, bentuk seperti bertengger, dan sebagainya. Kumpulan data mencakup informasi tentang berapa lama waktu yang dibutuhkan setiap orang untuk memutuskan label dan seberapa yakin orang tersebut dengan keputusan mereka, tetapi kita tidak akan menggunakan informasi itu. Data dibagi menjadi beberapa file. Kita akan membahas file-file itu sebelum masuk ke kode: [ 28 ]

File classes.txt menunjukkan ID kelas dengan nama spesies burung. File images.txt menunjukkan ID gambar dan nama file. Spesies untuk setiap foto diberikan dalam file image_class_label.txt yang menghubungkan ID kelas dengan ID gambar. File attribute.txt memberikan nama setiap atribut, yang pada akhirnya tidak akan terlalu penting bagi kita . Kita hanya membutuhkan ID atribut: Terakhir, file yang paling penting adalah image_attribute_labels.txt: [ 29 ]

Ini menghubungkan setiap gambar dengan atributnya dalam nilai biner yang ada atau tidak ada untuk atribut itu. Pengguna di Mechanical Turk menghasilkan setiap baris dalam file ini. Sekarang, mari kita lihat kodenya: Pertama-tama kita akan memuat file CSV dengan semua label atribut gambar. [ 30 ]

Berikut beberapa hal yang perlu diperhatikan:  Pemisahan ruang untuk semua nilai  Tidak ada kolom atau baris header  Abaikan pesan atau peringatan, seperti error_bad_lines = False dan warm_bad_lines= False  Gunakan kolom 0, 1 ,dan 2 yang memiliki ID gambar, ID atribut, dan nilai sekarang atau tidak sekarang Anda tidak perlu khawatir tentang atribut dan waktu yang dibutuhkan untuk memilihnya. Di sini, di bagian atas kumpulan data itu: ID gambar nomor 1 tidak memiliki atribut 1, 2, 3, atau 4, tetapi memiliki atribut 5. Bentuknya akan memberi tahu kita berapa banyak baris dan kolom yang kita miliki: Ini memiliki 3,7 juta baris dan tiga kolom. Ini bukan formula sebenarnya yang Anda inginkan. Anda ingin atribut menjadi kolom, bukan baris. [ 31 ]

Oleh karena itu, kita harus menggunakan pivot, seperti Excel memiliki metode pivot: 1. Putar pada ID gambar dan buat satu baris untuk setiap ID gambar. Hanya akan ada satu baris untuk gambar nomor satu. 2. Ubah atribut menjadi kolom yang berbeda, dan nilainya akan menjadi satu atau dua. Kita sekarang dapat melihat bahwa setiap ID gambar hanya satu baris dan setiap atribut adalah kolomnya sendiri, dan kita memiliki satu dan dua: Mari kita masukkan data ini ke dalam random forests. Pada contoh sebelumnya, kita memiliki 312 kolom dan 312 atribut, yang pada akhirnya adalah sekitar 12.000 gambar atau 12.000 contoh burung yang berbeda: [ 32 ]

Sekarang, kita perlu memuat jawabannya, seperti apakah itu burung dan spesies apa. Karena ini adalah file label kelas gambar, pemisahnya adalah spasi. Tidak ada baris header dan dua kolom adalah imgid dan label. Kita akan menggunakan set_index(‘imgid’) untuk mendapatkan hasil yang sama yang dihasilkan oleh imgatt2.head(), di mana baris diidentifikasi oleh ID gambar: Berikut tampilannya: [ 33 ]

Kolom imgid memiliki 1,2 3,4, dan 5, Semua diberi label sebagai . Mereka semua elang laut di bagian atas file. Seperti yang terlihat, ada sekitar 12.000 baris, yang sempurna: Ini adalah nomor yang sama dengan data atribut. Kita akan menggunakan join. Dalam join, kita akan menggunakan indeks pada image ID untuk menggabungkan dua data frame. Secara efektif, apa yang akan kita dapatkan adalah labelnya menempel pada kolom terakhir. Kita sekarang akan mengocok dan kemudian memisahkan atribut. Dengan kata lain, kita ingin melepaskan label dari label. Jadi, inilah atributnya, dengan 312 kolom pertama dan kolom terakhir sebagai label: [ 34 ]

Setelah mengacak, kita memiliki baris pertama sebagai gambar 527, baris kedua sebagai gambar 1532, dan seterusnya. Atribut dalam data label sesuai. Pada baris pertama ada gambar 527, yang merupakan angka 10. Anda tidak akan tahu burung apa itu, tetapi jenisnya, dan ini adalah atributnya. Tapi akhirnya dalam bentuk yang tepat. Kita perlu melakukan split tes pelatihan. Ada 12.000 baris, jadi mari kita ambil 8.000 pertama dan sebut mereka pelatihan, dan sisanya adalah pengujian (4.000). Kita akan mendapatkan jawaban menggunakan RandomForestClassifier : Fitur maksimal menunjukkan jumlah kolom berbeda yang dapat dilihat setiap pohon. Misalnya, jika kita mengatakan sesuatu seperti, lihat dua atribut, itu mungkin tidak cukup untuk benar-benar mengetahui burung mana itu. Beberapa burung unik, jadi Anda mungkin membutuhkan lebih banyak atribut. Kemudian jika kita mengatakan max_feature=50 dan jumlah estimator menunjukkan jumlah pohon yang dibuat. Kecocokan benar-benar membangunnya. [ 35 ]

Mari kita prediksi beberapa kasus. Mari kita gunakan atribut dari lima baris pertama dari set pelatihan, yang akan memprediksi spesies 10, 28, 156, 10, dan 43. Setelah pengujian, kita mendapatkan akurasi 44%: Bahkan akurasi 44% bukanlah hasil terbaik. Ada 200 spesies, jadi memiliki akurasi 0,5% jauh lebih baik daripada menebak secara acak. Membuat matriks konfusi untuk data Mari kita buat matriks konfusi untuk melihat burung mana yang dibingungkan oleh kumpulan data. Itu Fungsi confusion_matrix dari scikit-learn akan menghasilkan matriks, tetapi matriksnya cukup besar: [ 36 ]

Dua ratus kali dua ratus tidak mudah dipahami dalam bentuk angka seperti ini. Berikut beberapa kode dari dokumentasi scikit-learn yang memungkinkan kita untuk memplot matriks dan warna dalam matriks: [ 37 ]

Kita akan membutuhkan nama sebenarnya dari burung pada matriks sehingga kita mengetahui spesies yang saling membingungkan. Jadi, mari kita muat file kelas: Plot the matrix. This is the confusion matrix for this dataset: [ 38 ]

The output looks like the following: Outputnya tidak terbaca karena ada 200 baris dan kolom. Tetapi jika kita membukanya secara terpisah dan kemudian mulai memperbesar, pada sumbu y Anda akan melihat burung yang sebenarnya, dan pada sumbu x, Anda akan melihat burung yang diprediksi: [ 39 ]

Misalnya, tenggorokan kuning yang umum adalah yang benar. Melihat grafik berikut, kita dapat melihat bahwa tenggorokan kuning biasa dikacaukan dengan elang laut berkaki hitam. Saat kita memperkecil, kita akan melihat kekeliruan: [ 40 ]

Ini seperti kotak kekeliruan yang ada di antara tenggorokan kuning biasa dan elang laut berkaki hitam. Beberapa fitur adalah tern, seperti tern Arktik, tern hitam, tern Kaspia, dan tern umum. Terns tampaknya mudah dibingungkan karena terlihat mirip. Set ini juga sedikit membingungkan: [ 41 ]

Ini adalah set tentang burung pipit. Matriks kekeliruan memberi tahu kita hal- hal yang kita harapkan, yaitu, burung-burung yang terlihat mirip dibingungkan satu sama lain. Ada sedikit kekeliruan, seperti yang terlihat pada tangkapan layar sebelumnya. Untuk sebagian besar, Anda tidak ingin membingungkan elang laut dengan tenggorokan kuning yang umum karena ini berarti bahwa kumpulan data tidak tahu apa yang dilakukannya. [ 42 ]

Karena nama burung diurutkan, kuadrat kekeliruannya lebih kecil. Mari kita bandingkan dengan decision trees sederhana: Di sini, akurasinya adalah 27%, yang lebih rendah dari akurasi 44% sebelumnya. Oleh karena itu, decision trees lebih buruk. Jika kita menggunakan Support Vector Machine (SVM), yang merupakan pendekatan jaringan saraf, outputnya adalah 29%: Random forests masih lebih baik. Mari kita lakukan validasi silang untuk memastikan bahwa kita membagi tes pelatihan dengan cara yang berbeda. Outputnya masih 44% untuk random forests, 25% untuk decision trees kita , dan 27% untuk SVM, seperti yang ditunjukkan pada tangkapan layar berikut: [ 43 ]

Hasil terbaik tercermin melalui random forests karena kita memiliki beberapa opsi dan pertanyaan dengan random forests. Misalnya, berapa banyak pertanyaan berbeda yang dapat diajukan setiap pohon? Berapa banyak atribut yang dilihatnya, dan ada berapa pohon? Nah, ada banyak parameter yang harus dilihat, jadi mari kita buat loop dan coba semuanya: [ 44 ]

These are all the accuracies, but it would be better to visualize this in a graph, as shown here: [ 45 ]