Panduan Definitif untuk Regresi Logistik dengan Python

Pengantar

Kadang bingung dengan regresi linier oleh pemula – karena berbagi istilah regresi - regresi logistik jauh berbeda dengan regresi linier. Sedangkan regresi linier memprediksi nilai seperti 2, 2.45, 6.77 atau nilai berkelanjutan, membuatnya menjadi regresi algoritma, regresi logistik memprediksi nilai-nilai seperti 0 atau 1, 1 atau 2 atau 3, yang nilai diskrit, membuatnya menjadi klasifikasi algoritma. Ya, itu disebut regresi tetapi adalah klasifikasi algoritma. Lebih lanjut tentang itu sebentar lagi.

Oleh karena itu, jika masalah ilmu data Anda melibatkan nilai kontinu, Anda dapat menerapkan a regresi algoritma (regresi linier adalah salah satunya). Jika tidak, jika melibatkan pengklasifikasian input, nilai diskrit, atau kelas, Anda dapat menerapkan a klasifikasi algoritma (regresi logistik adalah salah satunya).

Dalam panduan ini, kita akan melakukan regresi logistik dengan Python dengan library Scikit-Learn. Kami juga akan menjelaskan mengapa kata "regresi" hadir dalam nama dan cara kerja regresi logistik.

Untuk melakukan itu, pertama-tama kita akan memuat data yang akan diklasifikasikan, divisualisasikan, dan diproses sebelumnya. Kemudian, kita akan membangun model regresi logistik yang akan memahami data tersebut. Model ini kemudian akan dievaluasi, dan digunakan untuk memprediksi nilai berdasarkan input baru.

Motivasi

Perusahaan tempat Anda bekerja melakukan kemitraan dengan pertanian pertanian Turki. Kemitraan ini melibatkan penjualan biji labu. Biji labu sangat penting untuk nutrisi manusia. Mereka mengandung proporsi yang baik dari karbohidrat, lemak, protein, kalsium, kalium, fosfor, magnesium, besi, dan seng.

Di tim ilmu data, tugas Anda adalah membedakan jenis biji labu hanya dengan menggunakan data – atau mengklasifikasikan data sesuai dengan jenis benih.

Pertanian Turki bekerja dengan dua jenis biji labu, satu disebut erçevelik Dan lainnya rgüp Sivrisi.

Untuk mengklasifikasikan biji labu, tim Anda telah mengikuti makalah 2021 “Penggunaan metode machine learning dalam klasifikasi biji labu kuning (Cucurbita pepo L.). Sumber Daya Genetik dan Evolusi Tanaman” dari Koklu, Sarigil, dan Ozbek – dalam makalah ini, ada metodologi untuk memotret dan mengekstrak ukuran benih dari gambar.

Setelah menyelesaikan proses yang dijelaskan dalam makalah, pengukuran berikut diekstraksi:

• Daerah – jumlah piksel dalam batas biji labu
• keliling – keliling dalam piksel biji labu
• Panjang Sumbu Utama – juga keliling dalam piksel biji labu
• Panjang Sumbu Kecil – jarak sumbu kecil biji labu
• Keanehan – eksentrisitas biji labu
• Area Cembung – jumlah piksel kulit cembung terkecil di daerah yang dibentuk oleh biji labu
• Tingkat – rasio area biji labu dengan piksel kotak pembatas
• Diameter Setara – akar kuadrat dari perkalian area biji labu dengan empat dibagi dengan pi
• Kekompakan – proporsi luas biji labu relatif terhadap luas lingkaran dengan keliling yang sama
• Kepadatan – kondisi cembung dan cembung biji labu
• Kebulatan – ovalitas biji labu tanpa mempertimbangkan distorsi tepinya
• Rasio Aspek – rasio aspek biji labu

Itu adalah pengukuran yang harus Anda kerjakan. Selain pengukuran, ada juga Kelas label untuk dua jenis biji labu.

Untuk mulai mengklasifikasikan benih, mari impor data dan mulai melihatnya.

Memahami Kumpulan Data

Setelah mengunduh kumpulan data, kita dapat memuatnya ke dalam struktur kerangka data menggunakan pandas Perpustakaan. Karena ini adalah file excel, kami akan menggunakan read_excel() Metode:

import pandas as pd

fpath = 'dataset/pumpkin_seeds_dataset.xlsx' 
df = pd.read_excel(fpath)

Setelah data dimuat, kita dapat mengintip 5 baris pertama menggunakan head() Metode:

df.head() 

Ini menghasilkan:

	Area 	Perimeter 	Major_Axis_Length 	Minor_Axis_Length 	Convex_Area 	Equiv_Diameter 	Eccentricity 	Solidity 	Extent 	Roundness 	Aspect_Ration 	Compactness 	Class
0 	56276 	888.242 	326.1485 			220.2388 			56831 			267.6805 		0.7376 			0.9902 		0.7453 	0.8963 		1.4809 			0.8207 			Çerçevelik
1 	76631 	1068.146 	417.1932 			234.2289 			77280 			312.3614 		0.8275 			0.9916 		0.7151 	0.8440 		1.7811 			0.7487 			Çerçevelik
2 	71623 	1082.987 	435.8328 			211.0457 			72663 			301.9822 		0.8749 			0.9857 		0.7400 	0.7674 		2.0651 			0.6929 			Çerçevelik
3 	66458 	992.051 	381.5638 			222.5322 			67118 			290.8899 		0.8123 			0.9902 		0.7396 	0.8486 		1.7146 			0.7624 			Çerçevelik
4 	66107 	998.146 	383.8883 			220.4545 			67117 			290.1207 		0.8187 			0.9850 		0.6752 	0.8338 		1.7413 			0.7557 			Çerçevelik

