Big Data Analytics - Panduan Cepat
Volume data yang harus ditangani seseorang telah meledak ke tingkat yang tak terbayangkan dalam dekade terakhir, dan pada saat yang sama, harga penyimpanan data telah berkurang secara sistematis. Perusahaan swasta dan lembaga penelitian menangkap terabyte data tentang interaksi pengguna, bisnis, media sosial, dan juga sensor dari perangkat seperti ponsel dan mobil. Tantangan era ini adalah memahami lautan data ini. Ini dimanabig data analytics mulai terlihat.
Big Data Analytics sebagian besar melibatkan pengumpulan data dari berbagai sumber, membuatnya tersedia untuk dikonsumsi oleh analis dan akhirnya memberikan produk data yang berguna bagi bisnis organisasi.
Proses mengonversi data mentah tidak terstruktur dalam jumlah besar, diambil dari berbagai sumber menjadi produk data yang berguna untuk organisasi, membentuk inti dari Big Data Analytics.
Siklus Hidup Data Mining Tradisional
Untuk memberikan kerangka kerja untuk mengatur pekerjaan yang dibutuhkan oleh organisasi dan memberikan wawasan yang jelas dari Big Data, ada baiknya untuk menganggapnya sebagai siklus dengan tahapan yang berbeda. Ini sama sekali tidak linier, artinya semua tahapan terkait satu sama lain. Siklus ini memiliki kemiripan yang dangkal dengan siklus data mining yang lebih tradisional seperti yang dijelaskan dalamCRISP methodology.
Metodologi CRISP-DM
Itu CRISP-DM methodologyyang merupakan singkatan dari Proses Standar Lintas Industri untuk Penambangan Data, adalah siklus yang menggambarkan pendekatan yang umum digunakan yang digunakan para ahli penambangan data untuk mengatasi masalah dalam penambangan data BI tradisional. Itu masih digunakan dalam tim penambangan data BI tradisional.
Perhatikan ilustrasi berikut. Ini menunjukkan tahapan utama dari siklus seperti yang dijelaskan oleh metodologi CRISP-DM dan bagaimana mereka saling terkait.
CRISP-DM dibentuk pada tahun 1996 dan tahun berikutnya, itu dimulai sebagai proyek Uni Eropa di bawah inisiatif pendanaan ESPRIT. Proyek ini dipimpin oleh lima perusahaan: SPSS, Teradata, Daimler AG, NCR Corporation, dan OHRA (sebuah perusahaan asuransi). Proyek tersebut akhirnya dimasukkan ke dalam SPSS. Metodologi ini sangat berorientasi pada detail bagaimana proyek data mining harus ditentukan.
Sekarang mari kita belajar lebih banyak tentang setiap tahapan yang terlibat dalam siklus hidup CRISP-DM -
Business Understanding- Fase awal ini berfokus pada pemahaman tujuan dan persyaratan proyek dari perspektif bisnis, dan kemudian mengubah pengetahuan ini menjadi definisi masalah data mining. Sebuah rencana awal dirancang untuk mencapai tujuan. Sebuah model keputusan, terutama yang dibangun dengan menggunakan Decision Model dan standar Notation dapat digunakan.
Data Understanding - Tahap pemahaman data dimulai dengan pengumpulan data awal dan dilanjutkan dengan aktivitas untuk membiasakan diri dengan data, mengidentifikasi masalah kualitas data, menemukan wawasan pertama ke dalam data, atau mendeteksi subset yang menarik untuk membentuk hipotesis untuk informasi tersembunyi.
Data Preparation- Tahap persiapan data mencakup semua kegiatan untuk menyusun dataset akhir (data yang akan dimasukkan ke dalam alat pemodelan) dari data mentah awal. Tugas persiapan data mungkin dilakukan beberapa kali, dan tidak dalam urutan yang ditentukan. Tugas termasuk pemilihan tabel, catatan, dan atribut serta transformasi dan pembersihan data untuk alat pemodelan.
Modeling- Dalam fase ini, berbagai teknik pemodelan dipilih dan diterapkan dan parameternya dikalibrasi ke nilai optimal. Biasanya, ada beberapa teknik untuk jenis masalah data mining yang sama. Beberapa teknik memiliki persyaratan khusus berupa datanya. Oleh karena itu, sering kali diperlukan untuk mundur ke tahap persiapan data.
Evaluation- Pada tahap proyek ini, Anda telah membangun model (atau model) yang tampaknya memiliki kualitas tinggi, dari perspektif analisis data. Sebelum melanjutkan ke penerapan akhir model, penting untuk mengevaluasi model secara menyeluruh dan meninjau langkah-langkah yang dilakukan untuk membangun model, untuk memastikan model tersebut mencapai tujuan bisnis dengan benar.
Tujuan utamanya adalah untuk menentukan apakah ada beberapa masalah bisnis penting yang belum dipertimbangkan secara memadai. Di akhir fase ini, keputusan tentang penggunaan hasil data mining harus dibuat.
Deployment- Penciptaan model umumnya bukanlah akhir dari proyek. Meskipun tujuan model adalah untuk meningkatkan pengetahuan tentang data, pengetahuan yang diperoleh perlu diatur dan disajikan dengan cara yang berguna bagi pelanggan.
Bergantung pada persyaratannya, fase penerapan dapat sesederhana membuat laporan atau serumit menerapkan penilaian data yang dapat diulang (misalnya alokasi segmen) atau proses penggalian data.
Dalam banyak kasus, ini akan menjadi pelanggan, bukan analis data, yang akan melakukan langkah-langkah penerapan. Bahkan jika analis menerapkan model, penting bagi pelanggan untuk memahami tindakan yang perlu dilakukan untuk benar-benar menggunakan model yang dibuat.
Metodologi SEMMA
SEMMA adalah metodologi lain yang dikembangkan oleh SAS untuk pemodelan data mining. Itu singkatanScukup, Explore, MOdify, Model, dan Asses. Berikut adalah deskripsi singkat tahapannya -
Sample- Prosesnya dimulai dengan pengambilan sampel data, misalnya memilih dataset untuk pemodelan. Kumpulan data harus cukup besar untuk memuat informasi yang cukup untuk diambil, namun cukup kecil untuk digunakan secara efisien. Fase ini juga berhubungan dengan partisi data.
Explore - Fase ini mencakup pemahaman data dengan menemukan hubungan yang diantisipasi dan tidak diantisipasi antara variabel, dan juga kelainan, dengan bantuan visualisasi data.
Modify - Fase Modifikasi berisi metode untuk memilih, membuat dan mengubah variabel dalam persiapan untuk pemodelan data.
Model - Pada fase Model, fokusnya adalah menerapkan berbagai teknik pemodelan (data mining) pada variabel yang disiapkan untuk membuat model yang mungkin memberikan hasil yang diinginkan.
Assess - Evaluasi hasil pemodelan menunjukkan keandalan dan kegunaan model yang dibuat.
Perbedaan utama antara CRISM-DM dan SEMMA adalah SEMMA berfokus pada aspek pemodelan, sedangkan CRISP-DM lebih mementingkan tahapan siklus sebelum pemodelan seperti memahami masalah bisnis yang akan dipecahkan, memahami dan memproses data yang akan diproses. digunakan sebagai masukan, misalnya, algoritme pembelajaran mesin.
Siklus Hidup Big Data
Dalam konteks data besar saat ini, pendekatan sebelumnya tidak lengkap atau kurang optimal. Misalnya, metodologi SEMMA mengabaikan sepenuhnya pengumpulan data dan pemrosesan awal dari sumber data yang berbeda. Tahapan ini biasanya merupakan sebagian besar pekerjaan dalam proyek data besar yang sukses.
Siklus analitik data besar dapat dijelaskan dengan tahap berikut -
- Definisi Masalah Bisnis
- Research
- Penilaian Sumber Daya Manusia
- Akuisisi Data
- Data Munging
- Penyimpanan data
- Analisis Data Eksplorasi
- Persiapan Data untuk Pemodelan dan Penilaian
- Modeling
- Implementation
Di bagian ini, kami akan menyoroti masing-masing tahapan siklus hidup data besar ini.
Definisi Masalah Bisnis
Ini adalah poin yang umum dalam BI tradisional dan siklus hidup analitik data besar. Biasanya, ini adalah tahap non-sepele dari proyek data besar untuk menentukan masalah dan mengevaluasi dengan benar seberapa besar potensi keuntungan yang mungkin didapatnya bagi suatu organisasi. Tampaknya jelas untuk menyebutkan hal ini, tetapi harus dievaluasi berapa keuntungan dan biaya yang diharapkan dari proyek tersebut.
Penelitian
Analisis apa yang telah dilakukan perusahaan lain dalam situasi yang sama. Ini melibatkan mencari solusi yang masuk akal untuk perusahaan Anda, meskipun itu melibatkan penyesuaian solusi lain dengan sumber daya dan persyaratan yang dimiliki perusahaan Anda. Dalam tahap ini, metodologi untuk tahap-tahap selanjutnya harus ditentukan.
Penilaian Sumber Daya Manusia
Setelah masalah ditentukan, masuk akal untuk melanjutkan analisis jika staf saat ini dapat menyelesaikan proyek dengan sukses. Tim BI tradisional mungkin tidak dapat memberikan solusi yang optimal untuk semua tahapan, jadi ini harus dipertimbangkan sebelum memulai proyek jika ada kebutuhan untuk melakukan outsourcing sebagian dari proyek atau mempekerjakan lebih banyak orang.
Akuisisi Data
Bagian ini adalah kunci dalam siklus hidup data besar; ini menentukan jenis profil yang diperlukan untuk mengirimkan produk data yang dihasilkan. Pengumpulan data adalah langkah proses yang tidak sepele; biasanya melibatkan pengumpulan data tidak terstruktur dari sumber yang berbeda. Sebagai contoh, ini bisa melibatkan penulisan crawler untuk mengambil ulasan dari situs web. Ini melibatkan berurusan dengan teks, mungkin dalam bahasa berbeda yang biasanya membutuhkan banyak waktu untuk diselesaikan.
Data Munging
Setelah data diambil, misalnya, dari web, perlu disimpan dalam format yang mudah digunakan. Untuk melanjutkan dengan contoh tinjauan, anggaplah data diambil dari situs berbeda yang masing-masing memiliki tampilan data yang berbeda.
Misalkan satu sumber data memberikan ulasan dalam hal peringkat dalam bintang, oleh karena itu dimungkinkan untuk membaca ini sebagai pemetaan untuk variabel respons y ∈ {1, 2, 3, 4, 5}. Sumber data lain memberikan review dengan menggunakan sistem dua panah, satu untuk up voting dan satunya lagi untuk down voting. Ini akan menyiratkan variabel respons dari formuliry ∈ {positive, negative}.
Untuk menggabungkan kedua sumber data, keputusan harus dibuat agar kedua representasi tanggapan ini setara. Hal ini dapat melibatkan konversi representasi respons sumber data pertama ke bentuk kedua, dengan mempertimbangkan satu bintang sebagai negatif dan lima bintang sebagai positif. Proses ini seringkali membutuhkan alokasi waktu yang besar agar dapat disampaikan dengan kualitas yang baik.
Penyimpanan data
Setelah data diproses, terkadang perlu disimpan dalam database. Teknologi data besar menawarkan banyak alternatif terkait hal ini. Alternatif yang paling umum adalah menggunakan Sistem File Hadoop untuk penyimpanan yang menyediakan pengguna SQL versi terbatas, yang dikenal sebagai Bahasa Kueri HIVE. Hal ini memungkinkan sebagian besar tugas analitik dilakukan dengan cara yang sama seperti yang akan dilakukan di gudang data BI tradisional, dari perspektif pengguna. Opsi penyimpanan lain yang perlu dipertimbangkan adalah MongoDB, Redis, dan SPARK.
Tahapan siklus ini terkait dengan pengetahuan sumber daya manusia dalam hal kemampuan mereka untuk mengimplementasikan arsitektur yang berbeda. Versi modifikasi dari gudang data tradisional masih digunakan dalam aplikasi skala besar. Misalnya, teradata dan IBM menawarkan database SQL yang dapat menangani terabyte data; solusi open source seperti postgreSQL dan MySQL masih digunakan untuk aplikasi skala besar.
Meskipun ada perbedaan dalam cara kerja penyimpanan yang berbeda di latar belakang, dari sisi klien, sebagian besar solusi menyediakan API SQL. Karenanya, memiliki pemahaman yang baik tentang SQL masih merupakan keterampilan utama yang dimiliki untuk analitik data besar.
Tahap apriori ini tampaknya menjadi topik yang paling penting, dalam praktiknya, ini tidak benar. Ini bahkan bukan tahap yang penting. Sangat mungkin untuk mengimplementasikan solusi big data yang akan bekerja dengan data real-time, jadi dalam hal ini, kita hanya perlu mengumpulkan data untuk mengembangkan model dan kemudian mengimplementasikannya secara real time. Jadi tidak perlu menyimpan data secara formal sama sekali.
Analisis Data Eksplorasi
Setelah data dibersihkan dan disimpan sedemikian rupa sehingga wawasan dapat diambil darinya, fase eksplorasi data wajib dilakukan. Tahapan ini bertujuan untuk memahami data yang biasanya dilakukan dengan teknik statistik dan juga memplot data. Ini adalah tahap yang baik untuk mengevaluasi apakah definisi masalah masuk akal atau layak.
Persiapan Data untuk Pemodelan dan Penilaian
Tahap ini melibatkan pembentukan kembali data dibersihkan yang diambil sebelumnya dan menggunakan prapemrosesan statistik untuk imputasi nilai yang hilang, deteksi outlier, normalisasi, ekstraksi fitur, dan pemilihan fitur.
Pemodelan
Tahap sebelumnya harus sudah menghasilkan beberapa dataset untuk pelatihan dan pengujian, misalnya model prediktif. Tahap ini melibatkan mencoba model yang berbeda dan berharap untuk memecahkan masalah bisnis yang dihadapi. Dalam praktiknya, biasanya model tersebut diharapkan akan memberikan beberapa wawasan tentang bisnis. Akhirnya, model terbaik atau kombinasi model dipilih mengevaluasi kinerjanya pada set data yang tertinggal.
Penerapan
Pada tahap ini produk data yang dikembangkan diimplementasikan dalam pipeline data perusahaan. Ini melibatkan pengaturan skema validasi saat produk data bekerja, untuk melacak kinerjanya. Misalnya, dalam kasus penerapan model prediktif, tahap ini akan melibatkan penerapan model ke data baru dan begitu respons tersedia, evaluasi model.
Dalam hal metodologi, analitik data besar berbeda secara signifikan dari pendekatan statistik tradisional desain eksperimental. Analytics dimulai dengan data. Biasanya kami memodelkan data dengan cara menjelaskan tanggapan. Tujuan dari pendekatan ini adalah untuk memprediksi perilaku respons atau memahami bagaimana variabel input berhubungan dengan respons. Biasanya dalam desain eksperimental statistik, percobaan dikembangkan dan data diambil sebagai hasilnya. Hal ini memungkinkan untuk menghasilkan data dengan cara yang dapat digunakan oleh model statistik, di mana asumsi tertentu berlaku seperti independensi, normalitas, dan pengacakan.
Dalam analitik data besar, kami disajikan dengan data. Kami tidak dapat merancang eksperimen yang memenuhi model statistik favorit kami. Dalam aplikasi analitik skala besar, sejumlah besar pekerjaan (biasanya 80% dari upaya) dibutuhkan hanya untuk membersihkan data, sehingga dapat digunakan oleh model pembelajaran mesin.
Kami tidak memiliki metodologi unik untuk diikuti dalam aplikasi skala besar yang nyata. Biasanya setelah masalah bisnis ditentukan, diperlukan tahapan penelitian untuk merancang metodologi yang akan digunakan. Namun pedoman umum relevan untuk disebutkan dan berlaku untuk hampir semua masalah.
Salah satu tugas terpenting dalam analitik data besar adalah statistical modeling, yang berarti masalah klasifikasi atau regresi yang diawasi dan tidak diawasi. Setelah data dibersihkan dan diproses sebelumnya, tersedia untuk pemodelan, perhatian harus diberikan dalam mengevaluasi model yang berbeda dengan metrik kerugian yang wajar dan kemudian setelah model diterapkan, evaluasi dan hasil lebih lanjut harus dilaporkan. Kesalahan umum dalam pemodelan prediktif adalah dengan hanya mengimplementasikan model dan tidak pernah mengukur kinerjanya.
Seperti yang disebutkan dalam siklus hidup data besar, produk data yang dihasilkan dari pengembangan produk data besar dalam banyak kasus adalah sebagai berikut -
Machine learning implementation - Ini bisa menjadi algoritma klasifikasi, model regresi atau model segmentasi.
Recommender system - Tujuannya adalah untuk mengembangkan sistem yang merekomendasikan pilihan berdasarkan perilaku pengguna. Netflix adalah contoh karakteristik dari produk data ini, dimana berdasarkan rating pengguna, direkomendasikan film lain.
Dashboard- Bisnis biasanya membutuhkan alat untuk memvisualisasikan data agregat. Dasbor adalah mekanisme grafis untuk membuat data ini dapat diakses.
Ad-Hoc analysis - Biasanya area bisnis memiliki pertanyaan, hipotesis atau mitos yang dapat dijawab dengan melakukan analisis ad-hoc dengan data.
Dalam organisasi besar, untuk berhasil mengembangkan proyek data besar, diperlukan manajemen yang mendukung proyek tersebut. Ini biasanya melibatkan menemukan cara untuk menunjukkan keuntungan bisnis dari proyek tersebut. Kami tidak memiliki solusi unik untuk masalah menemukan sponsor untuk sebuah proyek, tetapi beberapa pedoman diberikan di bawah ini -
Periksa siapa dan di mana sponsor proyek lain yang serupa dengan yang Anda minati.
Memiliki kontak pribadi di posisi manajemen kunci membantu, sehingga kontak apa pun dapat dipicu jika proyeknya menjanjikan.
Siapa yang akan mendapat manfaat dari proyek Anda? Siapa yang akan menjadi klien Anda setelah proyek berjalan sesuai rencana?
Kembangkan proposal yang sederhana, jelas, dan menarik dan bagikan dengan pemain kunci di organisasi Anda.
Cara terbaik untuk mencari sponsor untuk sebuah proyek adalah dengan memahami masalahnya dan apa yang akan menjadi produk data yang dihasilkan setelah diimplementasikan. Pemahaman ini akan memberikan keunggulan dalam meyakinkan manajemen akan pentingnya proyek big data.
Seorang analis data memiliki profil berorientasi pelaporan, memiliki pengalaman dalam mengekstraksi dan menganalisis data dari gudang data tradisional menggunakan SQL. Tugas mereka biasanya berada di sisi penyimpanan data atau dalam melaporkan hasil bisnis umum. Penyimpanan data sama sekali tidak sederhana, hanya saja berbeda dengan apa yang dilakukan oleh data scientist.
Banyak organisasi berjuang keras untuk menemukan data scientist yang kompeten di pasar. Namun, merupakan ide yang bagus untuk memilih calon analis data dan mengajari mereka keterampilan yang relevan untuk menjadi ilmuwan data. Ini sama sekali bukan tugas yang sepele dan biasanya akan melibatkan orang yang mengambil gelar master dalam bidang kuantitatif, tetapi ini jelas merupakan pilihan yang layak. Keterampilan dasar yang harus dimiliki oleh seorang analis data yang kompeten tercantum di bawah ini -
- Pemahaman bisnis
- Pemrograman SQL
- Desain dan implementasi laporan
- Pengembangan dasbor
Peran seorang data scientist biasanya dikaitkan dengan tugas-tugas seperti pemodelan prediktif, pengembangan algoritme segmentasi, sistem pemberi rekomendasi, kerangka kerja pengujian A / B, dan sering kali bekerja dengan data mentah tidak terstruktur.
Sifat pekerjaan mereka menuntut pemahaman yang mendalam tentang matematika, statistik terapan, dan pemrograman. Ada beberapa keterampilan yang umum antara seorang analis data dan seorang ilmuwan data, misalnya, kemampuan untuk melakukan kueri database. Keduanya menganalisis data, tetapi keputusan seorang data scientist dapat memberikan dampak yang lebih besar dalam suatu organisasi.
Berikut ini seperangkat keterampilan yang biasanya perlu dimiliki oleh data scientist -
- Pemrograman dalam paket statistik seperti: R, Python, SAS, SPSS, atau Julia
- Mampu membersihkan, mengekstrak, dan mengeksplorasi data dari berbagai sumber
- Penelitian, desain, dan implementasi model statistik
- Pengetahuan statistik, matematika, dan ilmu komputer yang mendalam
Dalam analitik data besar, orang biasanya mengacaukan peran ilmuwan data dengan peran arsitek data. Pada kenyataannya, perbedaannya cukup sederhana. Seorang arsitek data mendefinisikan alat dan arsitektur tempat data akan disimpan, sedangkan data scientist menggunakan arsitektur ini. Tentu saja, seorang data scientist harus dapat menyiapkan alat baru jika diperlukan untuk proyek ad-hoc, tetapi definisi dan desain infrastruktur tidak boleh menjadi bagian dari tugasnya.
Melalui tutorial ini, kami akan mengembangkan sebuah proyek. Setiap bab berikutnya dalam tutorial ini berhubungan dengan bagian dari proyek yang lebih besar di bagian proyek mini. Ini dianggap sebagai bagian tutorial terapan yang akan memberikan eksposur ke masalah dunia nyata. Dalam hal ini, kami akan mulai dengan definisi masalah proyek.
Deskripsi Proyek
Tujuan dari proyek ini adalah untuk mengembangkan model pembelajaran mesin untuk memprediksi gaji per jam orang menggunakan teks curriculum vitae (CV) mereka sebagai input.
Menggunakan kerangka kerja yang didefinisikan di atas, mudah untuk mendefinisikan masalahnya. Kita dapat mendefinisikan X = {x 1 , x 2 ,…, x n } sebagai CV pengguna, di mana setiap fitur dapat, dengan cara yang paling sederhana, berapa kali kata ini muncul. Maka tanggapannya benar-benar dihargai, kami mencoba memprediksi gaji per jam individu dalam dolar.
Kedua pertimbangan ini cukup untuk menyimpulkan bahwa masalah yang disajikan dapat diselesaikan dengan algoritma regresi terbimbing.
Definisi masalah
Problem Definitionmungkin salah satu tahapan yang paling kompleks dan sangat diabaikan dalam pipeline analitik data besar. Untuk menentukan masalah yang akan dipecahkan oleh produk data, pengalaman adalah wajib. Sebagian besar calon ilmuwan data memiliki sedikit atau tidak ada pengalaman dalam tahap ini.
Sebagian besar masalah big data dapat dikategorikan dengan cara berikut -
- Klasifikasi terbimbing
- Regresi yang diawasi
- Pembelajaran tanpa pengawasan
- Belajar menentukan peringkat
Mari kita pelajari lebih lanjut tentang keempat konsep ini.
Klasifikasi Terbimbing
Diberikan matriks fitur X = {x 1 , x 2 , ..., x n } kami mengembangkan model M untuk memprediksi kelas yang berbeda didefinisikan sebagai y = {c 1 , c 2 , ..., c n } . Misalnya: Dengan adanya data transaksional pelanggan di perusahaan asuransi, dimungkinkan untuk mengembangkan model yang akan memprediksi apakah klien akan churn atau tidak. Yang terakhir adalah masalah klasifikasi biner, di mana terdapat dua kelas atau variabel target: churn dan bukan churn.
Masalah lain melibatkan prediksi lebih dari satu kelas, kita mungkin tertarik untuk melakukan pengenalan digit, oleh karena itu vektor respon akan didefinisikan sebagai: y = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} , model a-state-of-the-art akan menjadi jaringan saraf konvolusional dan matriks fitur akan didefinisikan sebagai piksel gambar.
Regresi yang Diawasi
Dalam hal ini, definisi masalah agak mirip dengan contoh sebelumnya; perbedaannya bergantung pada respons. Dalam soal regresi, respon y ∈ ℜ, ini berarti respon bernilai nyata. Misalnya, kami dapat mengembangkan model untuk memprediksi gaji per jam individu berdasarkan korpus CV mereka.
Pembelajaran Tanpa Pengawasan
Manajemen seringkali haus akan wawasan baru. Model segmentasi dapat memberikan wawasan ini agar departemen pemasaran dapat mengembangkan produk untuk segmen yang berbeda. Pendekatan yang baik untuk mengembangkan model segmentasi, daripada memikirkan algoritma, adalah dengan memilih fitur yang relevan dengan segmentasi yang diinginkan.
Misalnya, di perusahaan telekomunikasi, menarik untuk menyegmentasikan klien berdasarkan penggunaan ponsel mereka. Ini akan melibatkan pengabaian fitur yang tidak ada hubungannya dengan tujuan segmentasi dan hanya menyertakan yang terkait. Dalam hal ini, ini akan memilih fitur seperti jumlah SMS yang digunakan dalam sebulan, jumlah menit masuk dan keluar, dll.
Belajar Peringkat
Masalah ini dapat dianggap sebagai masalah regresi, tetapi memiliki karakteristik tertentu dan memerlukan perlakuan tersendiri. Masalahnya melibatkan kumpulan dokumen yang kami cari untuk menemukan urutan paling relevan yang diberikan kueri. Untuk mengembangkan algoritme pembelajaran tersupervisi, perlu diberi label seberapa relevan suatu pengurutan, jika diberi kueri.
Perlu diperhatikan bahwa untuk mengembangkan algoritme pembelajaran terbimbing, diperlukan pemberian label pada data pelatihan. Artinya, untuk melatih model yang akan, misalnya, mengenali angka dari sebuah gambar, kita perlu memberi label pada sejumlah besar contoh secara manual. Ada layanan web yang dapat mempercepat proses ini dan biasanya digunakan untuk tugas ini seperti amazon mechanical turk. Terbukti bahwa algoritme pembelajaran meningkatkan kinerjanya saat dilengkapi dengan lebih banyak data, jadi pelabelan sejumlah contoh yang layak secara praktis wajib dalam pembelajaran yang diawasi.
Pengumpulan data memainkan peran terpenting dalam siklus Big Data. Internet menyediakan sumber data yang hampir tidak terbatas untuk berbagai topik. Pentingnya area ini bergantung pada jenis bisnis, tetapi industri tradisional dapat memperoleh beragam sumber data eksternal dan menggabungkannya dengan data transaksionalnya.
Misalnya, anggaplah kita ingin membangun sistem yang merekomendasikan restoran. Langkah pertama adalah mengumpulkan data, dalam hal ini, ulasan restoran dari berbagai situs web dan menyimpannya dalam database. Karena kami tertarik pada teks mentah, dan akan menggunakannya untuk analitik, tidaklah relevan di mana data untuk mengembangkan model akan disimpan. Ini mungkin terdengar kontradiktif dengan teknologi utama big data, tetapi untuk mengimplementasikan aplikasi big data, kita hanya perlu membuatnya berfungsi secara real time.
Proyek Mini Twitter
Setelah masalah ditentukan, tahap berikutnya adalah mengumpulkan data. Ide miniproyek berikut adalah mengerjakan pengumpulan data dari web dan menyusunnya untuk digunakan dalam model pembelajaran mesin. Kami akan mengumpulkan beberapa tweet dari twitter rest API menggunakan bahasa pemrograman R.
Pertama-tama buat akun twitter, lalu ikuti petunjuk di twitteRsketsa paket untuk membuat akun pengembang twitter. Ini adalah ringkasan dari instruksi tersebut -
Pergi ke https://twitter.com/apps/new dan masuk.
Setelah mengisi info dasar, buka tab "Pengaturan" dan pilih "Baca, Tulis, dan Akses pesan langsung".
Pastikan untuk mengklik tombol simpan setelah melakukan ini
Di tab "Detail", catat kunci konsumen dan rahasia konsumen Anda
Dalam sesi R Anda, Anda akan menggunakan kunci API dan nilai rahasia API
Terakhir jalankan skrip berikut. Ini akan menginstaltwitteR paket dari repositori di github.
install.packages(c("devtools", "rjson", "bit64", "httr"))
# Make sure to restart your R session at this point
library(devtools)
install_github("geoffjentry/twitteR")Kami tertarik untuk mendapatkan data yang menyertakan string "big mac" dan mencari tahu topik mana yang menonjol tentang hal ini. Untuk melakukan ini, langkah pertama adalah mengumpulkan data dari twitter. Di bawah ini adalah skrip R kami untuk mengumpulkan data yang dibutuhkan dari twitter. Kode ini juga tersedia di file bda / part1 / collect_data / collect_data_twitter.R.
rm(list = ls(all = TRUE)); gc() # Clears the global environment
library(twitteR)
Sys.setlocale(category = "LC_ALL", locale = "C")
### Replace the xxx’s with the values you got from the previous instructions
# consumer_key = "xxxxxxxxxxxxxxxxxxxx"
# consumer_secret = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
# access_token = "xxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
# access_token_secret= "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
# Connect to twitter rest API
setup_twitter_oauth(consumer_key, consumer_secret, access_token, access_token_secret)
# Get tweets related to big mac
tweets <- searchTwitter(’big mac’, n = 200, lang = ’en’)
df <- twListToDF(tweets)
# Take a look at the data
head(df)
# Check which device is most used
sources <- sapply(tweets, function(x) x$getStatusSource())
sources <- gsub("</a>", "", sources)
sources <- strsplit(sources, ">")
sources <- sapply(sources, function(x) ifelse(length(x) > 1, x[2], x[1]))
source_table = table(sources)
source_table = source_table[source_table > 1]
freq = source_table[order(source_table, decreasing = T)]
as.data.frame(freq)
# Frequency
# Twitter for iPhone 71
# Twitter for Android 29
# Twitter Web Client 25
# recognia 20Setelah data terkumpul, biasanya kita memiliki sumber data yang beragam dengan karakteristik berbeda. Langkah paling cepat adalah membuat sumber data ini homogen dan terus mengembangkan produk data kami. Namun, itu tergantung pada jenis datanya. Kita harus bertanya pada diri kita sendiri apakah praktis untuk menghomogenkan data.
Mungkin sumber datanya benar-benar berbeda, dan kehilangan informasi akan menjadi besar jika sumbernya dihomogenisasi. Dalam hal ini, kita dapat memikirkan alternatif. Dapatkah satu sumber data membantu saya membuat model regresi dan yang lainnya menjadi model klasifikasi? Apakah mungkin bekerja dengan heterogenitas untuk keuntungan kita daripada hanya kehilangan informasi? Mengambil keputusan inilah yang membuat analitik menarik dan menantang.
Dalam hal tinjauan, dimungkinkan untuk memiliki bahasa untuk setiap sumber data. Sekali lagi, kami memiliki dua pilihan -
Homogenization- Ini melibatkan penerjemahan bahasa yang berbeda ke bahasa di mana kami memiliki lebih banyak data. Kualitas layanan terjemahan dapat diterima, tetapi jika kami ingin menerjemahkan data dalam jumlah besar dengan API, biayanya akan signifikan. Ada perangkat lunak yang tersedia untuk tugas ini, tetapi itu juga akan mahal.
Heterogenization- Apakah mungkin mengembangkan solusi untuk setiap bahasa? Karena mudah untuk mendeteksi bahasa korpus, kami dapat mengembangkan pemberi rekomendasi untuk setiap bahasa. Ini akan melibatkan lebih banyak pekerjaan dalam hal menyesuaikan setiap pemberi rekomendasi sesuai dengan jumlah bahasa yang tersedia tetapi jelas merupakan opsi yang layak jika kami memiliki beberapa bahasa yang tersedia.
Proyek Mini Twitter
Dalam kasus ini, pertama-tama kita perlu membersihkan data tidak terstruktur dan kemudian mengubahnya menjadi matriks data untuk menerapkan pemodelan topik padanya. Secara umum, saat mendapatkan data dari twitter, ada beberapa karakter yang kurang kami minati, setidaknya pada tahap pertama proses pembersihan data.
Misalnya, setelah mendapatkan tweet kita mendapatkan karakter aneh ini: "<ed> <U + 00A0> <U + 00BD> <ed> <U + 00B8> <U + 008B>". Ini mungkin emotikon, jadi untuk membersihkan data, kami hanya akan menghapusnya menggunakan skrip berikut. Kode ini juga tersedia di file bda / part1 / collect_data / cleaning_data.R.
rm(list = ls(all = TRUE)); gc() # Clears the global environment
source('collect_data_twitter.R')
# Some tweets
head(df$text)
[1] "I’m not a big fan of turkey but baked Mac &
cheese <ed><U+00A0><U+00BD><ed><U+00B8><U+008B>"
[2] "@Jayoh30 Like no special sauce on a big mac. HOW"
### We are interested in the text - Let’s clean it!
# We first convert the encoding of the text from latin1 to ASCII
df$text <- sapply(df$text,function(row) iconv(row, "latin1", "ASCII", sub = ""))
# Create a function to clean tweets
clean.text <- function(tx) {
tx <- gsub("htt.{1,20}", " ", tx, ignore.case = TRUE)
tx = gsub("[^#[:^punct:]]|@|RT", " ", tx, perl = TRUE, ignore.case = TRUE)
tx = gsub("[[:digit:]]", " ", tx, ignore.case = TRUE)
tx = gsub(" {1,}", " ", tx, ignore.case = TRUE)
tx = gsub("^\\s+|\\s+$", " ", tx, ignore.case = TRUE) return(tx) } clean_tweets <- lapply(df$text, clean.text)
# Cleaned tweets
head(clean_tweets)
[1] " WeNeedFeminlsm MAC s new make up line features men woc and big girls "
[1] " TravelsPhoto What Happens To Your Body One Hour After A Big Mac "Langkah terakhir dari proyek mini pembersihan data adalah membersihkan teks yang dapat kita ubah menjadi matriks dan menerapkan algoritme. Dari teks yang disimpan diclean_tweets vektor kita dapat dengan mudah mengubahnya menjadi sekumpulan matriks kata-kata dan menerapkan algoritma pembelajaran tanpa pengawasan.
Pelaporan sangat penting dalam analitik data besar. Setiap organisasi pasti memiliki penyediaan informasi yang teratur untuk mendukung proses pengambilan keputusannya. Tugas ini biasanya ditangani oleh analis data dengan pengalaman SQL dan ETL (ekstrak, transfer, dan muat).
Tim yang bertanggung jawab atas tugas ini memiliki tanggung jawab untuk menyebarkan informasi yang dihasilkan di departemen analitik data besar ke berbagai area organisasi.
Contoh berikut menunjukkan apa arti ringkasan data. Arahkan ke folder tersebutbda/part1/summarize_data dan di dalam folder tersebut, buka summarize_data.Rprojfile dengan mengklik dua kali. Kemudian, bukasummarize_data.R skrip dan lihat kodenya, dan ikuti penjelasan yang disajikan.
# Install the following packages by running the following code in R.
pkgs = c('data.table', 'ggplot2', 'nycflights13', 'reshape2')
install.packages(pkgs)Itu ggplot2paket sangat bagus untuk visualisasi data. Itudata.table paket adalah pilihan yang bagus untuk melakukan peringkasan yang cepat dan hemat memori R. Tolok ukur baru-baru ini menunjukkan bahwa itu lebih cepat daripadapandas, pustaka python yang digunakan untuk tugas serupa.
Lihatlah datanya menggunakan kode berikut. Kode ini juga tersedia dibda/part1/summarize_data/summarize_data.Rproj mengajukan.
library(nycflights13)
library(ggplot2)
library(data.table)
library(reshape2)
# Convert the flights data.frame to a data.table object and call it DT
DT <- as.data.table(flights)
# The data has 336776 rows and 16 columns
dim(DT)
# Take a look at the first rows
head(DT)
# year month day dep_time dep_delay arr_time arr_delay carrier
# 1: 2013 1 1 517 2 830 11 UA
# 2: 2013 1 1 533 4 850 20 UA
# 3: 2013 1 1 542 2 923 33 AA
# 4: 2013 1 1 544 -1 1004 -18 B6
# 5: 2013 1 1 554 -6 812 -25 DL
# 6: 2013 1 1 554 -4 740 12 UA
# tailnum flight origin dest air_time distance hour minute
# 1: N14228 1545 EWR IAH 227 1400 5 17
# 2: N24211 1714 LGA IAH 227 1416 5 33
# 3: N619AA 1141 JFK MIA 160 1089 5 42
# 4: N804JB 725 JFK BQN 183 1576 5 44
# 5: N668DN 461 LGA ATL 116 762 5 54
# 6: N39463 1696 EWR ORD 150 719 5 54Kode berikut memiliki contoh peringkasan data.
### Data Summarization
# Compute the mean arrival delay
DT[, list(mean_arrival_delay = mean(arr_delay, na.rm = TRUE))]
# mean_arrival_delay
# 1: 6.895377
# Now, we compute the same value but for each carrier
mean1 = DT[, list(mean_arrival_delay = mean(arr_delay, na.rm = TRUE)),
by = carrier]
print(mean1)
# carrier mean_arrival_delay
# 1: UA 3.5580111
# 2: AA 0.3642909
# 3: B6 9.4579733
# 4: DL 1.6443409
# 5: EV 15.7964311
# 6: MQ 10.7747334
# 7: US 2.1295951
# 8: WN 9.6491199
# 9: VX 1.7644644
# 10: FL 20.1159055
# 11: AS -9.9308886
# 12: 9E 7.3796692
# 13: F9 21.9207048
# 14: HA -6.9152047
# 15: YV 15.5569853
# 16: OO 11.9310345
# Now let’s compute to means in the same line of code
mean2 = DT[, list(mean_departure_delay = mean(dep_delay, na.rm = TRUE),
mean_arrival_delay = mean(arr_delay, na.rm = TRUE)),
by = carrier]
print(mean2)
# carrier mean_departure_delay mean_arrival_delay
# 1: UA 12.106073 3.5580111
# 2: AA 8.586016 0.3642909
# 3: B6 13.022522 9.4579733
# 4: DL 9.264505 1.6443409
# 5: EV 19.955390 15.7964311
# 6: MQ 10.552041 10.7747334
# 7: US 3.782418 2.1295951
# 8: WN 17.711744 9.6491199
# 9: VX 12.869421 1.7644644
# 10: FL 18.726075 20.1159055
# 11: AS 5.804775 -9.9308886
# 12: 9E 16.725769 7.3796692
# 13: F9 20.215543 21.9207048
# 14: HA 4.900585 -6.9152047
# 15: YV 18.996330 15.5569853
# 16: OO 12.586207 11.9310345
### Create a new variable called gain
# this is the difference between arrival delay and departure delay
DT[, gain:= arr_delay - dep_delay]
# Compute the median gain per carrier
median_gain = DT[, median(gain, na.rm = TRUE), by = carrier]
print(median_gain)Exploratory data analysisadalah konsep yang dikembangkan oleh John Tuckey (1977) yang terdiri dari perspektif baru statistik. Ide Tuckey adalah bahwa dalam statistik tradisional, data tidak dieksplorasi secara grafis, hanya digunakan untuk menguji hipotesis. Upaya pertama untuk mengembangkan alat dilakukan di Stanford, proyek itu disebut prim9 . Alat ini mampu memvisualisasikan data dalam sembilan dimensi, sehingga mampu memberikan perspektif multivariasi dari data tersebut.
Dalam beberapa hari terakhir, analisis data eksplorasi adalah suatu keharusan dan telah dimasukkan dalam siklus hidup analitik data besar. Kemampuan untuk menemukan wawasan dan mampu mengkomunikasikannya secara efektif dalam suatu organisasi didorong oleh kemampuan EDA yang kuat.
Berdasarkan ide Tuckey, Bell Labs mengembangkan S programming languageuntuk menyediakan antarmuka interaktif untuk melakukan statistik. Ide S adalah untuk menyediakan kemampuan grafis yang luas dengan bahasa yang mudah digunakan. Di dunia saat ini, dalam konteks Big Data,R yang didasarkan pada S bahasa pemrograman adalah perangkat lunak paling populer untuk analitik.
Program berikut mendemonstrasikan penggunaan analisis data eksplorasi.
Berikut adalah contoh analisis data eksplorasi. Kode ini juga tersedia dipart1/eda/exploratory_data_analysis.R mengajukan.
library(nycflights13)
library(ggplot2)
library(data.table)
library(reshape2)
# Using the code from the previous section
# This computes the mean arrival and departure delays by carrier.
DT <- as.data.table(flights)
mean2 = DT[, list(mean_departure_delay = mean(dep_delay, na.rm = TRUE),
mean_arrival_delay = mean(arr_delay, na.rm = TRUE)),
by = carrier]
# In order to plot data in R usign ggplot, it is normally needed to reshape the data
# We want to have the data in long format for plotting with ggplot
dt = melt(mean2, id.vars = ’carrier’)
# Take a look at the first rows
print(head(dt))
# Take a look at the help for ?geom_point and geom_line to find similar examples
# Here we take the carrier code as the x axis
# the value from the dt data.table goes in the y axis
# The variable column represents the color
p = ggplot(dt, aes(x = carrier, y = value, color = variable, group = variable)) +
geom_point() + # Plots points
geom_line() + # Plots lines
theme_bw() + # Uses a white background
labs(list(title = 'Mean arrival and departure delay by carrier',
x = 'Carrier', y = 'Mean delay'))
print(p)
# Save the plot to disk
ggsave('mean_delay_by_carrier.png', p,
width = 10.4, height = 5.07)Kode tersebut harus menghasilkan gambar seperti berikut -
Untuk memahami data, sering kali berguna untuk memvisualisasikannya. Biasanya dalam aplikasi Big Data, minat bergantung pada menemukan wawasan daripada hanya membuat plot yang indah. Berikut ini adalah contoh pendekatan berbeda untuk memahami data menggunakan plot.
Untuk mulai menganalisis data penerbangan, kita bisa mulai dengan memeriksa apakah ada korelasi antara variabel numerik. Kode ini juga tersedia dibda/part1/data_visualization/data_visualization.R mengajukan.
# Install the package corrplot by running
install.packages('corrplot')
# then load the library
library(corrplot)
# Load the following libraries
library(nycflights13)
library(ggplot2)
library(data.table)
library(reshape2)
# We will continue working with the flights data
DT <- as.data.table(flights)
head(DT) # take a look
# We select the numeric variables after inspecting the first rows.
numeric_variables = c('dep_time', 'dep_delay',
'arr_time', 'arr_delay', 'air_time', 'distance')
# Select numeric variables from the DT data.table
dt_num = DT[, numeric_variables, with = FALSE]
# Compute the correlation matrix of dt_num
cor_mat = cor(dt_num, use = "complete.obs")
print(cor_mat)
### Here is the correlation matrix
# dep_time dep_delay arr_time arr_delay air_time distance
# dep_time 1.00000000 0.25961272 0.66250900 0.23230573 -0.01461948 -0.01413373
# dep_delay 0.25961272 1.00000000 0.02942101 0.91480276 -0.02240508 -0.02168090
# arr_time 0.66250900 0.02942101 1.00000000 0.02448214 0.05429603 0.04718917
# arr_delay 0.23230573 0.91480276 0.02448214 1.00000000 -0.03529709 -0.06186776
# air_time -0.01461948 -0.02240508 0.05429603 -0.03529709 1.00000000 0.99064965
# distance -0.01413373 -0.02168090 0.04718917 -0.06186776 0.99064965 1.00000000
# We can display it visually to get a better understanding of the data
corrplot.mixed(cor_mat, lower = "circle", upper = "ellipse")
# save it to disk
png('corrplot.png')
print(corrplot.mixed(cor_mat, lower = "circle", upper = "ellipse"))
dev.off()Kode ini menghasilkan visualisasi matriks korelasi berikut -
Kita dapat melihat di plot bahwa ada korelasi yang kuat antara beberapa variabel dalam dataset. Misalnya, keterlambatan kedatangan dan keterlambatan keberangkatan tampaknya sangat berkorelasi. Kita dapat melihat ini karena elips menunjukkan hubungan yang hampir garis antara kedua variabel, namun tidak mudah untuk menemukan penyebab dari hasil ini.
Kita tidak dapat mengatakan bahwa karena dua variabel berkorelasi, yang satu berpengaruh pada yang lain. Juga kami menemukan di plot korelasi yang kuat antara waktu udara dan jarak, yang cukup masuk akal untuk diharapkan karena dengan jarak yang lebih jauh, waktu penerbangan akan bertambah.
Kami juga dapat melakukan analisis data univariat. Cara sederhana dan efektif untuk memvisualisasikan distribusi adalahbox-plots. Kode berikut menunjukkan cara membuat plot kotak dan bagan teralis menggunakan pustaka ggplot2. Kode ini juga tersedia dibda/part1/data_visualization/boxplots.R mengajukan.
source('data_visualization.R')
### Analyzing Distributions using box-plots
# The following shows the distance as a function of the carrier
p = ggplot(DT, aes(x = carrier, y = distance, fill = carrier)) + # Define the carrier
in the x axis and distance in the y axis
geom_box-plot() + # Use the box-plot geom
theme_bw() + # Leave a white background - More in line with tufte's
principles than the default
guides(fill = FALSE) + # Remove legend
labs(list(title = 'Distance as a function of carrier', # Add labels
x = 'Carrier', y = 'Distance'))
p
# Save to disk
png(‘boxplot_carrier.png’)
print(p)
dev.off()
# Let's add now another variable, the month of each flight
# We will be using facet_wrap for this
p = ggplot(DT, aes(carrier, distance, fill = carrier)) +
geom_box-plot() +
theme_bw() +
guides(fill = FALSE) +
facet_wrap(~month) + # This creates the trellis plot with the by month variable
labs(list(title = 'Distance as a function of carrier by month',
x = 'Carrier', y = 'Distance'))
p
# The plot shows there aren't clear differences between distance in different months
# Save to disk
png('boxplot_carrier_by_month.png')
print(p)
dev.off()Bagian ini dikhususkan untuk memperkenalkan pengguna pada bahasa pemrograman R. R dapat diunduh dari situs web cran . Untuk pengguna Windows, menginstal rtools dan rstudio IDE akan berguna .
Konsep umum dibalik R berfungsi sebagai antarmuka ke perangkat lunak lain yang dikembangkan dalam bahasa terkompilasi seperti C, C ++, dan Fortran dan untuk memberikan alat interaktif kepada pengguna untuk menganalisis data.
Arahkan ke folder file zip buku bda/part2/R_introduction dan buka R_introduction.Rprojmengajukan. Ini akan membuka sesi RStudio. Kemudian buka file 01_vectors.R. Jalankan skrip baris demi baris dan ikuti komentar di kode. Pilihan lain yang berguna untuk belajar adalah dengan mengetikkan kode, ini akan membantu Anda terbiasa dengan sintaks R. Di R komentar ditulis dengan simbol #.
Untuk menampilkan hasil menjalankan kode R di buku, setelah kode dievaluasi, hasil R kembali diberi komentar. Dengan cara ini, Anda dapat menyalin dan menempel kode di buku dan mencoba langsung bagian-bagiannya di R.
# Create a vector of numbers
numbers = c(1, 2, 3, 4, 5)
print(numbers)
# [1] 1 2 3 4 5
# Create a vector of letters
ltrs = c('a', 'b', 'c', 'd', 'e')
# [1] "a" "b" "c" "d" "e"
# Concatenate both
mixed_vec = c(numbers, ltrs)
print(mixed_vec)
# [1] "1" "2" "3" "4" "5" "a" "b" "c" "d" "e"Mari kita analisis apa yang terjadi di kode sebelumnya. Kita dapat melihat bahwa dimungkinkan untuk membuat vektor dengan angka dan huruf. Kami tidak perlu memberi tahu R tipe data apa yang kami inginkan sebelumnya. Akhirnya, kami dapat membuat vektor dengan angka dan huruf. Vektor mixed_vec telah memaksa angka menjadi karakter, kita dapat melihatnya dengan memvisualisasikan bagaimana nilai dicetak di dalam tanda kutip.
Kode berikut menunjukkan tipe data dari berbagai vektor yang dikembalikan oleh kelas fungsi. Biasanya menggunakan fungsi kelas untuk "menginterogasi" sebuah objek, menanyakan kelasnya.
### Evaluate the data types using class
### One dimensional objects
# Integer vector
num = 1:10
class(num)
# [1] "integer"
# Numeric vector, it has a float, 10.5
num = c(1:10, 10.5)
class(num)
# [1] "numeric"
# Character vector
ltrs = letters[1:10]
class(ltrs)
# [1] "character"
# Factor vector
fac = as.factor(ltrs)
class(fac)
# [1] "factor"R juga mendukung objek dua dimensi. Pada kode berikut, terdapat contoh dari dua struktur data terpopuler yang digunakan di R: matrix dan data.frame.
# Matrix
M = matrix(1:12, ncol = 4)
# [,1] [,2] [,3] [,4]
# [1,] 1 4 7 10
# [2,] 2 5 8 11
# [3,] 3 6 9 12
lM = matrix(letters[1:12], ncol = 4)
# [,1] [,2] [,3] [,4]
# [1,] "a" "d" "g" "j"
# [2,] "b" "e" "h" "k"
# [3,] "c" "f" "i" "l"
# Coerces the numbers to character
# cbind concatenates two matrices (or vectors) in one matrix
cbind(M, lM)
# [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
# [1,] "1" "4" "7" "10" "a" "d" "g" "j"
# [2,] "2" "5" "8" "11" "b" "e" "h" "k"
# [3,] "3" "6" "9" "12" "c" "f" "i" "l"
class(M)
# [1] "matrix"
class(lM)
# [1] "matrix"
# data.frame
# One of the main objects of R, handles different data types in the same object.
# It is possible to have numeric, character and factor vectors in the same data.frame
df = data.frame(n = 1:5, l = letters[1:5])
df
# n l
# 1 1 a
# 2 2 b
# 3 3 c
# 4 4 d
# 5 5 eSeperti yang ditunjukkan pada contoh sebelumnya, dimungkinkan untuk menggunakan tipe data yang berbeda dalam objek yang sama. Secara umum, ini adalah bagaimana data disajikan dalam database, API bagian dari data adalah teks atau vektor karakter dan numerik lainnya. Tugas analis adalah menentukan tipe data statistik mana yang akan ditetapkan dan kemudian menggunakan tipe data R yang benar untuknya. Dalam statistik kami biasanya menganggap variabel adalah dari jenis berikut -
- Numeric
- Nominal atau kategoris
- Ordinal
Di R, vektor dapat berupa kelas berikut -
- Numerik - Integer
- Factor
- Faktor yang Dipesan
R menyediakan tipe data untuk setiap tipe statistik variabel. Faktor terurut jarang digunakan, tetapi dapat dibuat oleh faktor fungsi, atau dipesan.
Bagian berikut membahas konsep pengindeksan. Ini adalah operasi yang cukup umum, dan berhubungan dengan masalah pemilihan bagian dari suatu objek dan membuat transformasi padanya.
# Let's create a data.frame
df = data.frame(numbers = 1:26, letters)
head(df)
# numbers letters
# 1 1 a
# 2 2 b
# 3 3 c
# 4 4 d
# 5 5 e
# 6 6 f
# str gives the structure of a data.frame, it’s a good summary to inspect an object
str(df)
# 'data.frame': 26 obs. of 2 variables:
# $ numbers: int 1 2 3 4 5 6 7 8 9 10 ... # $ letters: Factor w/ 26 levels "a","b","c","d",..: 1 2 3 4 5 6 7 8 9 10 ...
# The latter shows the letters character vector was coerced as a factor.
# This can be explained by the stringsAsFactors = TRUE argumnet in data.frame
# read ?data.frame for more information
class(df)
# [1] "data.frame"
### Indexing
# Get the first row
df[1, ]
# numbers letters
# 1 1 a
# Used for programming normally - returns the output as a list
df[1, , drop = TRUE]
# $numbers # [1] 1 # # $letters
# [1] a
# Levels: a b c d e f g h i j k l m n o p q r s t u v w x y z
# Get several rows of the data.frame
df[5:7, ]
# numbers letters
# 5 5 e
# 6 6 f
# 7 7 g
### Add one column that mixes the numeric column with the factor column
df$mixed = paste(df$numbers, df$letters, sep = ’’) str(df) # 'data.frame': 26 obs. of 3 variables: # $ numbers: int 1 2 3 4 5 6 7 8 9 10 ...
# $ letters: Factor w/ 26 levels "a","b","c","d",..: 1 2 3 4 5 6 7 8 9 10 ... # $ mixed : chr "1a" "2b" "3c" "4d" ...
### Get columns
# Get the first column
df[, 1]
# It returns a one dimensional vector with that column
# Get two columns
df2 = df[, 1:2]
head(df2)
# numbers letters
# 1 1 a
# 2 2 b
# 3 3 c
# 4 4 d
# 5 5 e
# 6 6 f
# Get the first and third columns
df3 = df[, c(1, 3)]
df3[1:3, ]
# numbers mixed
# 1 1 1a
# 2 2 2b
# 3 3 3c
### Index columns from their names
names(df)
# [1] "numbers" "letters" "mixed"
# This is the best practice in programming, as many times indeces change, but
variable names don’t
# We create a variable with the names we want to subset
keep_vars = c("numbers", "mixed")
df4 = df[, keep_vars]
head(df4)
# numbers mixed
# 1 1 1a
# 2 2 2b
# 3 3 3c
# 4 4 4d
# 5 5 5e
# 6 6 6f
### subset rows and columns
# Keep the first five rows
df5 = df[1:5, keep_vars]
df5
# numbers mixed
# 1 1 1a
# 2 2 2b
# 3 3 3c
# 4 4 4d
# 5 5 5e
# subset rows using a logical condition
df6 = df[df$numbers < 10, keep_vars]
df6
# numbers mixed
# 1 1 1a
# 2 2 2b
# 3 3 3c
# 4 4 4d
# 5 5 5e
# 6 6 6f
# 7 7 7g
# 8 8 8h
# 9 9 9iSQL adalah singkatan dari bahasa kueri terstruktur. Ini adalah salah satu bahasa yang paling banyak digunakan untuk mengekstraksi data dari database di gudang data tradisional dan teknologi data besar. Untuk mendemonstrasikan dasar-dasar SQL, kami akan mengerjakan contoh. Untuk fokus pada bahasanya sendiri, kita akan menggunakan SQL di dalam R. Dalam hal penulisan kode SQL, ini persis seperti yang dilakukan dalam database.
Inti dari SQL adalah tiga pernyataan: SELECT, FROM dan WHERE. Contoh berikut memanfaatkan kasus penggunaan SQL yang paling umum. Arahkan ke folder tersebutbda/part2/SQL_introduction dan buka SQL_introduction.Rprojmengajukan. Kemudian buka script 01_select.R. Untuk menulis kode SQL di R kita perlu menginstalsqldf paket seperti yang ditunjukkan pada kode berikut.
# Install the sqldf package
install.packages('sqldf')
# load the library
library('sqldf')
library(nycflights13)
# We will be working with the fligths dataset in order to introduce SQL
# Let’s take a look at the table
str(flights)
# Classes 'tbl_d', 'tbl' and 'data.frame': 336776 obs. of 16 variables:
# $ year : int 2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 ...
# $ month : int 1 1 1 1 1 1 1 1 1 1 ... # $ day : int 1 1 1 1 1 1 1 1 1 1 ...
# $ dep_time : int 517 533 542 544 554 554 555 557 557 558 ... # $ dep_delay: num 2 4 2 -1 -6 -4 -5 -3 -3 -2 ...
# $ arr_time : int 830 850 923 1004 812 740 913 709 838 753 ... # $ arr_delay: num 11 20 33 -18 -25 12 19 -14 -8 8 ...
# $ carrier : chr "UA" "UA" "AA" "B6" ... # $ tailnum : chr "N14228" "N24211" "N619AA" "N804JB" ...
# $ flight : int 1545 1714 1141 725 461 1696 507 5708 79 301 ... # $ origin : chr "EWR" "LGA" "JFK" "JFK" ...
# $ dest : chr "IAH" "IAH" "MIA" "BQN" ... # $ air_time : num 227 227 160 183 116 150 158 53 140 138 ...
# $ distance : num 1400 1416 1089 1576 762 ... # $ hour : num 5 5 5 5 5 5 5 5 5 5 ...
# $ minute : num 17 33 42 44 54 54 55 57 57 58 ...Pernyataan select digunakan untuk mengambil kolom dari tabel dan melakukan perhitungan padanya. Pernyataan SELECT paling sederhana ditunjukkan diej1. Kami juga dapat membuat variabel baru seperti yang ditunjukkan padaej2.
### SELECT statement
ej1 = sqldf("
SELECT
dep_time
,dep_delay
,arr_time
,carrier
,tailnum
FROM
flights
")
head(ej1)
# dep_time dep_delay arr_time carrier tailnum
# 1 517 2 830 UA N14228
# 2 533 4 850 UA N24211
# 3 542 2 923 AA N619AA
# 4 544 -1 1004 B6 N804JB
# 5 554 -6 812 DL N668DN
# 6 554 -4 740 UA N39463
# In R we can use SQL with the sqldf function. It works exactly the same as in
a database
# The data.frame (in this case flights) represents the table we are querying
and goes in the FROM statement
# We can also compute new variables in the select statement using the syntax:
# old_variables as new_variable
ej2 = sqldf("
SELECT
arr_delay - dep_delay as gain,
carrier
FROM
flights
")
ej2[1:5, ]
# gain carrier
# 1 9 UA
# 2 16 UA
# 3 31 AA
# 4 -17 B6
# 5 -19 DLSalah satu fitur SQL yang paling umum digunakan adalah grup berdasarkan pernyataan. Ini memungkinkan untuk menghitung nilai numerik untuk berbagai grup variabel lain. Buka script 02_group_by.R.
### GROUP BY
# Computing the average
ej3 = sqldf("
SELECT
avg(arr_delay) as mean_arr_delay,
avg(dep_delay) as mean_dep_delay,
carrier
FROM
flights
GROUP BY
carrier
")
# mean_arr_delay mean_dep_delay carrier
# 1 7.3796692 16.725769 9E
# 2 0.3642909 8.586016 AA
# 3 -9.9308886 5.804775 AS
# 4 9.4579733 13.022522 B6
# 5 1.6443409 9.264505 DL
# 6 15.7964311 19.955390 EV
# 7 21.9207048 20.215543 F9
# 8 20.1159055 18.726075 FL
# 9 -6.9152047 4.900585 HA
# 10 10.7747334 10.552041 MQ
# 11 11.9310345 12.586207 OO
# 12 3.5580111 12.106073 UA
# 13 2.1295951 3.782418 US
# 14 1.7644644 12.869421 VX
# 15 9.6491199 17.711744 WN
# 16 15.5569853 18.996330 YV
# Other aggregations
ej4 = sqldf("
SELECT
avg(arr_delay) as mean_arr_delay,
min(dep_delay) as min_dep_delay,
max(dep_delay) as max_dep_delay,
carrier
FROM
flights
GROUP BY
carrier
")
# We can compute the minimun, mean, and maximum values of a numeric value
ej4
# mean_arr_delay min_dep_delay max_dep_delay carrier
# 1 7.3796692 -24 747 9E
# 2 0.3642909 -24 1014 AA
# 3 -9.9308886 -21 225 AS
# 4 9.4579733 -43 502 B6
# 5 1.6443409 -33 960 DL
# 6 15.7964311 -32 548 EV
# 7 21.9207048 -27 853 F9
# 8 20.1159055 -22 602 FL
# 9 -6.9152047 -16 1301 HA
# 10 10.7747334 -26 1137 MQ
# 11 11.9310345 -14 154 OO
# 12 3.5580111 -20 483 UA
# 13 2.1295951 -19 500 US
# 14 1.7644644 -20 653 VX
# 15 9.6491199 -13 471 WN
# 16 15.5569853 -16 387 YV
### We could be also interested in knowing how many observations each carrier has
ej5 = sqldf("
SELECT
carrier, count(*) as count
FROM
flights
GROUP BY
carrier
")
ej5
# carrier count
# 1 9E 18460
# 2 AA 32729
# 3 AS 714
# 4 B6 54635
# 5 DL 48110
# 6 EV 54173
# 7 F9 685
# 8 FL 3260
# 9 HA 342
# 10 MQ 26397
# 11 OO 32
# 12 UA 58665
# 13 US 20536
# 14 VX 5162
# 15 WN 12275
# 16 YV 601Fitur SQL yang paling berguna adalah join. Gabungan berarti kita ingin menggabungkan tabel A dan tabel B dalam satu tabel menggunakan satu kolom agar sesuai dengan nilai kedua tabel. Ada berbagai jenis gabungan, secara praktis, untuk memulai ini akan menjadi yang paling berguna: gabungan dalam dan gabungan luar kiri.
# Let’s create two tables: A and B to demonstrate joins.
A = data.frame(c1 = 1:4, c2 = letters[1:4])
B = data.frame(c1 = c(2,4,5,6), c2 = letters[c(2:5)])
A
# c1 c2
# 1 a
# 2 b
# 3 c
# 4 d
B
# c1 c2
# 2 b
# 4 c
# 5 d
# 6 e
### INNER JOIN
# This means to match the observations of the column we would join the tables by.
inner = sqldf("
SELECT
A.c1, B.c2
FROM
A INNER JOIN B
ON A.c1 = B.c1
")
# Only the rows that match c1 in both A and B are returned
inner
# c1 c2
# 2 b
# 4 c
### LEFT OUTER JOIN
# the left outer join, sometimes just called left join will return the
# first all the values of the column used from the A table
left = sqldf("
SELECT
A.c1, B.c2
FROM
A LEFT OUTER JOIN B
ON A.c1 = B.c1
")
# Only the rows that match c1 in both A and B are returned
left
# c1 c2
# 1 <NA>
# 2 b
# 3 <NA>
# 4 cPendekatan pertama untuk menganalisis data adalah menganalisisnya secara visual. Tujuan melakukan ini biasanya menemukan hubungan antara variabel dan deskripsi univariat variabel. Kami dapat membagi strategi ini sebagai -
- Analisis univariat
- Analisis multivariasi
Metode Grafis Univariat
Univariateadalah istilah statistik. Dalam praktiknya, ini berarti kami ingin menganalisis variabel secara independen dari data lainnya. Plot yang memungkinkan untuk melakukan ini secara efisien adalah -
Kotak-Plot
Box-Plot biasanya digunakan untuk membandingkan distribusi. Ini adalah cara yang bagus untuk memeriksa secara visual jika ada perbedaan di antara distribusi. Kita bisa melihat apakah ada perbedaan antara harga berlian untuk potongan yang berbeda.
# We will be using the ggplot2 library for plotting
library(ggplot2)
data("diamonds")
# We will be using the diamonds dataset to analyze distributions of numeric variables
head(diamonds)
# carat cut color clarity depth table price x y z
# 1 0.23 Ideal E SI2 61.5 55 326 3.95 3.98 2.43
# 2 0.21 Premium E SI1 59.8 61 326 3.89 3.84 2.31
# 3 0.23 Good E VS1 56.9 65 327 4.05 4.07 2.31
# 4 0.29 Premium I VS2 62.4 58 334 4.20 4.23 2.63
# 5 0.31 Good J SI2 63.3 58 335 4.34 4.35 2.75
# 6 0.24 Very Good J VVS2 62.8 57 336 3.94 3.96 2.48
### Box-Plots
p = ggplot(diamonds, aes(x = cut, y = price, fill = cut)) +
geom_box-plot() +
theme_bw()
print(p)Dapat kita lihat di plot terdapat perbedaan distribusi harga berlian di berbagai jenis potongan.
Histogram
source('01_box_plots.R')
# We can plot histograms for each level of the cut factor variable using
facet_grid
p = ggplot(diamonds, aes(x = price, fill = cut)) +
geom_histogram() +
facet_grid(cut ~ .) +
theme_bw()
p
# the previous plot doesn’t allow to visuallize correctly the data because of
the differences in scale
# we can turn this off using the scales argument of facet_grid
p = ggplot(diamonds, aes(x = price, fill = cut)) +
geom_histogram() +
facet_grid(cut ~ ., scales = 'free') +
theme_bw()
p
png('02_histogram_diamonds_cut.png')
print(p)
dev.off()Output dari kode di atas adalah sebagai berikut -
Metode Grafis Multivariasi
Metode grafik multivariat dalam analisis data eksplorasi bertujuan untuk menemukan hubungan antar variabel yang berbeda. Ada dua cara untuk mencapai ini yang umum digunakan: memplot matriks korelasi variabel numerik atau hanya memplot data mentah sebagai matriks plot pencar.
Untuk mendemonstrasikan ini, kami akan menggunakan dataset diamonds. Untuk mengikuti kode, buka skripbda/part2/charts/03_multivariate_analysis.R.
library(ggplot2)
data(diamonds)
# Correlation matrix plots
keep_vars = c('carat', 'depth', 'price', 'table')
df = diamonds[, keep_vars]
# compute the correlation matrix
M_cor = cor(df)
# carat depth price table
# carat 1.00000000 0.02822431 0.9215913 0.1816175
# depth 0.02822431 1.00000000 -0.0106474 -0.2957785
# price 0.92159130 -0.01064740 1.0000000 0.1271339
# table 0.18161755 -0.29577852 0.1271339 1.0000000
# plots
heat-map(M_cor)Kode akan menghasilkan keluaran berikut -
Ini adalah ringkasan, yang memberi tahu kita bahwa ada korelasi yang kuat antara harga dan tanda sisipan, dan tidak banyak di antara variabel lainnya.
Matriks korelasi dapat berguna jika kita memiliki banyak variabel yang dalam hal ini memplot data mentah tidak praktis. Seperti yang disebutkan, dimungkinkan untuk menunjukkan data mentah juga -
library(GGally)
ggpairs(df)Kita bisa lihat di plot bahwa hasil yang ditampilkan di heat-map dikonfirmasi, ada korelasi 0,922 antara harga dan variabel karat.
Hal ini dimungkinkan untuk memvisualisasikan hubungan ini dalam scatterplot harga-karat yang terletak di indeks (3, 1) dari matriks scatterplot.
Ada berbagai alat yang memungkinkan ilmuwan data menganalisis data secara efektif. Biasanya aspek teknik analisis data berfokus pada database, data scientist fokus pada alat yang dapat mengimplementasikan produk data. Bagian berikut membahas keuntungan dari alat yang berbeda dengan fokus pada paket statistik yang paling sering digunakan oleh ilmuwan dalam praktik.
Bahasa Pemrograman R.
R adalah bahasa pemrograman open source dengan fokus pada analisis statistik. Ini kompetitif dengan alat komersial seperti SAS, SPSS dalam hal kemampuan statistik. Ini dianggap sebagai antarmuka ke bahasa pemrograman lain seperti C, C ++ atau Fortran.
Keuntungan lain dari R adalah banyaknya pustaka open source yang tersedia. Di CRAN ada lebih dari 6000 paket yang bisa diunduh secara gratis dan diGithub Ada berbagai macam paket R yang tersedia.
Dalam hal kinerja, R lambat untuk operasi intensif, mengingat banyaknya pustaka yang tersedia, bagian kode yang lambat ditulis dalam bahasa yang dikompilasi. Tetapi jika Anda berniat untuk melakukan operasi yang memerlukan penulisan mendalam untuk loop, maka R tidak akan menjadi alternatif terbaik Anda. Untuk tujuan analisis data, ada perpustakaan yang bagus sepertidata.table, glmnet, ranger, xgboost, ggplot2, caret yang memungkinkan untuk menggunakan R sebagai antarmuka untuk bahasa pemrograman yang lebih cepat.
Python untuk analisis data
Python adalah bahasa pemrograman tujuan umum dan berisi sejumlah besar pustaka yang dikhususkan untuk analisis data seperti pandas, scikit-learn, theano, numpy dan scipy.
Sebagian besar dari apa yang tersedia di R juga dapat dilakukan dengan Python tetapi kami menemukan bahwa R lebih sederhana untuk digunakan. Jika Anda bekerja dengan kumpulan data besar, biasanya Python adalah pilihan yang lebih baik daripada R. Python dapat digunakan dengan cukup efektif untuk membersihkan dan memproses data baris demi baris. Ini dimungkinkan dari R tetapi tidak seefisien Python untuk tugas skrip.
Untuk pembelajaran mesin, scikit-learnadalah lingkungan yang bagus yang menyediakan sejumlah besar algoritme yang dapat menangani kumpulan data berukuran sedang tanpa masalah. Dibandingkan dengan pustaka setara R (tanda sisipan),scikit-learn memiliki API yang lebih bersih dan lebih konsisten.
Julia
Julia adalah bahasa pemrograman dinamis tingkat tinggi dan berkinerja tinggi untuk komputasi teknis. Sintaksnya sangat mirip dengan R atau Python, jadi jika Anda sudah bekerja dengan R atau Python, seharusnya cukup mudah untuk menulis kode yang sama di Julia. Bahasanya cukup baru dan telah berkembang secara signifikan dalam beberapa tahun terakhir, jadi ini jelas merupakan pilihan saat ini.
Kami akan merekomendasikan Julia untuk membuat prototipe algoritme yang intensif secara komputasi seperti jaringan saraf. Ini adalah alat yang hebat untuk penelitian. Dalam hal penerapan model dalam produksi mungkin Python memiliki alternatif yang lebih baik. Namun, ini menjadi lebih sedikit masalah karena ada layanan web yang melakukan rekayasa model implementasi di R, Python dan Julia.
SAS
SAS adalah bahasa komersial yang masih digunakan untuk intelijen bisnis. Ia memiliki bahasa dasar yang memungkinkan pengguna untuk memprogram berbagai macam aplikasi. Ini berisi beberapa produk komersial yang memberikan pengguna non-ahli kemampuan untuk menggunakan alat yang kompleks seperti perpustakaan jaringan saraf tanpa perlu pemrograman.
Di luar kelemahan yang jelas dari alat komersial, SAS tidak dapat diskalakan dengan baik pada kumpulan data yang besar. Bahkan dataset berukuran sedang akan mengalami masalah dengan SAS dan membuat server crash. Hanya jika Anda bekerja dengan kumpulan data kecil dan pengguna bukan ilmuwan data ahli, SAS dapat direkomendasikan. Untuk pengguna tingkat lanjut, R dan Python menyediakan lingkungan yang lebih produktif.
SPSS
SPSS, saat ini merupakan produk IBM untuk analisis statistik. Ini sebagian besar digunakan untuk menganalisis data survei dan bagi pengguna yang tidak dapat membuat program, ini adalah alternatif yang layak. Ini mungkin sesederhana untuk digunakan seperti SAS, tetapi dalam hal mengimplementasikan model, ini lebih sederhana karena menyediakan kode SQL untuk menilai model. Kode ini biasanya tidak efisien, tetapi ini adalah permulaan sedangkan SAS menjual produk yang menilai model untuk setiap database secara terpisah. Untuk data kecil dan tim yang belum berpengalaman, SPSS adalah pilihan yang sebaik SAS.
Namun perangkat lunaknya agak terbatas, dan pengguna berpengalaman akan lebih produktif menggunakan R atau Python.
Matlab, Oktaf
Ada alat lain yang tersedia seperti Matlab atau versi open source (Oktaf). Alat-alat ini banyak digunakan untuk penelitian. Dalam hal kapabilitas R atau Python dapat melakukan semua yang tersedia di Matlab atau Oktaf. Masuk akal untuk membeli lisensi produk jika Anda tertarik dengan dukungan yang mereka berikan.
Saat menganalisis data, dimungkinkan untuk memiliki pendekatan statistik. Alat dasar yang diperlukan untuk melakukan analisis dasar adalah -
- Analisis korelasi
- Analisis Varians
- Pengujian Hipotesis
Saat bekerja dengan kumpulan data besar, itu tidak melibatkan masalah karena metode ini tidak intensif secara komputasi dengan pengecualian Analisis Korelasi. Dalam hal ini, selalu memungkinkan untuk mengambil sampel dan hasilnya harus kuat.
Analisis korelasi
Analisis Korelasi berusaha untuk menemukan hubungan linier antara variabel numerik. Ini dapat berguna dalam situasi yang berbeda. Salah satu penggunaan yang umum adalah analisis data eksplorasi, di bagian 16.0.2 buku ini terdapat contoh dasar dari pendekatan ini. Pertama-tama, metrik korelasi yang digunakan dalam contoh yang disebutkan didasarkan padaPearson coefficient. Namun, ada metrik korelasi menarik lainnya yang tidak dipengaruhi oleh pencilan. Metrik ini disebut korelasi spearman.
Itu spearman correlation metrik lebih kuat terhadap keberadaan pencilan daripada metode Pearson dan memberikan perkiraan yang lebih baik dari hubungan linier antara variabel numerik ketika data tidak terdistribusi normal.
library(ggplot2)
# Select variables that are interesting to compare pearson and spearman
correlation methods.
x = diamonds[, c('x', 'y', 'z', 'price')]
# From the histograms we can expect differences in the correlations of both
metrics.
# In this case as the variables are clearly not normally distributed, the
spearman correlation
# is a better estimate of the linear relation among numeric variables.
par(mfrow = c(2,2))
colnm = names(x)
for(i in 1:4) {
hist(x[[i]], col = 'deepskyblue3', main = sprintf('Histogram of %s', colnm[i]))
}
par(mfrow = c(1,1))Dari histogram pada gambar berikut, kita dapat mengharapkan perbedaan korelasi kedua metrik tersebut. Dalam hal ini, karena variabel jelas tidak terdistribusi normal, korelasi spearman adalah perkiraan yang lebih baik dari hubungan linier antar variabel numerik.
Untuk menghitung korelasi di R, buka file bda/part2/statistical_methods/correlation/correlation.R yang memiliki bagian kode ini.
## Correlation Matrix - Pearson and spearman
cor_pearson <- cor(x, method = 'pearson')
cor_spearman <- cor(x, method = 'spearman')
### Pearson Correlation
print(cor_pearson)
# x y z price
# x 1.0000000 0.9747015 0.9707718 0.8844352
# y 0.9747015 1.0000000 0.9520057 0.8654209
# z 0.9707718 0.9520057 1.0000000 0.8612494
# price 0.8844352 0.8654209 0.8612494 1.0000000
### Spearman Correlation
print(cor_spearman)
# x y z price
# x 1.0000000 0.9978949 0.9873553 0.9631961
# y 0.9978949 1.0000000 0.9870675 0.9627188
# z 0.9873553 0.9870675 1.0000000 0.9572323
# price 0.9631961 0.9627188 0.9572323 1.0000000Uji Chi-squared
Uji chi-squared memungkinkan kita untuk menguji apakah dua variabel acak tidak bergantung. Artinya distribusi probabilitas masing-masing variabel tidak mempengaruhi variabel lainnya. Untuk mengevaluasi tes di R, pertama kita perlu membuat tabel kontingensi, dan kemudian meneruskan tabel kechisq.test R fungsi.
Sebagai contoh, mari kita periksa apakah ada hubungan antara variabel: cut dan color dari dataset diamonds. Tes ini secara resmi didefinisikan sebagai -
- H0: Potongan variabel dan berlian tidak tergantung
- H1: Potongan variabel dan berlian tidak independen
Kami akan mengasumsikan ada hubungan antara kedua variabel ini dengan namanya, tetapi pengujian dapat memberikan "aturan" objektif yang mengatakan seberapa signifikan hasil ini atau tidak.
Dalam potongan kode berikut, kami menemukan bahwa nilai-p pengujian adalah 2.2e-16, ini hampir nol dalam istilah praktis. Kemudian setelah menjalankan tes lakukan aMonte Carlo simulation, kami menemukan bahwa p-value adalah 0,0004998 yang masih cukup rendah dari ambang 0,05. Hasil ini berarti kami menolak hipotesis nol (H0), jadi kami percaya variabelcut dan color tidak independen.
library(ggplot2)
# Use the table function to compute the contingency table
tbl = table(diamonds$cut, diamonds$color)
tbl
# D E F G H I J
# Fair 163 224 312 314 303 175 119
# Good 662 933 909 871 702 522 307
# Very Good 1513 2400 2164 2299 1824 1204 678
# Premium 1603 2337 2331 2924 2360 1428 808
# Ideal 2834 3903 3826 4884 3115 2093 896
# In order to run the test we just use the chisq.test function.
chisq.test(tbl)
# Pearson’s Chi-squared test
# data: tbl
# X-squared = 310.32, df = 24, p-value < 2.2e-16
# It is also possible to compute the p-values using a monte-carlo simulation
# It's needed to add the simulate.p.value = TRUE flag and the amount of
simulations
chisq.test(tbl, simulate.p.value = TRUE, B = 2000)
# Pearson’s Chi-squared test with simulated p-value (based on 2000 replicates)
# data: tbl
# X-squared = 310.32, df = NA, p-value = 0.0004998Uji-t
Ide t-testadalah untuk mengevaluasi apakah ada perbedaan dalam distribusi variabel numerik # antara kelompok variabel nominal yang berbeda. Untuk mendemonstrasikan ini, saya akan memilih level level Adil dan Ideal dari potongan variabel faktor, kemudian kami akan membandingkan nilai variabel numerik di antara kedua kelompok tersebut.
data = diamonds[diamonds$cut %in% c('Fair', 'Ideal'), ]
data$cut = droplevels.factor(data$cut) # Drop levels that aren’t used from the
cut variable
df1 = data[, c('cut', 'price')]
# We can see the price means are different for each group
tapply(df1$price, df1$cut, mean)
# Fair Ideal
# 4358.758 3457.542Uji-t diimplementasikan di R dengan t.testfungsi. Antarmuka rumus ke t.test adalah cara termudah untuk menggunakannya, idenya adalah variabel numerik dijelaskan oleh variabel grup.
Sebagai contoh: t.test(numeric_variable ~ group_variable, data = data). Dalam contoh sebelumnya, filenumeric_variable adalah price dan group_variable adalah cut.
Dari perspektif statistik, kami menguji apakah ada perbedaan dalam distribusi variabel numerik di antara dua kelompok. Secara formal pengujian hipotesis dijelaskan dengan hipotesis nol (H0) dan hipotesis alternatif (H1).
H0: Tidak ada perbedaan dalam distribusi variabel harga antara kelompok Adil dan Ideal
H1 Terdapat perbedaan distribusi variabel harga antara kelompok Wajar dan Ideal
Berikut ini dapat diimplementasikan di R dengan kode berikut -
t.test(price ~ cut, data = data)
# Welch Two Sample t-test
#
# data: price by cut
# t = 9.7484, df = 1894.8, p-value < 2.2e-16
# alternative hypothesis: true difference in means is not equal to 0
# 95 percent confidence interval:
# 719.9065 1082.5251
# sample estimates:
# mean in group Fair mean in group Ideal
# 4358.758 3457.542
# Another way to validate the previous results is to just plot the
distributions using a box-plot
plot(price ~ cut, data = data, ylim = c(0,12000),
col = 'deepskyblue3')Kita dapat menganalisis hasil pengujian dengan memeriksa apakah nilai p lebih rendah dari 0,05. Jika demikian, kami menyimpan hipotesis alternatif. Ini berarti kami telah menemukan perbedaan harga di antara dua tingkat faktor potong. Berdasarkan nama level, kami mengharapkan hasil ini, tetapi kami tidak berharap bahwa harga rata-rata di grup Gagal akan lebih tinggi daripada di grup Ideal. Kita dapat melihat ini dengan membandingkan rata-rata setiap faktor.
Itu plotperintah menghasilkan grafik yang menunjukkan hubungan antara harga dan variabel potong. Ini adalah plot kotak; kami telah membahas plot ini di bagian 16.0.1 tetapi pada dasarnya menunjukkan distribusi variabel harga untuk dua tingkat pemotongan yang kami analisis.
Analisis Varians
Analysis of Variance (ANOVA) adalah model statistik yang digunakan untuk menganalisis perbedaan antar distribusi kelompok dengan membandingkan mean dan varians masing-masing kelompok, model yang dikembangkan oleh Ronald Fisher. ANOVA memberikan uji statistik apakah rata-rata beberapa kelompok sama atau tidak, dan oleh karena itu menggeneralisasi uji-t ke lebih dari dua kelompok.
ANOVA berguna untuk membandingkan tiga atau lebih kelompok untuk signifikansi statistik karena melakukan beberapa uji-t dua sampel akan menghasilkan peningkatan kemungkinan melakukan kesalahan tipe I statistik.
Dalam rangka memberikan penjelasan matematis, berikut ini diperlukan untuk memahami soal tes.
x ij = x + (x i - x) + (x ij - x)
Ini mengarah ke model berikut -
x ij = μ + α i + ∈ ij
di mana μ adalah mean utama dan α i adalah mean grup ke-i. Istilah kesalahan ∈ ij diasumsikan iid dari distribusi normal. Hipotesis nol dari pengujian ini adalah -
α 1 = α 2 =… = α k
Dalam hal menghitung statistik uji, kita perlu menghitung dua nilai -
- Jumlah kuadrat untuk perbedaan kelompok -
$$SSD_B = \sum_{i}^{k} \sum_{j}^{n}(\bar{x_{\bar{i}}} - \bar{x})^2$$
- Jumlah kotak dalam kelompok
$$SSD_W = \sum_{i}^{k} \sum_{j}^{n}(\bar{x_{\bar{ij}}} - \bar{x_{\bar{i}}})^2$$
dengan SSD B memiliki derajat kebebasan k − 1 dan SSD W memiliki derajat kebebasan N − k. Kemudian kita dapat menentukan perbedaan kuadrat rata-rata untuk setiap metrik.
MS B = SSD B / (k - 1)
MS w = SSD w / (N - k)
Akhirnya, statistik uji dalam ANOVA didefinisikan sebagai rasio dari dua kuantitas di atas
F = MS B / MS w
yang mengikuti distribusi F dengan k − 1 dan N − k derajat kebebasan. Jika hipotesis nol benar, F kemungkinan akan mendekati 1. Jika tidak, MSB kuadrat rata-rata antara grup kemungkinan besar, yang menghasilkan nilai F yang besar.
Pada dasarnya, ANOVA memeriksa dua sumber dari total varians dan melihat bagian mana yang lebih berkontribusi. Inilah mengapa disebut analisis varians meskipun tujuannya adalah untuk membandingkan rata-rata kelompok.
Dalam hal menghitung statistik, sebenarnya agak mudah dilakukan di R. Contoh berikut akan menunjukkan bagaimana hal itu dilakukan dan memplot hasilnya.
library(ggplot2)
# We will be using the mtcars dataset
head(mtcars)
# mpg cyl disp hp drat wt qsec vs am gear carb
# Mazda RX4 21.0 6 160 110 3.90 2.620 16.46 0 1 4 4
# Mazda RX4 Wag 21.0 6 160 110 3.90 2.875 17.02 0 1 4 4
# Datsun 710 22.8 4 108 93 3.85 2.320 18.61 1 1 4 1
# Hornet 4 Drive 21.4 6 258 110 3.08 3.215 19.44 1 0 3 1
# Hornet Sportabout 18.7 8 360 175 3.15 3.440 17.02 0 0 3 2
# Valiant 18.1 6 225 105 2.76 3.460 20.22 1 0 3 1
# Let's see if there are differences between the groups of cyl in the mpg variable.
data = mtcars[, c('mpg', 'cyl')]
fit = lm(mpg ~ cyl, data = mtcars)
anova(fit)
# Analysis of Variance Table
# Response: mpg
# Df Sum Sq Mean Sq F value Pr(>F)
# cyl 1 817.71 817.71 79.561 6.113e-10 ***
# Residuals 30 308.33 10.28
# Signif. codes: 0 *** 0.001 ** 0.01 * 0.05 .
# Plot the distribution
plot(mpg ~ as.factor(cyl), data = mtcars, col = 'deepskyblue3')Kode akan menghasilkan keluaran berikut -
Nilai p yang kita dapatkan dalam contoh secara signifikan lebih kecil dari 0,05, jadi R mengembalikan simbol '***' untuk menunjukkan ini. Ini berarti kami menolak hipotesis nol dan kami menemukan perbedaan antara rata-rata mpg di antara kelompok-kelompok yang berbedacyl variabel.
Pembelajaran mesin adalah subbidang ilmu komputer yang menangani tugas-tugas seperti pengenalan pola, visi komputer, pengenalan suara, analitik teks dan memiliki hubungan yang kuat dengan statistik dan pengoptimalan matematika. Aplikasi termasuk pengembangan mesin pencari, penyaringan spam, Optical Character Recognition (OCR) antara lain. Batasan antara data mining, pengenalan pola dan bidang pembelajaran statistik tidak jelas dan pada dasarnya semuanya mengacu pada masalah yang serupa.
Pembelajaran mesin dapat dibagi menjadi dua jenis tugas -
- Pembelajaran yang Diawasi
- Pembelajaran Tanpa Pengawasan
Pembelajaran yang Diawasi
Pembelajaran terbimbing mengacu pada jenis masalah di mana ada data input yang didefinisikan sebagai matriks X dan kami tertarik untuk memprediksi respons y . Dimana X = {x 1 , x 2 ,…, x n } memiliki n prediktor dan memiliki dua nilai y = {c 1 , c 2 } .
Contoh penerapannya adalah memprediksi kemungkinan pengguna web untuk mengklik iklan menggunakan fitur demografis sebagai prediktor. Ini sering disebut untuk memprediksi rasio klik-tayang (CTR). Kemudian y = {klik, tidak - klik} dan prediktornya bisa berupa alamat IP yang digunakan, hari ia memasuki situs, kota pengguna, negara di antara fitur-fitur lain yang mungkin tersedia.
Pembelajaran Tanpa Pengawasan
Pembelajaran tanpa pengawasan berkaitan dengan masalah menemukan kelompok yang serupa dalam satu sama lain tanpa harus belajar dari kelas. Ada beberapa pendekatan untuk tugas mempelajari pemetaan dari prediktor hingga menemukan kelompok yang memiliki contoh serupa di setiap kelompok dan berbeda satu sama lain.
Contoh penerapan unsupervised learning adalah segmentasi pelanggan. Misalnya, dalam industri telekomunikasi, tugas umum adalah menyegmentasikan pengguna menurut penggunaan yang mereka berikan ke telepon. Ini akan memungkinkan departemen pemasaran untuk menargetkan setiap kelompok dengan produk yang berbeda.
Naive Bayes adalah teknik probabilistik untuk membangun pengklasifikasi. Asumsi karakteristik pengklasifikasi naive Bayes adalah dengan mempertimbangkan bahwa nilai fitur tertentu tidak bergantung pada nilai fitur lainnya, dengan mempertimbangkan variabel kelas.
Terlepas dari asumsi yang terlalu disederhanakan yang disebutkan sebelumnya, pengklasifikasi Bayes yang naif memiliki hasil yang baik dalam situasi dunia nyata yang kompleks. Keuntungan dari bayes naif adalah bahwa ini hanya membutuhkan sedikit data pelatihan untuk memperkirakan parameter yang diperlukan untuk klasifikasi dan bahwa pengklasifikasi dapat dilatih secara bertahap.
Naive Bayes adalah model probabilitas bersyarat: diberi contoh masalah untuk diklasifikasikan, diwakili oleh vektor x= (x 1 ,…, x n ) mewakili beberapa fitur n (variabel independen), ini memberikan probabilitas contoh ini untuk setiap K kemungkinan hasil atau kelas.
$$p(C_k|x_1,....., x_n)$$
Masalah dengan rumusan di atas adalah bahwa jika jumlah fitur n besar atau jika fitur dapat mengambil sejumlah besar nilai, maka mendasarkan model seperti itu pada tabel probabilitas tidak layak. Oleh karena itu kami merumuskan kembali model tersebut untuk membuatnya lebih sederhana. Dengan menggunakan teorema Bayes, probabilitas bersyarat dapat didekomposisi sebagai -
$$p(C_k|x) = \frac{p(C_k)p(x|C_k)}{p(x)}$$
Ini berarti bahwa berdasarkan asumsi independensi di atas, distribusi bersyarat atas variabel kelas C adalah -
$$p(C_k|x_1,....., x_n)\: = \: \frac{1}{Z}p(C_k)\prod_{i = 1}^{n}p(x_i|C_k)$$
dimana bukti Z = p (x) adalah faktor penskalaan yang hanya bergantung pada x 1 ,…, x n , yang merupakan konstanta jika nilai variabel fitur diketahui. Satu aturan umum adalah memilih hipotesis yang paling mungkin; ini dikenal sebagai aturan keputusan a posteriori atau MAP maksimum. Pengklasifikasi yang sesuai, pengklasifikasi Bayes, adalah fungsi yang menetapkan label kelas$\hat{y} = C_k$ untuk beberapa k sebagai berikut -
$$\hat{y} = argmax\: p(C_k)\prod_{i = 1}^{n}p(x_i|C_k)$$
Menerapkan algoritme di R adalah proses yang mudah. Contoh berikut menunjukkan cara melatih pengklasifikasi Naive Bayes dan menggunakannya untuk prediksi dalam masalah pemfilteran spam.
Skrip berikut tersedia di bda/part3/naive_bayes/naive_bayes.R mengajukan.
# Install these packages
pkgs = c("klaR", "caret", "ElemStatLearn")
install.packages(pkgs)
library('ElemStatLearn')
library("klaR")
library("caret")
# Split the data in training and testing
inx = sample(nrow(spam), round(nrow(spam) * 0.9))
train = spam[inx,]
test = spam[-inx,]
# Define a matrix with features, X_train
# And a vector with class labels, y_train
X_train = train[,-58]
y_train = train$spam X_test = test[,-58] y_test = test$spam
# Train the model
nb_model = train(X_train, y_train, method = 'nb',
trControl = trainControl(method = 'cv', number = 3))
# Compute
preds = predict(nb_model$finalModel, X_test)$class
tbl = table(y_test, yhat = preds)
sum(diag(tbl)) / sum(tbl)
# 0.7217391Seperti yang bisa kita lihat dari hasil, akurasi model Naive Bayes adalah 72%. Ini berarti model mengklasifikasikan 72% instance dengan benar.
K-means clustering bertujuan untuk mempartisi n pengamatan menjadi k cluster di mana setiap pengamatan termasuk dalam cluster dengan mean terdekat, berfungsi sebagai prototipe cluster. Ini menghasilkan partisi ruang data menjadi sel Voronoi.
Diberikan himpunan pengamatan (x 1 , x 2 ,…, x n ) , di mana setiap pengamatan adalah vektor nyata berdimensi d, pengelompokan k-means bertujuan untuk membagi n pengamatan ke dalam kelompok k G = {G 1 , G 2 ,…, G k } untuk meminimalkan jumlah kuadrat dalam klaster (WCSS) yang didefinisikan sebagai berikut -
$$argmin \: \sum_{i = 1}^{k} \sum_{x \in S_{i}}\parallel x - \mu_{i}\parallel ^2$$
Rumus selanjutnya menunjukkan fungsi tujuan yang diminimalkan untuk menemukan prototipe yang optimal dalam k-means clustering. Intuisi rumusnya adalah kami ingin menemukan grup yang berbeda satu sama lain dan setiap anggota dari setiap grup harus serupa dengan anggota lain dari setiap cluster.
Contoh berikut menunjukkan cara menjalankan algoritme pengelompokan k-means di R.
library(ggplot2)
# Prepare Data
data = mtcars
# We need to scale the data to have zero mean and unit variance
data <- scale(data)
# Determine number of clusters
wss <- (nrow(data)-1)*sum(apply(data,2,var))
for (i in 2:dim(data)[2]) {
wss[i] <- sum(kmeans(data, centers = i)$withinss)
}
# Plot the clusters
plot(1:dim(data)[2], wss, type = "b", xlab = "Number of Clusters",
ylab = "Within groups sum of squares")Untuk menemukan nilai yang baik untuk K, kita dapat memplot jumlah kuadrat dalam grup untuk nilai K yang berbeda. Metrik ini biasanya menurun saat lebih banyak grup ditambahkan, kami ingin menemukan titik di mana penurunan jumlah grup dalam kotak mulai menurun perlahan. Dalam plot, nilai ini paling baik diwakili oleh K = 6.
Sekarang nilai K telah ditentukan, itu diperlukan untuk menjalankan algoritma dengan nilai itu.
# K-Means Cluster Analysis
fit <- kmeans(data, 5) # 5 cluster solution
# get cluster means
aggregate(data,by = list(fit$cluster),FUN = mean)
# append cluster assignment
data <- data.frame(data, fit$cluster)Misalkan I = i 1 , i 2 , ..., i n menjadi himpunan n atribut biner yang disebut item. Misalkan D = t 1 , t 2 , ..., t m adalah sekumpulan transaksi yang disebut database. Setiap transaksi di D memiliki ID transaksi unik dan berisi subset dari item di I. Aturan didefinisikan sebagai implikasi dari bentuk X ⇒ Y di mana X, Y ⊆ I dan X ∩ Y = ∅.
Himpunan item (untuk item-set pendek) X dan Y disebut anteseden (sisi kiri atau kiri) dan konsekuensi (sisi kanan atau kanan) aturan.
Untuk mengilustrasikan konsep, kami menggunakan contoh kecil dari domain supermarket. Himpunan item adalah I = {susu, roti, mentega, bir} dan database kecil yang berisi item tersebut ditunjukkan pada tabel berikut.
| ID transaksi | Item |
|---|---|
| 1 | susu, roti |
| 2 | mentega roti |
| 3 | Bir |
| 4 | susu, roti, mentega |
| 5 | mentega roti |
Contoh aturan untuk supermarket adalah {susu, roti} ⇒ {mentega} yang berarti jika susu dan roti dibeli, pelanggan juga membeli mentega. Untuk memilih aturan yang menarik dari kumpulan semua aturan yang mungkin, batasan pada berbagai ukuran signifikansi dan kepentingan dapat digunakan. Kendala yang paling terkenal adalah ambang batas minimum pada dukungan dan keyakinan.
Dukungan supp (X) dari set item X didefinisikan sebagai proporsi transaksi dalam set data yang berisi set item. Dalam contoh database di Tabel 1, item-set {milk, bread} memiliki dukungan 2/5 = 0,4 karena ini terjadi di 40% dari semua transaksi (2 dari 5 transaksi). Menemukan item-set yang sering ditemukan dapat dilihat sebagai penyederhanaan dari masalah pembelajaran tanpa pengawasan.
Keyakinan suatu aturan didefinisikan conf (X ⇒ Y) = supp (X ∪ Y) / supp (X). Misalnya aturan {susu, roti} ⇒ {mentega} memiliki tingkat keyakinan 0,2 / 0,4 = 0,5 dalam database pada Tabel 1, yang berarti bahwa untuk 50% transaksi yang mengandung susu dan roti, aturan tersebut benar. Keyakinan dapat diartikan sebagai estimasi probabilitas P (Y | X), probabilitas ditemukannya RHS aturan dalam transaksi dengan syarat transaksi tersebut juga mengandung LHS.
Dalam skrip yang terletak di bda/part3/apriori.R kode untuk mengimplementasikan apriori algorithm dapat ditemukan.
# Load the library for doing association rules
# install.packages(’arules’)
library(arules)
# Data preprocessing
data("AdultUCI")
AdultUCI[1:2,]
AdultUCI[["fnlwgt"]] <- NULL
AdultUCI[["education-num"]] <- NULL
AdultUCI[[ "age"]] <- ordered(cut(AdultUCI[[ "age"]], c(15,25,45,65,100)),
labels = c("Young", "Middle-aged", "Senior", "Old"))
AdultUCI[[ "hours-per-week"]] <- ordered(cut(AdultUCI[[ "hours-per-week"]],
c(0,25,40,60,168)), labels = c("Part-time", "Full-time", "Over-time", "Workaholic"))
AdultUCI[[ "capital-gain"]] <- ordered(cut(AdultUCI[[ "capital-gain"]],
c(-Inf,0,median(AdultUCI[[ "capital-gain"]][AdultUCI[[ "capitalgain"]]>0]),Inf)),
labels = c("None", "Low", "High"))
AdultUCI[[ "capital-loss"]] <- ordered(cut(AdultUCI[[ "capital-loss"]],
c(-Inf,0, median(AdultUCI[[ "capital-loss"]][AdultUCI[[ "capitalloss"]]>0]),Inf)),
labels = c("none", "low", "high"))Untuk menghasilkan aturan menggunakan algoritma apriori, kita perlu membuat matriks transaksi. Kode berikut menunjukkan bagaimana melakukan ini di R.
# Convert the data into a transactions format
Adult <- as(AdultUCI, "transactions")
Adult
# transactions in sparse format with
# 48842 transactions (rows) and
# 115 items (columns)
summary(Adult)
# Plot frequent item-sets
itemFrequencyPlot(Adult, support = 0.1, cex.names = 0.8)
# generate rules
min_support = 0.01
confidence = 0.6
rules <- apriori(Adult, parameter = list(support = min_support, confidence = confidence))
rules
inspect(rules[100:110, ])
# lhs rhs support confidence lift
# {occupation = Farming-fishing} => {sex = Male} 0.02856148 0.9362416 1.4005486
# {occupation = Farming-fishing} => {race = White} 0.02831579 0.9281879 1.0855456
# {occupation = Farming-fishing} => {native-country 0.02671881 0.8758389 0.9759474
= United-States}Decision Tree adalah algoritma yang digunakan untuk masalah pembelajaran yang diawasi seperti klasifikasi atau regresi. Pohon keputusan atau pohon klasifikasi adalah pohon di mana setiap simpul internal (nonleaf) diberi label dengan fitur masukan. Busur yang berasal dari node yang diberi label dengan fitur diberi label dengan masing-masing nilai yang mungkin dari fitur tersebut. Setiap daun pohon diberi label dengan kelas atau distribusi probabilitas di atas kelas.
Sebuah pohon dapat "dipelajari" dengan memisahkan kumpulan sumber menjadi beberapa subset berdasarkan pengujian nilai atribut. Proses ini diulangi pada setiap subset turunan secara rekursif yang disebutrecursive partitioning. Rekursi selesai ketika subset pada node memiliki semua nilai yang sama dari variabel target, atau ketika pemisahan tidak lagi menambah nilai pada prediksi. Proses induksi pohon keputusan dari atas ke bawah adalah contoh algoritme rakus, dan ini adalah strategi paling umum untuk mempelajari pohon keputusan.
Pohon keputusan yang digunakan dalam penambangan data terdiri dari dua jenis utama -
Classification tree - bila responnya adalah variabel nominal, misalnya jika email adalah spam atau bukan.
Regression tree - ketika hasil yang diprediksi dapat dianggap sebagai angka nyata (misalnya gaji seorang pekerja).
Pohon keputusan adalah metode sederhana, dan karena itu memiliki beberapa masalah. Salah satu masalah ini adalah varians yang tinggi dalam model yang dihasilkan yang dihasilkan pohon keputusan. Untuk mengatasi masalah ini, metode ansambel pohon keputusan dikembangkan. Ada dua kelompok metode ensemble yang saat ini digunakan secara luas -
Bagging decision trees- Pohon-pohon ini digunakan untuk membangun beberapa pohon keputusan dengan mengambil sampel ulang data pelatihan berulang kali dengan penggantian, dan memilih pohon untuk prediksi konsensus. Algoritma ini disebut hutan acak.
Boosting decision trees- Peningkatan gradien menggabungkan pelajar yang lemah; dalam hal ini, keputusan pohon menjadi pembelajar tunggal yang kuat, secara berulang. Ini menyesuaikan pohon yang lemah dengan data dan secara berulang terus menyesuaikan pelajar yang lemah untuk memperbaiki kesalahan dari model sebelumnya.
# Install the party package
# install.packages('party')
library(party)
library(ggplot2)
head(diamonds)
# We will predict the cut of diamonds using the features available in the
diamonds dataset.
ct = ctree(cut ~ ., data = diamonds)
# plot(ct, main="Conditional Inference Tree")
# Example output
# Response: cut
# Inputs: carat, color, clarity, depth, table, price, x, y, z
# Number of observations: 53940
#
# 1) table <= 57; criterion = 1, statistic = 10131.878
# 2) depth <= 63; criterion = 1, statistic = 8377.279
# 3) table <= 56.4; criterion = 1, statistic = 226.423
# 4) z <= 2.64; criterion = 1, statistic = 70.393
# 5) clarity <= VS1; criterion = 0.989, statistic = 10.48
# 6) color <= E; criterion = 0.997, statistic = 12.829
# 7)* weights = 82
# 6) color > E
#Table of prediction errors
table(predict(ct), diamonds$cut)
# Fair Good Very Good Premium Ideal
# Fair 1388 171 17 0 14
# Good 102 2912 499 26 27
# Very Good 54 998 3334 249 355
# Premium 44 711 5054 11915 1167
# Ideal 22 114 3178 1601 19988
# Estimated class probabilities
probs = predict(ct, newdata = diamonds, type = "prob")
probs = do.call(rbind, probs)
head(probs)Regresi logistik adalah model klasifikasi dimana variabel respon bersifat kategorikal. Ini adalah algoritma yang berasal dari statistik dan digunakan untuk masalah klasifikasi terbimbing. Dalam regresi logistik kami mencari vektor β parameter dalam persamaan berikut yang meminimalkan fungsi biaya.
$$logit(p_i) = ln \left ( \frac{p_i}{1 - p_i} \right ) = \beta_0 + \beta_1x_{1,i} + ... + \beta_kx_{k,i}$$
Kode berikut menunjukkan cara menyesuaikan model regresi logistik di R. Di sini kita akan menggunakan kumpulan data spam untuk mendemonstrasikan regresi logistik, yang sama yang digunakan untuk Naive Bayes.
Dari hasil prediksi dalam hal akurasi, kami menemukan bahwa model regresi mencapai akurasi 92,5% pada set pengujian, dibandingkan dengan 72% yang dicapai oleh pengklasifikasi Naive Bayes.
library(ElemStatLearn)
head(spam)
# Split dataset in training and testing
inx = sample(nrow(spam), round(nrow(spam) * 0.8))
train = spam[inx,]
test = spam[-inx,]
# Fit regression model
fit = glm(spam ~ ., data = train, family = binomial())
summary(fit)
# Call:
# glm(formula = spam ~ ., family = binomial(), data = train)
#
# Deviance Residuals:
# Min 1Q Median 3Q Max
# -4.5172 -0.2039 0.0000 0.1111 5.4944
# Coefficients:
# Estimate Std. Error z value Pr(>|z|)
# (Intercept) -1.511e+00 1.546e-01 -9.772 < 2e-16 ***
# A.1 -4.546e-01 2.560e-01 -1.776 0.075720 .
# A.2 -1.630e-01 7.731e-02 -2.108 0.035043 *
# A.3 1.487e-01 1.261e-01 1.179 0.238591
# A.4 2.055e+00 1.467e+00 1.401 0.161153
# A.5 6.165e-01 1.191e-01 5.177 2.25e-07 ***
# A.6 7.156e-01 2.768e-01 2.585 0.009747 **
# A.7 2.606e+00 3.917e-01 6.652 2.88e-11 ***
# A.8 6.750e-01 2.284e-01 2.955 0.003127 **
# A.9 1.197e+00 3.362e-01 3.559 0.000373 ***
# Signif. codes: 0 *** 0.001 ** 0.01 * 0.05 . 0.1 1
### Make predictions
preds = predict(fit, test, type = ’response’)
preds = ifelse(preds > 0.5, 1, 0)
tbl = table(target = test$spam, preds)
tbl
# preds
# target 0 1
# email 535 23
# spam 46 316
sum(diag(tbl)) / sum(tbl)
# 0.925Rangkaian waktu adalah urutan pengamatan variabel kategorikal atau numerik yang diindeks oleh tanggal, atau stempel waktu. Contoh yang jelas dari data deret waktu adalah deret waktu harga saham. Pada tabel berikut, kita dapat melihat struktur dasar dari data deret waktu. Dalam hal ini observasi dicatat setiap jam.
| Stempel waktu | Harga saham |
|---|---|
| 2015-10-11 09:00:00 | 100 |
| 2015-10-11 10:00:00 | 110 |
| 2015-10-11 11:00:00 | 105 |
| 2015-10-11 12:00:00 | 90 |
| 2015-10-11 13:00:00 | 120 |
Biasanya, langkah pertama dalam analisis deret waktu adalah memplot rangkaian tersebut, ini biasanya dilakukan dengan diagram garis.
Aplikasi yang paling umum dari analisis deret waktu adalah meramalkan nilai numerik masa depan menggunakan struktur temporal data. Artinya, observasi yang ada digunakan untuk memprediksi nilai dari masa depan.
Pengurutan data sementara, menyiratkan bahwa metode regresi tradisional tidak berguna. Untuk membuat ramalan yang kuat, kita membutuhkan model yang memperhitungkan urutan data secara temporal.
Model yang paling banyak digunakan untuk Analisis Deret Waktu disebut Autoregressive Moving Average(ARMA). Model terdiri dari dua bagian, sebuahautoregressive (AR) bagian dan a moving average(MA) bagian. Model tersebut biasanya kemudian disebut sebagai model ARMA (p, q) dimana p adalah urutan bagian autoregressive dan q adalah urutan bagian rata-rata bergerak.
Model Autoregresif
The AR (p) dibaca sebagai model autoregressive order p. Secara matematis ditulis sebagai -
$$ X_t = c + \ sum_ {i = 1} ^ {P} \ phi_i X_ {t - i} + \ varepsilon_ {t} $$
di mana {φ 1 ,…, φ p } adalah parameter yang akan diestimasi, c adalah konstanta, dan variabel acak ε t mewakili white noise. Beberapa batasan diperlukan pada nilai parameter agar model tetap stasioner.
Moving Average
Notasi MA (q) mengacu pada model moving average order q -
$$ X_t = \ mu + \ varepsilon_t + \ sum_ {i = 1} ^ {q} \ theta_i \ varepsilon_ {t - i} $$
di mana θ 1 , ..., θ q adalah parameter model, μ adalah ekspektasi dari X t , dan ε t , ε t - 1 , ... adalah, istilah kesalahan white noise.
Rata-Rata Pergerakan Autoregresif
Model ARMA (p, q) menggabungkan istilah autoregresif p dan q istilah rata-rata bergerak. Secara matematis model diekspresikan dengan rumus sebagai berikut:
$$ X_t = c + \ varepsilon_t + \ sum_ {i = 1} ^ {P} \ phi_iX_ {t - 1} + \ sum_ {i = 1} ^ {q} \ theta_i \ varepsilon_ {ti} $$
Dapat dilihat bahwa model ARMA (p, q) merupakan kombinasi dari model AR (p) dan MA (q) .
Untuk memberikan beberapa intuisi dari model, pertimbangkan bahwa bagian AR dari persamaan berusaha untuk memperkirakan parameter untuk pengamatan X t - i untuk memprediksi nilai variabel dalam X t . Ini pada akhirnya adalah rata-rata tertimbang dari nilai-nilai lampau. Bagian MA menggunakan pendekatan yang sama tetapi dengan kesalahan pengamatan sebelumnya, ε t - i . Jadi pada akhirnya, hasil dari model tersebut adalah rata-rata tertimbang.
Potongan kode berikut menunjukkan bagaimana menerapkan ARMA (p, q) di R .
# install.packages("forecast")
library("forecast")
# Read the data
data = scan('fancy.dat')
ts_data <- ts(data, frequency = 12, start = c(1987,1))
ts_data
plot.ts(ts_data)Merencanakan data biasanya merupakan langkah pertama untuk mengetahui apakah ada struktur temporal dalam data. Kita dapat melihat dari plot bahwa ada lonjakan yang kuat di setiap akhir tahun.
Kode berikut menyesuaikan model ARMA dengan data. Ini menjalankan beberapa kombinasi model dan memilih salah satu yang memiliki lebih sedikit kesalahan.
# Fit the ARMA model
fit = auto.arima(ts_data)
summary(fit)
# Series: ts_data
# ARIMA(1,1,1)(0,1,1)[12]
# Coefficients:
# ar1 ma1 sma1
# 0.2401 -0.9013 0.7499
# s.e. 0.1427 0.0709 0.1790
#
# sigma^2 estimated as 15464184: log likelihood = -693.69
# AIC = 1395.38 AICc = 1395.98 BIC = 1404.43
# Training set error measures:
# ME RMSE MAE MPE MAPE MASE ACF1
# Training set 328.301 3615.374 2171.002 -2.481166 15.97302 0.4905797 -0.02521172Dalam bab ini, kita akan menggunakan data yang diambil dari bagian 1 buku ini. Data tersebut memiliki teks yang menjelaskan profil freelancer, dan tarif per jam yang mereka kenakan dalam USD. Ide dari bagian berikut ini adalah untuk menyesuaikan model yang diberikan keterampilan seorang freelancer, kami dapat memprediksi gaji per jamnya.
Kode berikut menunjukkan cara mengonversi teks mentah yang dalam hal ini memiliki keterampilan pengguna dalam matriks sekantong kata. Untuk ini kami menggunakan perpustakaan R yang disebut tm. Artinya untuk setiap kata dalam korpus kita buat variabel dengan jumlah kemunculan masing-masing variabel.
library(tm)
library(data.table)
source('text_analytics/text_analytics_functions.R')
data = fread('text_analytics/data/profiles.txt')
rate = as.numeric(data$rate)
keep = !is.na(rate)
rate = rate[keep]
### Make bag of words of title and body
X_all = bag_words(data$user_skills[keep])
X_all = removeSparseTerms(X_all, 0.999)
X_all
# <<DocumentTermMatrix (documents: 389, terms: 1422)>>
# Non-/sparse entries: 4057/549101
# Sparsity : 99%
# Maximal term length: 80
# Weighting : term frequency - inverse document frequency (normalized) (tf-idf)
### Make a sparse matrix with all the data
X_all <- as_sparseMatrix(X_all)Sekarang kita memiliki teks yang direpresentasikan sebagai matriks renggang, kita dapat menyesuaikan model yang akan memberikan solusi renggang. Alternatif yang baik untuk kasus ini adalah menggunakan LASSO (penyusutan dan penyeleksian yang paling tidak absolut). Ini adalah model regresi yang mampu memilih fitur yang paling relevan untuk memprediksi target.
train_inx = 1:200
X_train = X_all[train_inx, ]
y_train = rate[train_inx]
X_test = X_all[-train_inx, ]
y_test = rate[-train_inx]
# Train a regression model
library(glmnet)
fit <- cv.glmnet(x = X_train, y = y_train,
family = 'gaussian', alpha = 1,
nfolds = 3, type.measure = 'mae')
plot(fit)
# Make predictions
predictions = predict(fit, newx = X_test)
predictions = as.vector(predictions[,1])
head(predictions)
# 36.23598 36.43046 51.69786 26.06811 35.13185 37.66367
# We can compute the mean absolute error for the test data
mean(abs(y_test - predictions))
# 15.02175Sekarang kami memiliki model yang diberikan seperangkat keterampilan yang dapat memprediksi gaji per jam seorang freelancer. Jika lebih banyak data yang dikumpulkan, performa model akan meningkat, tetapi kode untuk mengimplementasikan pipeline ini akan sama.
Pembelajaran online adalah subbidang pembelajaran mesin yang memungkinkan untuk menskalakan model pembelajaran yang diawasi ke kumpulan data yang sangat besar. Ide dasarnya adalah kita tidak perlu membaca semua data dalam memori agar sesuai dengan model, kita hanya perlu membaca setiap contoh pada satu waktu.
Dalam hal ini, kami akan menunjukkan bagaimana mengimplementasikan algoritma pembelajaran online menggunakan regresi logistik. Seperti di sebagian besar algoritma pembelajaran yang diawasi, ada fungsi biaya yang diminimalkan. Dalam regresi logistik, fungsi biaya didefinisikan sebagai -
$$ J (\ theta) \: = \: \ frac {-1} {m} \ kiri [\ sum_ {i = 1} ^ {m} y ^ {(i)} log (h _ {\ theta} ( x ^ {(i)})) + (1 - y ^ {(i)}) log (1 - h _ {\ theta} (x ^ {(i)})) \ kanan] $$
dimana J (θ) mewakili fungsi biaya dan h θ (x) mewakili hipotesis. Dalam kasus regresi logistik, ini didefinisikan dengan rumus berikut -
$$ h_ \ theta (x) = \ frac {1} {1 + e ^ {\ theta ^ T x}} $$
Sekarang kita telah mendefinisikan fungsi biaya, kita perlu menemukan algoritma untuk meminimalkannya. Algoritme paling sederhana untuk mencapai hal ini disebut penurunan gradien stokastik. Aturan pembaruan algoritme untuk bobot model regresi logistik didefinisikan sebagai -
$$ \ theta_j: = \ theta_j - \ alpha (h_ \ theta (x) - y) x $$
Ada beberapa implementasi dari algoritme berikut, tetapi yang diterapkan di pustaka wabbit vowpal sejauh ini adalah yang paling berkembang. Pustaka memungkinkan pelatihan model regresi skala besar dan menggunakan RAM dalam jumlah kecil. Dalam kata-kata pembuatnya sendiri dijelaskan sebagai: "Proyek Vowpal Wabbit (VW) adalah sistem pembelajaran out-of-core cepat yang disponsori oleh Microsoft Research dan (sebelumnya) Yahoo! Research".
Kami akan bekerja dengan kumpulan data titanic dari a kagglekompetisi. Data asli dapat ditemukan dibda/part3/vwmap. Di sini, kami memiliki dua file -
- Kami memiliki data pelatihan (train_titanic.csv), dan
- data tidak berlabel untuk membuat prediksi baru (test_titanic.csv).
Untuk mengonversi format csv ke vowpal wabbit format masukan menggunakan csv_to_vowpal_wabbit.pyskrip python. Anda jelas perlu menginstal python untuk ini. Arahkan kebda/part3/vw folder, buka terminal dan jalankan perintah berikut -
python csv_to_vowpal_wabbit.pyPerhatikan bahwa untuk bagian ini, jika Anda menggunakan windows Anda perlu menginstal baris perintah Unix, masuk ke situs web cygwin untuk itu.
Buka terminal dan juga di folder bda/part3/vw dan jalankan perintah berikut -
vw train_titanic.vw -f model.vw --binary --passes 20 -c -q ff --sgd --l1
0.00000001 --l2 0.0000001 --learning_rate 0.5 --loss_function logisticMari kita uraikan apa masing-masing argumen vw call cara.
-f model.vw - artinya kita menyimpan model dalam file model.vw untuk membuat prediksi nanti
--binary - Melaporkan kerugian sebagai klasifikasi biner dengan -1,1 label
--passes 20 - Data tersebut digunakan 20 kali untuk mempelajari bobot
-c - buat file cache
-q ff - Gunakan fitur kuadrat di namespace f
--sgd - menggunakan pembaruan penurunan gradien stokastik reguler / klasik / sederhana, yaitu nonadaptif, non-normalisasi, dan non-invarian.
--l1 --l2 - Regularisasi norma L1 dan L2
--learning_rate 0.5 - Kecepatan pembelajaran αseperti yang ditentukan dalam rumus aturan pembaruan
Kode berikut menunjukkan hasil dari menjalankan model regresi di baris perintah. Hasilnya, kami mendapatkan log-loss rata-rata dan laporan kecil dari performa algoritme.
-loss_function logistic
creating quadratic features for pairs: ff
using l1 regularization = 1e-08
using l2 regularization = 1e-07
final_regressor = model.vw
Num weight bits = 18
learning rate = 0.5
initial_t = 1
power_t = 0.5
decay_learning_rate = 1
using cache_file = train_titanic.vw.cache
ignoring text input in favor of cache input
num sources = 1
average since example example current current current
loss last counter weight label predict features
0.000000 0.000000 1 1.0 -1.0000 -1.0000 57
0.500000 1.000000 2 2.0 1.0000 -1.0000 57
0.250000 0.000000 4 4.0 1.0000 1.0000 57
0.375000 0.500000 8 8.0 -1.0000 -1.0000 73
0.625000 0.875000 16 16.0 -1.0000 1.0000 73
0.468750 0.312500 32 32.0 -1.0000 -1.0000 57
0.468750 0.468750 64 64.0 -1.0000 1.0000 43
0.375000 0.281250 128 128.0 1.0000 -1.0000 43
0.351562 0.328125 256 256.0 1.0000 -1.0000 43
0.359375 0.367188 512 512.0 -1.0000 1.0000 57
0.274336 0.274336 1024 1024.0 -1.0000 -1.0000 57 h
0.281938 0.289474 2048 2048.0 -1.0000 -1.0000 43 h
0.246696 0.211454 4096 4096.0 -1.0000 -1.0000 43 h
0.218922 0.191209 8192 8192.0 1.0000 1.0000 43 h
finished run
number of examples per pass = 802
passes used = 11
weighted example sum = 8822
weighted label sum = -2288
average loss = 0.179775 h
best constant = -0.530826
best constant’s loss = 0.659128
total feature number = 427878Sekarang kita bisa menggunakan model.vw kami melatih untuk menghasilkan prediksi dengan data baru.
vw -d test_titanic.vw -t -i model.vw -p predictions.txtPrediksi yang dihasilkan pada perintah sebelumnya tidak dinormalisasi agar sesuai di antara rentang [0, 1]. Untuk melakukan ini, kami menggunakan transformasi sigmoid.
# Read the predictions
preds = fread('vw/predictions.txt')
# Define the sigmoid function
sigmoid = function(x) {
1 / (1 + exp(-x))
}
probs = sigmoid(preds[[1]])
# Generate class labels
preds = ifelse(probs > 0.5, 1, 0)
head(preds)
# [1] 0 1 0 0 1 0