Di sini, kami memiliki semua pengukuran di kolom masing-masing, kami fitur, Dan juga Kelas kolom, kami target, yang merupakan yang terakhir dalam kerangka data. Kita dapat melihat berapa banyak pengukuran yang kita miliki dengan menggunakan shape atribut:

df.shape 

Outputnya adalah:

(2500, 13)

Hasil bentuk memberi tahu kita bahwa ada 2500 entri (atau baris) dalam kumpulan data dan 13 kolom. Karena kami tahu ada satu kolom target – ini berarti kami memiliki 12 kolom fitur.

Kita sekarang dapat menjelajahi variabel target, biji labu Class. Karena kita akan memprediksi variabel itu, menarik untuk melihat berapa banyak sampel dari setiap biji labu yang kita miliki. Biasanya, semakin kecil perbedaan antara jumlah instance di kelas kami, semakin seimbang sampel kami dan semakin baik prediksi kami.

Pemeriksaan ini dapat dilakukan dengan menghitung setiap sampel benih dengan value_counts() Metode:

df['Class'].value_counts() 

Kode di atas menampilkan:

Çerçevelik       1300
Ürgüp Sivrisi    1200
Name: Class, dtype: int64

Kita dapat melihat bahwa ada 1300 sampel erçevelik benih dan 1200 sampel rgüp Sivrisi benih. Perhatikan bahwa perbedaan di antara mereka adalah 100 sampel, perbedaan yang sangat kecil, yang baik untuk kita dan menunjukkan tidak perlu menyeimbangkan kembali jumlah sampel.

Mari kita lihat juga statistik deskriptif fitur kami dengan describe() metode untuk melihat seberapa baik distribusi data. Kami juga akan mentranspos tabel yang dihasilkan dengan T untuk mempermudah membandingkan seluruh statistik:

df.describe().T

Tabel yang dihasilkan adalah:

					count 	mean 			std 			min 		25% 			50% 			75% 			max
Area 				2500.0 	80658.220800 	13664.510228 	47939.0000 	70765.000000 	79076.00000 	89757.500000 	136574.0000
Perimeter 			2500.0 	1130.279015 	109.256418 		868.4850 	1048.829750 	1123.67200 		1203.340500 	1559.4500
Major_Axis_Length 	2500.0 	456.601840 		56.235704 		320.8446 	414.957850 		449.49660 		492.737650 		661.9113
Minor_Axis_Length 	2500.0 	225.794921 		23.297245 		152.1718 	211.245925 		224.70310 		240.672875 		305.8180
Convex_Area 		2500.0 	81508.084400 	13764.092788 	48366.0000 	71512.000000 	79872.00000 	90797.750000 	138384.0000
Equiv_Diameter 		2500.0 	319.334230 		26.891920 		247.0584 	300.167975 		317.30535 		338.057375 		417.0029
Eccentricity 		2500.0 	0.860879 		0.045167 		0.4921 		0.831700 		0.86370 		0.897025 		0.9481
Solidity 			2500.0 	0.989492 		0.003494 		0.9186 		0.988300 		0.99030 		0.991500 		0.9944
Extent 				2500.0 	0.693205 		0.060914 		0.4680 		0.658900 		0.71305 		0.740225 		0.8296
Roundness 			2500.0 	0.791533 		0.055924 		0.5546 		0.751900 		0.79775 		0.834325 		0.9396
Aspect_Ration 		2500.0 	2.041702 		0.315997 		1.1487 		1.801050 		1.98420 		2.262075 		3.1444
Compactness 		2500.0 	0.704121 		0.053067 		0.5608 		0.663475 		0.70770 		0.743500 		0.9049

Dengan melihat tabel, saat membandingkan berarti dan standar deviasi (std) terlihat bahwa sebagian besar fitur memiliki mean yang jauh dari standar deviasi. Itu menunjukkan bahwa nilai data tidak terkonsentrasi di sekitar nilai rata-rata, tetapi lebih tersebar di sekitarnya – dengan kata lain, mereka memiliki variabilitas tinggi.

Juga, ketika melihat minimum (min) Dan maksimum (max) kolom, beberapa fitur, seperti Area, dan Convex_Area, memiliki perbedaan besar antara nilai minimum dan maksimum. Ini berarti kolom tersebut memiliki data yang sangat kecil dan juga nilai data yang sangat besar, atau amplitudo lebih tinggi antara nilai data.

Dengan variabilitas tinggi, amplitudo tinggi, dan fitur dengan unit pengukuran yang berbeda, sebagian besar data kami akan mendapat manfaat dari memiliki skala yang sama untuk semua fitur atau menjadi diskalakan. Penskalaan data akan memusatkan data di sekitar rata-rata dan mengurangi variansnya.

Skenario ini mungkin juga menunjukkan adanya outlier dan nilai ekstrim dalam data. Jadi, yang terbaik adalah memilikinya pengobatan outlier selain menskalakan data.

Ada beberapa algoritma pembelajaran mesin, misalnya, algoritma berbasis pohon seperti Klasifikasi Hutan Acak, yang tidak terpengaruh oleh varians data yang tinggi, outlier, dan nilai ekstrim. Regresi logistik berbeda, ini didasarkan pada fungsi yang mengkategorikan nilai kita, dan parameter fungsi tersebut dapat dipengaruhi oleh nilai yang keluar dari tren data umum dan memiliki varians yang tinggi.

Kami akan memahami lebih banyak tentang regresi logistik sedikit ketika kami mengimplementasikannya. Untuk saat ini, kami dapat terus mengeksplorasi data kami.

Memvisualisasikan Data

Sampai sekarang, dengan statistik deskriptif, kami memiliki gambaran yang agak abstrak dari beberapa kualitas data. Langkah penting lainnya adalah memvisualisasikannya dan mengkonfirmasi hipotesis kami tentang varians tinggi, amplitudo, dan outlier. Untuk melihat apakah apa yang telah kita amati sejauh ini terlihat dalam data, kita dapat memplot beberapa grafik.

Menarik juga untuk melihat bagaimana fitur-fitur tersebut berhubungan dengan dua kelas yang akan diprediksi. Untuk melakukan itu, mari impor seaborn paket dan gunakan pairplot grafik untuk melihat setiap distribusi fitur, dan setiap pemisahan kelas per fitur:

import seaborn as sns


sns.pairplot(data=df, hue='Class')

Melihat plot pasangan, kita dapat melihat bahwa dalam banyak kasus titik-titik dari Çerçevelik kelas dipisahkan dengan jelas dari titik-titik Ürgüp Sivrisi kelas. Entah titik-titik satu kelas berada di kanan ketika yang lain berada di kiri, atau beberapa di atas sementara yang lain di bawah. Jika kita menggunakan semacam kurva atau garis untuk memisahkan kelas, ini menunjukkan lebih mudah untuk memisahkan mereka, jika mereka dicampur, klasifikasi akan menjadi tugas yang lebih sulit.

Dalam majalah Eccentricity, Compactness dan Aspect_Ration kolom, beberapa titik yang “terisolasi” atau menyimpang dari tren data umum – outlier – juga mudah terlihat.

Saat melihat diagonal dari kiri atas ke kanan bawah grafik, perhatikan distribusi data juga diberi kode warna menurut kelas kita. Bentuk distribusi dan jarak antara kedua kurva adalah indikator lain tentang bagaimana mereka dapat dipisahkan – semakin jauh satu sama lain, semakin baik. Dalam kebanyakan kasus, mereka tidak ditumpangkan, yang menyiratkan bahwa mereka lebih mudah untuk dipisahkan, juga berkontribusi pada tugas kita.

Secara berurutan, kita juga dapat memplot boxplot semua variabel dengan sns.boxplot() metode. Sering kali, sangat membantu untuk mengarahkan plot kotak secara horizontal, sehingga bentuk plot kotak sama dengan bentuk distribusinya, kita dapat melakukannya dengan orient argumen:

sns.boxplot(data=df, orient='h') 

Dalam plot di atas, perhatikan bahwa Area dan Convex_Area memiliki magnitudo yang begitu tinggi jika dibandingkan dengan magnitudo kolom lainnya, sehingga mereka menekan boxplot lainnya. Untuk dapat melihat semua boxplot, kita dapat menskalakan fitur dan memplotnya lagi.

Sebelum melakukan itu, mari kita pahami bahwa jika ada nilai fitur yang terkait erat dengan nilai lain, misalnya – jika ada nilai yang juga semakin besar ketika nilai fitur lainnya semakin besar, memiliki korelasi positif; atau jika ada nilai yang melakukan sebaliknya, semakin kecil sementara nilai lainnya semakin kecil, memiliki a korelasi negatif.

Ini penting untuk dilihat karena memiliki hubungan yang kuat dalam data mungkin berarti bahwa beberapa kolom diturunkan dari kolom lain atau memiliki arti yang mirip dengan model kita. Ketika itu terjadi, hasil model mungkin dilebih-lebihkan dan kami menginginkan hasil yang lebih mendekati kenyataan. Jika ada korelasi yang kuat, itu juga berarti kita dapat mengurangi jumlah fitur, dan menggunakan lebih sedikit kolom untuk membuat model lebih banyak pelit.

Mari kita lihat korelasi antar variabel dan kemudian kita dapat beralih ke pra-proses data. Kami akan menghitung korelasi dengan corr() metode dan memvisualisasikannya dengan Seaborn's heatmap(). Ukuran standar peta panas cenderung kecil, jadi kami akan mengimpor matplotlib (mesin visualisasi umum/perpustakaan tempat Seaborn dibangun di atasnya) dan ubah ukurannya dengan figsize:

import matplotlib.pyplot as plt
plt.figure(figsize=(15, 10))

correlations = df.corr()
sns.heatmap(correlations, annot=True) 

Dalam heatmap ini, nilai yang mendekati 1 atau -1 adalah nilai yang perlu kita perhatikan. Kasus pertama, menunjukkan korelasi positif yang tinggi dan yang kedua, korelasi negatif yang tinggi. Kedua nilai, jika tidak di atas 0.8 atau -0.8 akan bermanfaat bagi model regresi logistik kami.

Ketika ada korelasi tinggi seperti salah satu dari 0.99 antara Aspec_Ration dan Compactness, ini berarti kita dapat memilih untuk menggunakan saja Aspec_Ration atau hanya Compactness, alih-alih keduanya (karena mereka hampir sama prediktor satu sama lain). Hal yang sama berlaku untuk Eccentricity dan Compactness dengan -0.98 korelasi, untuk Area dan Perimeter dengan 0.94 korelasi, dan beberapa kolom lainnya.

Pra-pemrosesan Data

Karena kami telah menjelajahi data untuk sementara waktu, kami dapat mulai memprosesnya terlebih dahulu. Untuk saat ini, mari kita gunakan semua fitur untuk prediksi kelas. Setelah mendapatkan model pertama, garis dasar, kami kemudian dapat menghapus beberapa kolom yang sangat berkorelasi dan membandingkannya dengan garis dasar.

Kolom fitur akan menjadi milik kami X data dan kolom kelas, kami y data sasaran:

y = df['Class']
X = df.drop(columns=['Class'], axis=1)

Mengubah Fitur Kategoris menjadi Fitur Numerik

Mengenai kami Class kolom – nilainya bukan angka, ini berarti kita juga perlu mengubahnya. Ada banyak cara untuk melakukan transformasi ini; di sini, kita akan menggunakan replace() metode dan ganti Çerçevelik untuk 0 dan Ürgüp Sivrisi untuk 1.

y = y.replace('Çerçevelik', 0).replace('Ürgüp Sivrisi', 1)

Ingat pemetaannya! Saat membaca hasil dari model Anda, Anda akan ingin mengonversinya kembali setidaknya dalam pikiran Anda, atau kembali ke nama kelas untuk pengguna lain.

Membagi Data menjadi Train dan Test Set

Dalam eksplorasi kami, kami telah mencatat bahwa fitur-fitur tersebut membutuhkan penskalaan. Jika kita melakukan penskalaan sekarang, atau secara otomatis, kita akan menskalakan nilai dengan seluruh X dan y. Dalam hal ini, kami akan memperkenalkan kebocoran data, karena nilai set pengujian yang akan segera hadir akan memengaruhi penskalaan. Kebocoran data adalah penyebab umum dari hasil yang tidak dapat direproduksi dan performa tinggi yang ilusif dari model ML.

Memikirkan tentang penskalaan menunjukkan bahwa kita harus terlebih dahulu membagi X dan y data lebih jauh ke dalam set kereta dan tes dan kemudian ke cocok scaler di set pelatihan, dan untuk mengubah baik set kereta maupun set pengujian (tanpa pernah set pengujian memengaruhi scaler yang melakukan ini). Untuk ini, kami akan menggunakan Scikit-Learn's train_test_split() Metode:

from sklearn.model_selection import train_test_split
SEED = 42 

X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=.25, 
                                                    random_state=SEED)

Pengaturan test_size=.25 memastikan kami menggunakan 25% data untuk pengujian dan 75% untuk pelatihan. Ini bisa dihilangkan, setelah itu adalah pemisahan default, tetapi Pythonik cara menulis kode menyarankan bahwa menjadi "eksplisit lebih baik daripada implisit".

Setelah membagi data menjadi rangkaian pelatihan dan pengujian, merupakan praktik yang baik untuk melihat berapa banyak catatan dalam setiap rangkaian. Itu bisa dilakukan dengan shape atribut:

X_train.shape, X_test.shape, y_train.shape, y_test.shape

Ini menampilkan:

((1875, 12), (625, 12), (1875,), (625,))

Kita dapat melihat bahwa setelah pemisahan, kami memiliki 1875 catatan untuk pelatihan dan 625 untuk pengujian.

Menskalakan Data

Setelah set pelatihan dan pengujian kami siap, kami dapat melanjutkan untuk menskalakan data dengan Scikit-Learn StandardScaler objek (atau scaler lain yang disediakan oleh perpustakaan). Untuk menghindari kebocoran, scaler dipasang pada X_train data dan nilai kereta kemudian digunakan untuk menskalakan – atau mengubah – baik data kereta maupun data uji:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

Karena Anda biasanya akan menelepon:

scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Dua baris pertama dapat diciutkan dengan singular fit_transform() panggilan, yang sesuai dengan scaler di set, dan mengubahnya dalam sekali jalan. Sekarang kita dapat mereproduksi grafik boxplot untuk melihat perbedaannya setelah menskalakan data.

Mengingat penskalaan menghapus nama kolom, sebelum merencanakan, kita dapat mengatur data kereta ke dalam kerangka data dengan nama kolom lagi untuk memfasilitasi visualisasi:

column_names = df.columns[:12] 
X_train = pd.DataFrame(X_train, columns=column_names)

sns.boxplot(data=X_train, orient='h')

Kita akhirnya bisa melihat semua boxplot kita! Perhatikan bahwa semuanya memiliki outlier, dan fitur yang menyajikan distribusi lebih jauh dari normal (yang memiliki kurva miring ke kiri atau kanan), seperti Solidity, Extent, Aspect_Ration, dan Compactedness, adalah sama yang memiliki korelasi lebih tinggi.

Menghapus Pencilan dengan Metode IQR

Kita sudah tahu bahwa regresi logistik dapat dipengaruhi oleh outlier. Salah satu cara mengobatinya adalah dengan menggunakan metode yang disebut Jarak interkuartil or I.Q.R.. Langkah awal dari metode IQR adalah membagi data train kita menjadi empat bagian, yang disebut kuartil. Kuartil pertama, Q1, berjumlah 25% dari data, yang kedua, Q2, hingga 50%, ketiga, Q3, hingga 75%, dan yang terakhir, Q4, hingga 100%. Kotak-kotak dalam boxplot ditentukan oleh metode IQR dan merupakan representasi visual darinya.

Mempertimbangkan boxplot horizontal, garis vertikal di sebelah kiri menandai 25% data, garis vertikal di tengah, 50% data (atau median), dan garis vertikal terakhir di sebelah kanan, 75% data . Semakin merata ukuran kedua kotak yang ditentukan oleh garis vertikal – atau semakin garis vertikal median berada di tengah – berarti data kami lebih dekat ke distribusi normal atau kurang miring, yang berguna untuk analisis kami.

Selain kotak IQR, ada juga garis horizontal di kedua sisinya. Garis-garis tersebut menandai nilai distribusi minimum dan maksimum yang ditentukan oleh

$$
Minimum = Q1 – 1.5*IQR
$$

dan

$$
Maksimum = Q3 + 1.5*IQR
$$

IQR persis perbedaan antara Q3 dan Q1 (atau Q3 – Q1) dan merupakan titik data paling sentral. Itulah sebabnya ketika menemukan IQR, kami akhirnya memfilter outlier di ekstremitas data, atau di titik minimum dan maksimum. Plot kotak memberi kita gambaran tentang apa hasil dari metode IQR nantinya.

Kita bisa menggunakan Panda quantile() metode untuk menemukan kuantil kami, dan iqr dari scipy.stats paket untuk mendapatkan rentang data interkuartil untuk setiap kolom:

from scipy.stats import iqr

Q1 = X_train.quantile(q=.25)
Q3 = X_train.quantile(q=.75)

IQR = X_train.apply(iqr)

Sekarang kita memiliki Q1, Q3, dan IQR, kita dapat memfilter nilai yang lebih dekat ke median:

minimum = X_train < (Q1-1.5*IQR)
maximum = X_train > (Q3+1.5*IQR)


filter = ~(minimum | maximum).any(axis=1)


X_train = X_train[filter]

Setelah memfilter baris pelatihan kami, kami dapat melihat berapa banyak dari mereka yang masih ada dalam data dengan shape:

X_train.shape

Ini menghasilkan:

(1714, 12)

Kita dapat melihat bahwa jumlah baris berubah dari tahun 1875 menjadi 1714 setelah penyaringan. Ini berarti bahwa 161 baris berisi outlier atau 8.5% dari data.

Setelah menghapus outlier, kita hampir siap untuk memasukkan data ke dalam model. Untuk model fitting, kita akan menggunakan data train. X_train difilter, tapi bagaimana dengan y_train?

y_train.shape

Output ini:

(1875,)

Perhatikan bahwa y_train masih memiliki 1875 baris. Kita harus mencocokkan jumlah y_train baris ke jumlah X_train baris dan tidak sembarangan. Kita perlu menghapus nilai-y dari instance biji labu yang kita buang, yang kemungkinan tersebar melalui y_train mengatur. yang difilter X_train masih memiliki indeks aslinya dan indeks memiliki celah di mana kami menghapus outlier! Kita kemudian dapat menggunakan indeks dari X_train DataFrame untuk mencari nilai yang sesuai di y_train:

y_train = y_train.iloc[X_train.index]

Setelah melakukan itu, kita dapat melihat y_train bentuk lagi:

y_train.shape

Keluaran mana:

(1714,)

Sekarang, y_train juga memiliki 1714 baris dan mereka sama dengan X_train baris. Kami akhirnya siap untuk membuat model regresi logistik kami!

Menerapkan Model Regresi Logistik

Bagian yang sulit sudah selesai! Prapemrosesan biasanya lebih sulit daripada pengembangan model, dalam hal penggunaan pustaka seperti Scikit-Learn, yang telah menyederhanakan penerapan model ML menjadi beberapa baris saja.

Pertama, kami mengimpor LogisticRegression kelas dan instantiate, buat LogisticRegression obyek:

from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression(random_state=SEED)

Kedua, kami menyesuaikan data kereta kami dengan logreg model dengan fit() metode, dan memprediksi data pengujian kami dengan predict() metode, menyimpan hasilnya sebagai y_pred:

logreg.fit(X_train.values, y_train)
y_pred = logreg.predict(X_test)

Kami telah membuat prediksi dengan model kami! Mari kita lihat 3 baris pertama di X_train untuk melihat data apa yang telah kami gunakan:

X_train[:3]

Kode di atas menghasilkan:

       Area          Perimeter     Major_Axis_Length    Minor_Axis_Length    Convex_Area   Equiv_Diameter       Eccentricity  Solidity      Extent        Roundness     Aspect_Ration        Compactness
0      -1.098308     -0.936518     -0.607941            -1.132551            -1.082768     -1.122359            0.458911      -1.078259     0.562847      -0.176041     0.236617             -0.360134
1      -0.501526     -0.468936     -0.387303            -0.376176            -0.507652     -0.475015            0.125764      0.258195      0.211703      0.094213      -0.122270            0.019480
2      0.012372      -0.209168     -0.354107            0.465095              0.003871      0.054384            -0.453911     0.432515      0.794735      0.647084      -0.617427            0.571137

Dan pada 3 prediksi pertama di y_pred untuk melihat hasilnya:

y_pred[:3] 

Ini menghasilkan:

array([0, 0, 0])

Untuk tiga baris itu, prediksi kami adalah bahwa mereka adalah benih kelas satu, Çerçevelik.

Dengan regresi logistik, alih-alih memprediksi kelas akhir, seperti 0, kita juga dapat memprediksi probabilitas baris yang berkaitan dengan 0 kelas. Inilah yang sebenarnya terjadi ketika regresi logistik mengklasifikasikan data, dan predict() metode kemudian melewati prediksi ini melalui ambang batas untuk mengembalikan kelas "keras". Untuk memprediksi probabilitas yang berkaitan dengan kelas, predict_proba() digunakan:

y_pred_proba = logreg.predict_proba(X_test)

Mari kita lihat juga 3 nilai pertama dari prediksi probabilitas y:

y_pred_proba[:3] 

Keluaran mana:

        # class 0   class 1   
array([[0.54726628, 0.45273372],
       [0.56324527, 0.43675473],
       [0.86233349, 0.13766651]])

Sekarang, alih-alih tiga nol, kami memiliki satu kolom untuk setiap kelas. Di kolom sebelah kiri, dimulai dengan 0.54726628, adalah peluang data yang berkaitan dengan kelas 0; dan di kolom kanan, dimulai dengan 0.45273372, adalah probabilitas itu berkaitan dengan kelas 1.

Ada lebih banyak informasi tentang bagaimana output yang diprediksi dibuat. Itu tidak benar-benar 0, tetapi peluang kelas 55% 0, dan peluang kelas 45% 1. Ini menunjukkan bagaimana tiga yang pertama X_test titik data, berkaitan dengan kelas 0, benar-benar jelas hanya mengenai titik data ketiga, dengan probabilitas 86% – dan tidak begitu banyak untuk dua titik data pertama.

Saat mengomunikasikan temuan menggunakan metode ML – biasanya yang terbaik adalah mengembalikan kelas lunak, dan probabilitas terkait sebagai "kepercayaan diri" dari klasifikasi itu.

Kita akan berbicara lebih banyak tentang bagaimana itu dihitung ketika kita masuk lebih dalam ke model. Pada saat ini, kita dapat melanjutkan ke langkah berikutnya.

Mengevaluasi Model dengan Laporan Klasifikasi

Langkah ketiga adalah melihat bagaimana model bekerja pada data uji. Kami dapat mengimpor Scikit-Learn classification_report() dan lulus kami y_test dan y_pred sebagai argumen. Setelah itu, kami dapat mencetak tanggapannya.

Laporan klasifikasi berisi metrik klasifikasi yang paling sering digunakan, seperti: ketelitian, mengingat kembali, f1-skor, dan ketepatan.

1. Ketelitian: untuk memahami nilai prediksi yang benar yang dianggap benar oleh pengklasifikasi kami. Presisi akan membagi nilai positif yang sebenarnya dengan apa pun yang diprediksi sebagai positif:

$$
presisi = frac{teks{positif benar}}{teks{positif benar} + teks{positif salah}}
$$

2. Mengingat kembali: untuk memahami berapa banyak positif sejati yang diidentifikasi oleh pengklasifikasi kami. Penarikan kembali dihitung dengan membagi positif sejati dengan apa pun yang seharusnya diprediksi sebagai positif:

$$
ingat = frac{teks{positif benar}}{teks{positif benar} + teks{negatif palsu}}
$$

3. Skor F1: apakah seimbang atau rata-rata harmonis presisi dan recall. Nilai terendah adalah 0 dan tertinggi adalah 1. Ketika f1-score sama dengan 1, itu berarti semua kelas diprediksi dengan benar – ini adalah skor yang sangat sulit diperoleh dengan data nyata:

$$
teks{f1-score} = 2* frac{text{precision} * teks{recall}}{text{precision} + teks{recall}}
$$

4. Ketepatan: menjelaskan berapa banyak prediksi yang benar dari pengklasifikasi kami. Nilai akurasi terendah adalah 0 dan tertinggi adalah 1. Nilai tersebut biasanya dikalikan dengan 100 untuk mendapatkan persentase:

$$
akurasi = frac{teks{jumlah prediksi yang benar}}{teks{jumlah total prediksi}}
$$

from sklearn.metrics import classification_report
cr = classification_report(y_test, y_pred)
print(cr)

Kita kemudian dapat melihat output laporan klasifikasi:

				precision    recall  f1-score   support

           0       0.83      0.91      0.87       316
           1       0.90      0.81      0.85       309

    accuracy                           0.86       625
   macro avg       0.86      0.86      0.86       625
weighted avg       0.86      0.86      0.86       625

Ini adalah hasil kami. Perhatikan itu precision, recall, f1-score, dan accuracy semua metrik sangat tinggi, di atas 80%, yang merupakan ideal – tetapi hasil tersebut mungkin dipengaruhi oleh korelasi tinggi, dan tidak akan bertahan dalam jangka panjang.

Keakuratan model adalah 86%, artinya model tersebut salah klasifikasi 14%. Kami memiliki informasi keseluruhan itu, tetapi akan menarik untuk mengetahui jika 14% kesalahan terjadi mengenai klasifikasi kelas 0 atau kelas 1. Untuk mengidentifikasi kelas mana yang salah diidentifikasi sebagai yang mana, dan di frekuensi mana – kita dapat menghitung dan memplot a matriks kebingungan prediksi model kami.

Mengevaluasi Model dengan Matriks Kebingungan

Mari kita hitung dan kemudian plot matriks kebingungan. Setelah melakukan itu, kita bisa memahami setiap bagiannya. Untuk memplot matriks konfusi, kita akan menggunakan Scikit-Learn confusion_matrix(), yang akan kami impor dari metrics modul.

Matriks kebingungan lebih mudah divisualisasikan menggunakan Seaborn heatmap(). Jadi, setelah membuatnya, kami akan meneruskan matriks kebingungan kami sebagai argumen untuk peta panas:

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d')

5. Matriks Kebingungan: matriks menunjukkan berapa banyak sampel model yang benar atau salah untuk setiap kelas. Nilai-nilai yang benar dan diprediksi dengan benar disebut positif sejati, dan yang diprediksi positif tetapi tidak positif disebut positif palsu. Nomenklatur yang sama dari negatif yang sebenarnya dan negatif palsu digunakan untuk nilai negatif;

Dengan melihat plot matriks kebingungan, kita dapat melihat bahwa kita memiliki 287 nilai-nilai yang 0 dan diprediksi sebagai 0 - atau positif sejati untuk kelas 0 (biji erçevelik). Kami juga punya 250 positif sejati untuk kelas 1 (biji Ürgüp Sivrisi). Positif sejati selalu terletak di diagonal matriks yang bergerak dari kiri atas ke kanan bawah.

Kami juga memiliki 29 nilai-nilai yang seharusnya 0, tetapi diprediksi sebagai 1 (positif palsu) Dan 59 nilai-nilai yang 1 dan diprediksi sebagai 0 (negatif palsu). Dengan angka-angka itu, kita dapat memahami bahwa kesalahan yang paling banyak dilakukan model adalah memprediksi negatif palsu. Jadi, sebagian besar dapat mengklasifikasikan benih rgüp Sivrisi sebagai benih erçevelik.

Kesalahan semacam ini juga dijelaskan oleh 81% recall kelas 1. Perhatikan bahwa metrik terhubung. Dan perbedaan dalam penarikan berasal dari memiliki 100 sampel lebih sedikit dari kelas rgüp Sivrisi. Ini adalah salah satu implikasi dari hanya memiliki beberapa sampel lebih sedikit dari kelas lain. Untuk lebih meningkatkan daya ingat, Anda dapat bereksperimen dengan bobot kelas atau menggunakan lebih banyak sampel rgüp Sivrisi.

Sejauh ini, kami telah menjalankan sebagian besar langkah tradisional ilmu data dan menggunakan model regresi logistik sebagai kotak hitam.

Sekarang saatnya untuk membuka kotak hitam dan melihat ke dalamnya, untuk memahami lebih dalam bagaimana regresi logistik bekerja.

Mendalami Cara Kerja Regresi Logistik

Grafik regresi Word tidak ada secara kebetulan, untuk memahami apa yang dilakukan regresi logistik, kita dapat mengingat apa yang saudara kandungnya lakukan, regresi linier terhadap data. Rumus regresi linier adalah sebagai berikut:

$$
y = b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + titik + b_n * x_n
$$

Di mana b₀ adalah intersep regresi, b¹ koefisien dan x¹ data.

Persamaan itu menghasilkan garis lurus yang digunakan untuk memprediksi nilai baru. Mengingat pendahuluan, perbedaannya sekarang adalah bahwa kita tidak akan memprediksi nilai baru, tetapi sebuah kelas. Jadi garis lurus itu perlu diubah. Dengan regresi logistik, kami memperkenalkan non-linier dan prediksi sekarang dibuat menggunakan kurva, bukan garis:

Amati bahwa sementara garis regresi linier terus berjalan dan dibuat dari nilai tak hingga yang kontinu, kurva regresi logistik dapat dibagi di tengah dan memiliki nilai ekstrem 0 dan 1. Bentuk “S” itulah yang menjadi alasan mengapa ia mengklasifikasikan data – titik-titik yang lebih dekat atau jatuh pada ekstremitas tertinggi termasuk kelas 1, sedangkan titik-titik yang berada di kuadran bawah atau mendekati 0, termasuk kelas 0. "S" adalah tengah antara 0 dan 1, 0.5 - itu adalah ambang batas untuk titik regresi logistik.

Kita sudah memahami perbedaan visual antara regresi logistik dan regresi linier, tetapi bagaimana dengan rumusnya? Rumus untuk regresi logistik adalah sebagai berikut:

$$
y = b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + titik + b_n * x_n
$$

Dapat juga ditulis sebagai:

$$
y_{masalah} = frac{1}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + titik + b_n * x_n)}}
$$

Atau bahkan ditulis sebagai:

$$
y_{masalah} = frac{e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + titik + b_n * x_n)}}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + titik + b_n * x_n)}}
$$

Dalam persamaan di atas, kami memiliki probabilitas input, bukan nilainya. Ini memiliki 1 sebagai pembilangnya sehingga dapat menghasilkan nilai antara 0 dan 1, dan 1 ditambah nilai pada penyebutnya, sehingga nilainya adalah 1 dan sesuatu – ini berarti bahwa seluruh hasil pecahan tidak boleh lebih besar dari 1 .

Dan berapakah nilai penyebutnya? Dia e, basis logaritma natural (sekitar 2.718282), dipangkatkan ke regresi linier:

$$
e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + titik + b_n * x_n)}
$$

Cara penulisan lainnya adalah:

$$
ln kiri( frac{p}{1-p} kanan) = {(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

Dalam persamaan terakhir, ln adalah logaritma natural (basis e) dan p adalah probabilitas, sehingga logaritma probabilitas hasil sama dengan hasil regresi linier.

Dengan kata lain, dengan hasil regresi linier dan logaritma natural, kita dapat sampai pada probabilitas input yang berkaitan atau tidak dengan kelas yang dirancang.

Seluruh proses penurunan regresi logistik adalah sebagai berikut:

$$
p{X} = frac{e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + titik + b_n * x_n)}}
$$

$$
p(1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}) = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldot + b_n * x_n)}
$$

$$
p + p*e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + titik + b_n * x_n)} = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + titik + b_n * x_n)}
$$

p
=

e

(

b
0

+

b
1

∗

x
1

+

b
2

∗

x
2

+

b
3

∗

x
3

+
...
+

b
n

∗

x
n

)

-
p
∗

e

(

b
0

+

b
1

∗

x
1

+

b
2

∗

x
2

+

b
3

∗

x
3

+
...
+

b
n

∗

x
n

)

$$
frac{p}{1-p} = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + titik + b_n * x_n)}
$$

$$
ln kiri( frac{p}{1-p} kanan) = (b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)
$$

Artinya model regresi logistik juga memiliki koefisien dan nilai intersep. Karena menggunakan regresi linier dan menambahkan komponen non-linier dengan logaritma natural (e).

Kita dapat melihat nilai koefisien dan intersep dari model kita, dengan cara yang sama seperti yang kita lakukan untuk regresi linier, menggunakan coef_ dan intercept_ properti:

logreg.coef_

Yang menampilkan koefisien masing-masing dari 12 fitur:

array([[ 1.43726172, -1.03136968,  0.24099522, -0.61180768,  1.36538261,
        -1.45321951, -1.22826034,  0.98766966,  0.0438686 , -0.78687889,
         1.9601197 , -1.77226097]])

logreg.intercept_

Itu menghasilkan:

array([0.08735782])

Dengan koefisien dan nilai intersep, kita dapat menghitung probabilitas yang diprediksi dari data kita. Ayo dapatkan yang pertama X_test nilai lagi, sebagai contoh:

X_test[:1]

Ini mengembalikan baris pertama dari X_test sebagai array NumPy:

array([[-1.09830823, -0.93651823, -0.60794138, -1.13255059, -1.0827684 ,
        -1.12235877,  0.45891056, -1.07825898,  0.56284738, -0.17604099,
         0.23661678, -0.36013424]])

Mengikuti persamaan awal:

$$
p{X} = frac{e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + titik + b_n * x_n)}}
$$

Di python, kami memiliki:

import math

lin_reg = logreg.intercept_[0] + 
((logreg.coef_[0][0]* X_test[:1][0][0])+ 
(logreg.coef_[0][1]* X_test[:1][0][1])+ 
(logreg.coef_[0][2]* X_test[:1][0][2])+ 
(logreg.coef_[0][3]* X_test[:1][0][3])+ 
(logreg.coef_[0][4]* X_test[:1][0][4])+ 
(logreg.coef_[0][5]* X_test[:1][0][5])+ 
(logreg.coef_[0][6]* X_test[:1][0][6])+ 
(logreg.coef_[0][7]* X_test[:1][0][7])+ 
(logreg.coef_[0][8]* X_test[:1][0][8])+ 
(logreg.coef_[0][9]* X_test[:1][0][9])+ 
(logreg.coef_[0][10]* X_test[:1][0][10])+ 
(logreg.coef_[0][11]* X_test[:1][0][11]))

px = math.exp(lin_reg)/(1 +(math.exp(lin_reg)))
px

Ini menghasilkan:

0.45273372469369133

Jika kita melihat lagi pada predict_proba hasil pertama X_test baris, kami memiliki:

logreg.predict_proba(X_test[:1])

Ini berarti bahwa persamaan regresi logistik asli memberi kita probabilitas input mengenai kelas 1, untuk mengetahui probabilitas mana untuk kelas 0, kita cukup:

1 - px

Perhatikan bahwa keduanya px dan 1-px identik dengan predict_proba hasil. Beginilah cara menghitung regresi logistik dan alasannya regresi adalah bagian dari namanya. Tapi bagaimana dengan istilahnya? logistik?

Istilah logistik datang dari logit, yang merupakan fungsi yang telah kita lihat:

$$
Di kiri( frac{p}{1-p} kanan)
$$

Kami baru saja menghitungnya dengan px dan 1-px. Ini adalah logit, juga disebut peluang masuk karena itu sama dengan logaritma peluang di mana p adalah probabilitas.

Kesimpulan

Dalam panduan ini, kami telah mempelajari salah satu algoritma klasifikasi pembelajaran mesin yang paling mendasar, yaitu regresi logistik.

Awalnya, kami menerapkan regresi logistik sebagai kotak hitam dengan perpustakaan pembelajaran mesin Scikit-Learn, dan kemudian kami memahaminya langkah demi langkah untuk mendapatkan alasan yang jelas dan dari mana istilah regresi dan logistik berasal.

Kami juga telah menjelajahi dan mempelajari data, memahami bahwa itu adalah salah satu bagian terpenting dari analisis ilmu data.

Dari sini, saya akan menyarankan Anda untuk bermain-main dengan regresi logistik multikelas, regresi logistik untuk lebih dari dua kelas – Anda dapat menerapkan algoritme regresi logistik yang sama untuk kumpulan data lain yang memiliki banyak kelas, dan menginterpretasikan hasilnya.

Saya juga menyarankan Anda untuk mempelajari L1 dan L2 regularisasi, mereka adalah cara untuk "menghukum" data yang lebih tinggi agar mendekati normal, menahan kompleksitas model, sehingga algoritme dapat memperoleh hasil yang lebih baik. Implementasi Scikit-Learn yang kami gunakan, sudah memiliki regularisasi L2 secara default. Hal lain yang perlu dilihat adalah perbedaannya pemecah, Seperti lbgs, yang mengoptimalkan kinerja algoritma regresi logistik.

Penting juga untuk melihat statistik pendekatan regresi logistik. Memiliki asumsi tentang perilaku data, dan tentang statistik lain yang harus dimiliki untuk menjamin hasil yang memuaskan, seperti:

• pengamatan bersifat independen;
• tidak ada multikolinearitas antar variabel penjelas;
• tidak ada outlier ekstrim;
• ada hubungan linier antara variabel penjelas dan logit dari variabel respon;
• ukuran sampel cukup besar.

Perhatikan berapa banyak dari asumsi tersebut yang telah tercakup dalam analisis dan perlakuan data kami.

Saya harap Anda terus mengeksplorasi apa yang ditawarkan regresi logistik dalam semua pendekatannya yang berbeda!