Python'da Lojistik Regresyon için Kesin Kılavuz

Giriş

Bazen karıştı doğrusal regresyon acemiler tarafından - terimi paylaşma nedeniyle gerileme - lojistik regresyon çok farklı doğrusal regresyon. Doğrusal regresyon 2, 2.45, 6.77 veya sürekli değerler, bir gerileme algoritması, lojistik regresyon olan 0 veya 1, 1 veya 2 veya 3 gibi değerleri tahmin eder. ayrık değerler, bir sınıflandırma algoritma. Evet, denir gerileme ama bir sınıflandırma algoritma. Birazdan bunun hakkında daha fazlası.

Bu nedenle, veri bilimi probleminiz sürekli değerler içeriyorsa, gerileme algoritma (doğrusal regresyon bunlardan biridir). Aksi takdirde, girdileri, ayrık değerleri veya sınıfları sınıflandırmayı içeriyorsa, bir sınıflandırma algoritma (lojistik regresyon bunlardan biridir).

Bu rehberde Python'da Scikit-Learn kütüphanesi ile lojistik regresyon gerçekleştireceğiz. Kelimenin nedenini de açıklayacağız. "gerileme" adında mevcuttur ve lojistik regresyon nasıl çalışır.

Bunu yapmak için önce sınıflandırılacak, görselleştirilecek ve ön işleme tabi tutulacak verileri yükleyeceğiz. Ardından, bu verileri anlayacak bir lojistik regresyon modeli oluşturacağız. Bu model daha sonra değerlendirilecek ve yeni girdiye dayalı değerleri tahmin etmek için kullanılacaktır.

Motivasyon

Çalıştığınız şirket bir Türk tarım çiftliği ile ortaklık yapmış. Bu ortaklık, kabak çekirdeği satmayı içerir. Kabak çekirdeği insan beslenmesi için çok önemlidir. İyi oranda karbonhidrat, yağ, protein, kalsiyum, potasyum, fosfor, magnezyum, demir ve çinko içerirler.

Veri bilimi ekibinde göreviniz, sadece verileri kullanarak kabak çekirdeği türleri arasındaki farkı anlatmaktır – veya sınıflandırma tohum türüne göre veriler.

Türk çiftliği iki kabak çekirdeği türü ile çalışır, biri denir çerçevelik ve diğer Ürgüp Sivrisi.

Kabak çekirdeklerini sınıflandırmak için ekibiniz 2021 makalesini takip etti. “Kabak çekirdeğinin (Cucurbita pepo L.) sınıflandırılmasında makine öğrenmesi yöntemlerinin kullanımı. Genetik Kaynaklar ve Mahsul Evrimi” Köklü, Sarıgil ve Özbek'ten - bu yazıda, fotoğraf çekmek ve görüntülerden tohum ölçümlerini çıkarmak için bir metodoloji var.

Kağıtta açıklanan işlemi tamamladıktan sonra, aşağıdaki ölçümler çıkarıldı:

• Semt - kabak çekirdeği sınırları içindeki piksel sayısı
• Çevre - kabak çekirdeğinin piksel cinsinden çevresi
• Ana Eksen Uzunluğu – ayrıca bir kabak çekirdeğinin piksel cinsinden çevresi
• Küçük Eksen Uzunluğu – kabak çekirdeğinin küçük eksen mesafesi
• acayiplik - kabak çekirdeğinin tuhaflığı
• Dışbükey Alan – Kabak çekirdeğinin oluşturduğu bölgedeki en küçük dışbükey kabuğun piksel sayısı
• kapsam – kabak çekirdeği alanının sınırlayıcı kutu piksellerine oranı
• Eşdeğer Çap – kabak çekirdeğinin alanının dörde bölünmesinin pi ile çarpımının karekökü
• yoğunluk - aynı çevredeki dairenin alanına göre kabak çekirdeğinin alanının oranı
• katılık – kabak çekirdeğinin dışbükey ve dışbükey durumu
• Yuvarlaklık – kabak çekirdeğinin ovalliği, kenarlarında bozulmalar göz önünde bulundurulmadan
• Boy Oranı - kabak çekirdeğinin en boy oranı

Bunlar, üzerinde çalışmanız gereken ölçümlerdir. Ölçümlerin yanı sıra, Sınıf iki tür kabak çekirdeği için etiket.

Tohumları sınıflandırmaya başlamak için verileri içe aktaralım ve ona bakmaya başlayalım.

Veri Kümesini Anlamak

Veri kümesini indirdikten sonra, onu kullanarak bir veri çerçevesi yapısına yükleyebiliriz. pandas kütüphane. Excel dosyası olduğu için kullanacağız. read_excel() yöntem:

import pandas as pd

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

Veriler yüklendikten sonra, ilk 5 satıra hızlıca göz atabiliriz. head() yöntem:

df.head() 

Bunun sonucu:

	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

Burada, ilgili sütunlarında tüm ölçümlere sahibiz, bizim ÖzelliklerVe ayrıca Sınıf sütun, bizim hedef, veri çerçevesindeki sonuncusu. kullanarak kaç tane ölçüm yaptığımızı görebiliriz. shape özellik:

df.shape 

Çıktı:

(2500, 13)

Şekil sonucu bize veri kümesinde 2500 giriş (veya satır) ve 13 sütun olduğunu söyler. Bir hedef sütun olduğunu bildiğimiz için - bu, 12 özellik sütunumuz olduğu anlamına gelir.

Artık hedef değişkeni, kabak çekirdeğini keşfedebiliriz. Class. Bu değişkeni tahmin edeceğimiz için, elimizde her bir kabak çekirdeğinden kaç tane örnek olduğunu görmek ilginç olacaktır. Genellikle, sınıflarımızdaki örnek sayısı arasındaki fark ne kadar küçük olursa, örneklemimiz o kadar dengeli olur ve tahminlerimiz o kadar iyi olur.

Bu inceleme, her bir tohum numunesi ile birlikte sayılarak yapılabilir. value_counts() yöntem:

df['Class'].value_counts() 

Yukarıdaki kod şunu gösterir:

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

1300 örnek olduğunu görebiliriz. çerçevelik tohum ve 1200 örnek Ürgüp Sivrisi tohum. Aralarındaki farkın 100 numune olduğuna dikkat edin, çok küçük bir fark, bu bizim için iyi ve numune sayısını yeniden dengelemeye gerek olmadığını gösteriyor.

Ayrıca özelliklerimizin tanımlayıcı istatistiklerine de bakalım. describe() Verilerin ne kadar iyi dağıtıldığını görme yöntemi. Ayrıca ortaya çıkan tabloyu transpoze edeceğiz T istatistikler arasında karşılaştırmayı kolaylaştırmak için:

df.describe().T

Ortaya çıkan tablo:

					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

Tabloya bakarak, karşılaştırırken ortalama ve standart sapma (std) sütunlarında, çoğu özelliğin standart sapmadan uzak bir ortalamaya sahip olduğu görülebilir. Bu, veri değerlerinin ortalama değer etrafında toplanmadığını, bunun etrafında daha fazla dağıldığını gösterir - başka bir deyişle, yüksek değişkenlik.

Ayrıca, baktığınızda asgari (min) Ve maksimum (max) sütunları, bazı özellikler gibi Area, ve Convex_Area, minimum ve maksimum değerler arasında büyük farklar var. Bu, bu sütunların çok küçük verilere ve ayrıca çok büyük veri değerlerine sahip olduğu anlamına gelir veya daha yüksek genlik veri değerleri arasında

Yüksek değişkenlik, yüksek genlik ve farklı ölçüm birimlerine sahip özellikler ile, verilerimizin çoğu, tüm özellikler için aynı ölçeğe sahip olmaktan veya tüm özellikler için aynı ölçeğe sahip olmaktan fayda sağlayacaktır. pullu. Veri ölçeklendirme, verileri ortalama etrafında ortalayacak ve varyansını azaltacaktır.

Bu senaryo muhtemelen verilerde aykırı değerler ve uç değerler olduğunu da gösterir. Yani, biraz sahip olmak en iyisidir aykırı değer tedavisi verileri ölçeklendirmenin yanı sıra.

Ağaç tabanlı algoritmalar gibi bazı makine öğrenme algoritmaları vardır. Rastgele Orman Sınıflandırması, yüksek veri varyansı, aykırı değerler ve aşırı değerlerden etkilenmez. Lojistik regresyon farklıdır, değerlerimizi kategorize eden bir fonksiyona dayanır ve o fonksiyonun parametreleri genel veri trendinin dışında kalan ve yüksek varyansa sahip değerlerden etkilenebilir.

Lojistik regresyonu uygulamaya başladığımızda birazdan daha fazla anlayacağız. Şimdilik verilerimizi keşfetmeye devam edebiliriz.

Verileri Görselleştirme

Şimdiye kadar, tanımlayıcı istatistiklerle, verilerin bazı niteliklerinin biraz soyut bir anlık görüntüsüne sahibiz. Bir diğer önemli adım, onu görselleştirmek ve yüksek varyans, genlik ve aykırı değerler hipotezimizi doğrulamaktır. Şimdiye kadar gözlemlediğimiz şeyin verilerde gösterilip gösterilmediğini görmek için bazı grafikler çizebiliriz.

Özelliklerin tahmin edilecek iki sınıfla nasıl ilişkili olduğunu görmek de ilginç. Bunu yapmak için, hadi içe aktaralım seaborn paketleyin ve kullanın pairplot her özellik dağılımına ve özellik başına her sınıf ayrımına bakmak için grafik:

import seaborn as sns


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

Çift grafiğine baktığımızda, çoğu durumda Çerçevelik sınıf noktalarından açıkça ayrılmıştır. Ürgüp Sivrisi sınıf. Ya bir sınıfın puanları diğerleri soldayken sağdadır ya da bazıları yukarıda, diğerleri aşağıdadır. Sınıfları ayırmak için bir tür eğri veya doğru kullansaydık, bu onları ayırmanın daha kolay olduğunu gösterir, eğer karıştırılsaydı sınıflandırma daha zor olurdu.

içinde Eccentricity, Compactness ve Aspect_Ration sütunlar, "yalıtılmış" veya genel veri eğiliminden sapan bazı noktalar - aykırı değerler de kolayca tespit edilir.

Grafiğin sol üst köşesinden sağ alt köşesine bakarken, veri dağılımlarının da sınıflarımıza göre renk kodlu olduğuna dikkat edin. Dağılım şekilleri ve her iki eğri arasındaki mesafe, bunların ne kadar ayrılabilir olduklarının diğer göstergeleridir - birbirinden ne kadar uzak olursa o kadar iyidir. Çoğu durumda, üst üste binmezler, bu da ayrılmalarının daha kolay olduğu anlamına gelir ve aynı zamanda görevimize katkıda bulunur.

Sırayla, tüm değişkenlerin kutu grafiklerini aşağıdakilerle de çizebiliriz: sns.boxplot() yöntem. Çoğu zaman, kutu grafiklerini yatay olarak yönlendirmek yardımcı olur, bu nedenle kutu grafiklerinin şekilleri dağıtım şekilleri ile aynıdır. orient argüman:

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

Yukarıdaki şemada, dikkat edin Area ve Convex_Area diğer sütunların büyüklüklerine kıyasla o kadar yüksek bir büyüklüğe sahipler ki, diğer kutu grafiklerini eziyorlar. Tüm kutu grafiklerine bakabilmek için, özellikleri ölçekleyebilir ve tekrar çizebiliriz.

Bunu yapmadan önce şunu anlayalım ki, örneğin diğer değerlerle yakından ilişkili özelliklerin değerleri varsa – örneğin diğer özellik değerleri büyüdükçe daha da büyüyen değerler varsa, pozitif korelasyon; veya bunun tersini yapan değerler varsa küçülürken diğer değerler küçülür, Negatif korelasyon.

Buna bakmak önemlidir, çünkü verilerde güçlü ilişkilere sahip olmak, bazı sütunların diğer sütunlardan türetildiği veya modelimize benzer bir anlama sahip olduğu anlamına gelebilir. Bu olduğunda, model sonuçları fazla tahmin edilebilir ve gerçeğe daha yakın sonuçlar isteriz. Güçlü korelasyonlar varsa, bu aynı zamanda özellik sayısını azaltabileceğimiz ve modeli daha fazla hale getirmek için daha az sütun kullanabileceğimiz anlamına gelir. cimri.

Değişkenler arasındaki korelasyonlara bir göz atalım ve ardından verileri ön işlemeye geçebiliriz. ile korelasyonları hesaplayacağız. corr() Yöntem ve bunları Seaborn's ile görselleştirin heatmap(). Isı haritası standart boyutu küçük olma eğilimindedir, bu nedenle içe aktaracağız matplotlib (Seaborn'un üzerine inşa edildiği genel görselleştirme motoru/kütüphanesi) ve boyutu şununla değiştirin: figsize:

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

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

Bu ısı haritasında 1 veya -1'e yakın değerler dikkat etmemiz gereken değerlerdir. İlk durum, yüksek bir pozitif korelasyonu ve ikincisi, yüksek bir negatif korelasyonu gösterir. 0.8 veya -0.8'in üzerinde değilse her iki değer de lojistik regresyon modelimiz için faydalı olacaktır.

Aşağıdakilerden biri gibi yüksek korelasyonlar olduğunda 0.99 arasında Aspec_Ration ve Compactness, bu yalnızca kullanmayı seçebileceğimiz anlamına gelir Aspec_Ration veya sadece Compactness, her ikisi yerine (neredeyse eşit olduklarından öngörücüler birbirinden). Aynı şey için geçerli Eccentricity ve Compactness Birlikte -0.98 korelasyon, için Area ve Perimeter Birlikte 0.94 korelasyon ve diğer bazı sütunlar.

Verileri Ön İşleme

Verileri bir süredir araştırdığımız için ön işlemeye başlayabiliriz. Şimdilik sınıf tahmini için tüm özellikleri kullanalım. Bir ilk model, bir taban çizgisi elde ettikten sonra, yüksek düzeyde ilişkili sütunlardan bazılarını kaldırabilir ve bunu taban çizgisiyle karşılaştırabiliriz.

Özellik sütunları bizim olacak X data ve sınıf sütunu, bizim y hedef veri:

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

Kategorik Unsurları Sayısal Unsurlara Dönüştürme

Bizimle ilgili Class sütun – değerleri sayı değildir, bu da onları dönüştürmemiz gerektiği anlamına gelir. Bu dönüşümü yapmanın birçok yolu vardır; burada, kullanacağız replace() yöntem ve değiştir Çerçevelik için 0 ve Ürgüp Sivrisi için 1.

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

Haritalamayı aklınızda bulundurun! Modelinizden sonuçları okurken, bunları en azından zihninizde veya diğer kullanıcılar için sınıf adına geri dönüştürmek isteyeceksiniz.

Verileri Tren ve Test Setlerine Bölme

Keşfimizde, özelliklerin ölçeklendirilmesi gerektiğini not ettik. Ölçeklendirmeyi şimdi veya otomatik bir şekilde yapsaydık, değerleri tüm ile ölçeklendirirdik. X ve y. Bu durumda, tanıtacağız veri sızıntısı, yakında olacak test setinin değerleri ölçeklendirmeyi etkileyeceğinden. Veri sızıntısı, tekrarlanamayan sonuçların ve ML modellerinin yanıltıcı yüksek performansının yaygın bir nedenidir.

Ölçeklendirmeyi düşünmek, önce bölmemiz gerektiğini gösteriyor X ve y verileri daha sonra tren ve test setlerine ve ardından uygun eğitim setinde bir ölçekleyici ve dönüştürmek hem tren hem de test setleri (test seti bunu yapan ölçekleyiciyi etkilemeden). Bunun için Scikit-Learn's'i kullanacağız. train_test_split() yöntem:

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)

ayar test_size=.25 verilerin %25'ini test için ve %75'ini eğitim için kullanmamızı sağlıyor. Varsayılan bölünme olduğunda bu atlanabilir, ancak pythonic kod yazmanın yolu, “açık olmanın, örtük olmaktan daha iyi olduğunu” önerir.

Verileri tren ve test setlerine böldükten sonra, her sette kaç kayıt olduğuna bakmak iyi bir uygulamadır. Bu ile yapılabilir shape özellik:

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

Bu şunu görüntüler:

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

Bölünmeden sonra eğitim için 1875 ve test için 625 kaydımız olduğunu görebiliriz.

Ölçekleme Verileri

Tren ve test setlerimizi hazır hale getirdikten sonra Scikit-Learn ile verileri ölçeklendirmeye geçebiliriz. StandardScaler nesne (veya kitaplık tarafından sağlanan diğer ölçekleyiciler). Sızıntıyı önlemek için, ölçekleyici, X_train veriler ve tren değerleri daha sonra hem treni hem de test verilerini ölçeklemek veya dönüştürmek için kullanılır:

from sklearn.preprocessing import StandardScaler

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

Genellikle arayacağınız için:

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

İlk iki satır tekil olarak daraltılabilir. fit_transform() Ölçekleyiciyi sete sığdıran ve tek seferde dönüştüren çağrı. Artık verileri ölçeklendirdikten sonra farkı görmek için kutu grafiği grafiklerini çoğaltabiliriz.

Ölçeklendirmenin sütun adlarını kaldırdığını göz önünde bulundurarak, çizimden önce, görselleştirmeyi kolaylaştırmak için tren verilerini tekrar sütun adlarıyla bir veri çerçevesinde düzenleyebiliriz:

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

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

Sonunda tüm kutu çizimlerimizi görebiliriz! Hepsinin aykırı değerlere sahip olduğuna ve normalden daha uzak bir dağılım sunan özelliklerin (eğrileri sola veya sağa eğik olan), örneğin Solidity, Extent, Aspect_Ration, ve Compactedness, daha yüksek korelasyona sahip olanlarla aynıdır.

IQR Yöntemi ile Aykırı Değerleri Kaldırma

Lojistik regresyonun aykırı değerlerden etkilenebileceğini zaten biliyoruz. Onları tedavi etmenin yollarından biri, adı verilen bir yöntem kullanmaktır. Çeyrekler arası aralık or I.Q.R.. IQR yönteminin ilk adımı, tren verilerimizi çeyrekler adı verilen dört parçaya bölmektir. İlk çeyrek, Q1, verilerin %25'ini oluşturur, ikincisi, Q2, %50'ye kadar, üçüncü, Q3, %75'e kadar ve sonuncusu, Q4, %100'e kadar. Kutu grafiğindeki kutular, IQR yöntemiyle tanımlanır ve bunun görsel bir temsilidir.

Yatay bir kutu grafiği göz önüne alındığında, soldaki dikey çizgi verilerin %25'ini, ortadaki dikey çizgi verilerin %50'sini (veya medyanı) ve sağdaki son dikey çizgi verilerin %75'ini gösterir. . Dikey çizgilerle tanımlanan her iki karenin boyutu ne kadar eşitse - veya ortanca dikey çizgi ne kadar ortadaysa - verilerimizin normal dağılıma daha yakın veya daha az çarpık olduğu anlamına gelir, bu da analizimiz için yararlıdır.

IQR kutusunun yanı sıra her iki yanında yatay çizgiler bulunmaktadır. Bu çizgiler, tarafından tanımlanan minimum ve maksimum dağılım değerlerini işaretler.

$$
Minimum = Q1 – 1.5*IQR
$$

ve

$$
Maksimum = Q3 + 1.5*IQR
$$

IQR tam olarak Q3 ve Q1 (veya Q3 – Q1) arasındaki farktır ve verilerin en merkezi noktasıdır. Bu nedenle, IQR'yi bulurken, veri uçlarında veya minimum ve maksimum noktalarda aykırı değerleri filtreliyoruz. Kutu grafikleri bize IQR yönteminin sonucunun ne olacağına dair bir fikir verir.

Pandaları kullanabiliriz quantile() niceliklerimizi bulma yöntemi ve iqr itibaren scipy.stats Her sütun için çeyrekler arası veri aralığını elde etmek için paket:

from scipy.stats import iqr

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

IQR = X_train.apply(iqr)

Şimdi Q1, Q3 ve IQR'ye sahibiz, medyana daha yakın değerleri filtreleyebiliriz:

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]

Eğitim satırlarımızı filtreledikten sonra, kaç tanesinin hala veride olduğunu görebiliriz. shape:

X_train.shape

Bunun sonucu:

(1714, 12)

Filtrelemeden sonra satır sayısının 1875'ten 1714'e çıktığını görebiliriz. Bu, 161 satırın aykırı değerler veya verilerin %8.5'ini içerdiği anlamına gelir.

Aykırı değerleri çıkardıktan sonra, verileri modele dahil etmeye neredeyse hazırız. Model uydurma için tren verilerini kullanacağız. X_train filtrelendi, ama ne olacak? y_train?

y_train.shape

Bu çıktılar:

(1875,)

Dikkat edin y_train hala 1875 satır var. sayısını eşleştirmemiz gerekiyor. y_train sayısı kadar satır X_train satırlar ve sadece keyfi olarak değil. Kaldırdığımız kabak çekirdeği örneklerinin y-değerlerini çıkarmamız gerekiyor. y_train Ayarlamak. filtrelenmiş X_train stilin orijinal endeksleri var ve endekste aykırı değerleri kaldırdığımız boşluklar var! Daha sonra dizinin indeksini kullanabiliriz. X_train İlgili değerleri aramak için DataFrame y_train:

y_train = y_train.iloc[X_train.index]

Bunu yaptıktan sonra şuna bakabiliriz. y_train tekrar şekil:

y_train.shape

Hangi çıktılar:

(1714,)

Şimdi, y_train ayrıca 1714 satıra sahiptir ve bunlar X_train satırlar. Sonunda lojistik regresyon modelimizi oluşturmaya hazırız!

Lojistik Regresyon Modelinin Uygulanması

Zor kısım tamamlandı! ML modellerinin uygulamasını yalnızca birkaç satıra indirgeyen Scikit-Learn gibi kitaplıkları kullanmak söz konusu olduğunda, ön işleme genellikle model geliştirmeden daha zordur.

İlk olarak, ithal ediyoruz LogisticRegression sınıflandırın ve somutlaştırın, bir LogisticRegression nesne:

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

İkinci olarak, tren verilerimizi logreg ile model fit() yöntemi ile test verilerimizi tahmin edin ve predict() yöntemi, sonuçların saklanması y_pred:

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

Modelimizle zaten tahminler yaptık! İlk 3 satıra bakalım X_train hangi verileri kullandığımızı görmek için:

X_train[:3]

Yukarıdaki kod çıktı:

       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

Ve ilk 3 tahminde y_pred sonuçları görmek için:

y_pred[:3] 

Bunun sonucu:

array([0, 0, 0])

Bu üç sıra için tahminlerimiz, birinci sınıfın tohumları oldukları yönündeydi. Çerçevelik.

İle lojistik regresyongibi son sınıfı tahmin etmek yerine 0, satırın ilgili olma olasılığını da tahmin edebiliriz. 0 sınıf. Lojistik regresyon verileri sınıflandırdığında gerçekte olan budur ve predict() yöntem daha sonra bu tahmini "zor" bir sınıf döndürmek için bir eşikten geçirir. Bir sınıfa ait olma olasılığını tahmin etmek için, predict_proba() kullanıldı:

y_pred_proba = logreg.predict_proba(X_test)

Ayrıca y olasılık tahminlerinin ilk 3 değerine bir göz atalım:

y_pred_proba[:3] 

Hangi çıktılar:

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

Şimdi, üç sıfır yerine, her sınıf için bir sütunumuz var. ile başlayan soldaki sütunda 0.54726628, sınıfa ait verilerin olasılıkları 0; ve sağ sütunda, ile başlayan 0.45273372, sınıfa ait olma olasılığı 1.

Tahmini çıktının nasıl yapıldığı hakkında daha fazla bilgi var. aslında değildi 0, ancak %55 sınıf şansı 0, ve %45 sınıf şansı 1. Bu, ilk üç X_test sınıfla ilgili veri noktaları 0, %86 olasılıkla yalnızca üçüncü veri noktasıyla ilgili olarak gerçekten nettir ve ilk iki veri noktası için çok fazla değildir.

ML yöntemlerini kullanarak bulguları iletirken - genellikle en iyisi yumuşak bir sınıf ve ilişkili olasılığı şu şekilde döndürmektir: "kendinden emin" bu sınıflandırmanın

Modelin derinliklerine indiğimizde bunun nasıl hesaplandığı hakkında daha fazla konuşacağız. Bu sırada bir sonraki adıma geçebiliriz.

Modelin Sınıflandırma Raporları ile Değerlendirilmesi

Üçüncü adım, modelin test verileri üzerinde nasıl performans gösterdiğini görmektir. Scikit-Learn'i içe aktarabiliriz classification_report() ve bizim geçmek y_test ve y_pred argümanlar olarak. Bundan sonra, yanıtını yazdırabiliriz.

Sınıflandırma raporu, aşağıdakiler gibi en çok kullanılan sınıflandırma metriklerini içerir: hassas, geri çağırmak, f1-skoru, ve doğruluk.

1. Hassas: sınıflandırıcımız tarafından hangi doğru tahmin değerlerinin doğru kabul edildiğini anlamak için. Kesinlik, bu gerçek pozitif değerleri, pozitif olarak tahmin edilen herhangi bir şeye böler:

$$
kesinlik = frac{metin{doğru pozitif}}{metin{doğru pozitif} + metin{yanlış pozitif}}
$$

2. Geri çağırmak: sınıflandırıcımız tarafından gerçek pozitiflerden kaçının tanımlandığını anlamak için. Geri çağırma, gerçek pozitiflerin pozitif olarak tahmin edilmesi gereken herhangi bir şeye bölünmesiyle hesaplanır:

$$
hatırlama = frac{metin{gerçek pozitif}}{metin{gerçek pozitif} + metin{yanlış negatif}}
$$

3. F1 skoru: dengeli mi yoksa harmonik ortalama kesinlik ve hatırlama. En düşük değer 0 ve en yüksek değer 1'dir. f1-score 1'e eşittir, bu, tüm sınıfların doğru tahmin edildiği anlamına gelir - bu, gerçek verilerle elde edilmesi çok zor bir puandır:

$$
metin{f1-skor} = 2* frak{metin{kesinlik} * metin{hatırlama}}{metin{kesinlik} + metin{hatırlatma}}
$$

4. doğruluk: sınıflandırıcımızın kaç tahminin doğru çıktığını açıklar. En düşük doğruluk değeri 0 ve en yüksek doğruluk değeri 1'dir. Bu değer, bir yüzde elde etmek için genellikle 100 ile çarpılır:

$$
doğruluk = frac{metin{doğru tahmin sayısı}}{metin{toplam tahmin sayısı}}
$$

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

Daha sonra sınıflandırma raporu çıktısına bakabiliriz:

				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

Bu bizim sonucumuz. dikkat edin precision, recall, f1-score, ve accuracy metriklerin hepsi çok yüksek, %80'in üzerinde, ki bu idealdir - ancak bu sonuçlar muhtemelen yüksek korelasyonlardan etkilenmiştir ve uzun vadede sürdürülmeyecektir.

Modelin doğruluğu %86, yani sınıflandırmayı %14 oranında yanlış yapıyor. Bu genel bilgiye sahibiz, ancak sınıfın sınıflandırılmasıyla ilgili %14'lük hataların olup olmadığını bilmek ilginç olurdu. 0 veya sınıf 1. Hangi sınıfların hangi frekansta yanlış tanımlandığını belirlemek için - bir hesaplayabilir ve çizebiliriz. karışıklık matrisi modelimizin tahminlerinden.

Modeli Bir Karışıklık Matrisi ile Değerlendirmek

Hesaplayalım ve sonra karışıklık matrisini çizelim. Bunu yaptıktan sonra, her bir parçasını anlayabiliriz. Karışıklık matrisini çizmek için Scikit-Learn kullanacağız confusion_matrix()'den ithal edeceğimiz metrics modülü.

Karışıklık matrisini bir Seaborn kullanarak görselleştirmek daha kolaydır heatmap(). Bu nedenle, onu oluşturduktan sonra, ısı haritası için bir argüman olarak karışıklık matrisimizi ileteceğiz:

from sklearn.metrics import confusion_matrix

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

5. Karışıklık Matrisi: matris, modelin her bir sınıf için doğru veya yanlış kaç örnek aldığını gösterir. Doğru ve doğru tahmin edilen değerlere denir. gerçek pozitiflerve pozitif olarak tahmin edilen ancak pozitif olmayanlara denir. yanlış pozitif. Aynı isimlendirme gerçek negatifler ve yanlış negatifler negatif değerler için kullanılır;

Karışıklık matrisi grafiğine bakarak, sahip olduğumuzu görebiliriz. 287 olan değerler 0 ve tahmin edildiği gibi 0 - veya gerçek pozitifler sınıf için 0 (Çerçevelik tohumları). Ayrıca buna sahibiz 250 sınıf için gerçek pozitifler 1 (Ürgüp Sivrisi tohumları). Gerçek pozitifler her zaman sol üstten sağ alta doğru giden matris köşegeninde bulunur.

Ayrıca var 29 olması gereken değerler 0, ancak tahmin edildiği gibi 1 (yanlış pozitif) Ve 59 olan değerler 1 ve tahmin edildiği gibi 0 (yanlış negatifler). Bu sayılarla, modelin en çok yaptığı hatanın yanlış negatifleri tahmin etmesi olduğunu anlayabiliriz. Dolayısıyla bir Ürgüp Sivrisi tohumunu çoğunlukla Çerçevelik tohumu olarak sınıflandırmakla sonuçlanabilir.

Bu tür bir hata, sınıfın %81'inin geri çağrılmasıyla da açıklanmaktadır. 1. Metriklerin bağlı olduğuna dikkat edin. Ve geri çağırmadaki fark, Ürgüp Sivrisi sınıfından 100 tane daha az numuneye sahip olmaktan kaynaklanıyor. Bu, diğer sınıftan sadece birkaç numunenin daha az olmasının sonuçlarından biridir. Geri çağırmayı daha da iyileştirmek için sınıf ağırlıklarıyla deney yapabilir veya daha fazla Ürgüp Sivrisi örneği kullanabilirsiniz.

Şimdiye kadar, veri bilimi geleneksel adımlarının çoğunu gerçekleştirdik ve lojistik regresyon modelini bir kara kutu olarak kullandık.

Şimdi kara kutuyu açmanın ve içine bakmanın, lojistik regresyonun nasıl çalıştığını anlamak için daha derine inmenin zamanı geldi.

Lojistik Regresyonun Gerçekten Nasıl Çalıştığına Daha Derine İnmek

The gerileme kelimesi tesadüfen orada değil, lojistik regresyonun ne yaptığını anlamak için kardeşi lineer regresyonun verilere ne yaptığını hatırlayabiliriz. Doğrusal regresyon formülü şuydu:

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

hangi b₀ regresyon kesişimiydi, b¹ katsayı ve x¹ veri.

Bu denklem, yeni değerleri tahmin etmek için kullanılan düz bir çizgiyle sonuçlandı. Girişi hatırlatarak, şimdiki fark, yeni değerleri değil, bir sınıfı tahmin etmemizdir. Yani bu düz çizginin değişmesi gerekiyor. Lojistik regresyon ile doğrusal olmayan bir durum ortaya koyuyoruz ve tahmin artık bir çizgi yerine bir eğri kullanılarak yapılıyor:

Doğrusal regresyon çizgisi devam ederken ve sürekli sonsuz değerlerden oluşurken, lojistik regresyon eğrisinin ortadan bölünebileceğini ve 0 ve 1 değerlerinde aşırı uçlara sahip olduğunu gözlemleyin. Verileri sınıflandırmasının nedeni bu “S” şeklidir – en üst uca yakın olan veya düşen noktalar sınıf 1'e, alt kadranda veya 0'a yakın olan noktalar ise sınıf 0'a aittir. “S” 0 ile 1 arasındaki orta noktadır, 0.5 – lojistik regresyon noktalarının eşiğidir.

Lojistik ve doğrusal regresyon arasındaki görsel farkı zaten anlıyoruz, peki ya formül? Lojistik regresyon formülü aşağıdaki gibidir:

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

Şu şekilde de yazılabilir:

$$
y_{olasılık} = frac{1}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}
$$

Hatta şöyle yazılabilir:

$$
y_{prob} = 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 + lddotlar + b_n * x_n)}}
$$

Yukarıdaki denklemde, değeri yerine girdi olasılığına sahibiz. Payında 1'e sahiptir, bu nedenle 0 ile 1 arasında bir değere ve 1 artı paydasında bir değere neden olabilir, böylece değeri 1 ve bir şeydir - bu, tüm kesir sonucunun 1'den büyük olamayacağı anlamına gelir. .

Ve paydadaki değer nedir? Bu e, lineer regresyonun gücüne yükseltilmiş doğal logaritmanın (yaklaşık 2.718282) tabanı:

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

Bunu yazmanın başka bir yolu şöyle olurdu:

$$
Solda( frac{p}{1-p} sağda) = {(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

Bu son denklemde, ln doğal logaritma (e tabanı) ve p olasılıktır, dolayısıyla sonucun olasılığının logaritması lineer regresyon sonucuyla aynıdır.

Başka bir deyişle, lineer regresyon sonucu ve doğal logaritma ile, tasarlanmış bir sınıfa ait olan veya olmayan bir girdinin olasılığına ulaşabiliriz.

Tüm lojistik regresyon türetme süreci aşağıdaki gibidir:

$$
p{X} = parça{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 + ldots + b_n * x_n)}}
$$

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

$$
p + p*e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + lddotlar + b_n * x_n)} = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + lddotlar + 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 + ldots + b_n * x_n)}
$$

$$
Solda( frac{p}{1-p} sağda) = (b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)
$$

Bu, lojistik regresyon modelinin de katsayılara ve bir kesişme değerine sahip olduğu anlamına gelir. Çünkü doğrusal bir regresyon kullanır ve ona doğal logaritma ile doğrusal olmayan bir bileşen ekler (e).

Modelimizin katsayılarının ve kesişim değerlerinin değerlerini doğrusal regresyon için yaptığımız gibi görebiliriz. coef_ ve intercept_ özellikleri:

logreg.coef_

12 özelliğin her birinin katsayılarını gösteren:

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_

Sonuç olarak:

array([0.08735782])

Katsayılar ve kesişme değerleri ile verilerimizin tahmin edilen olasılıklarını hesaplayabiliriz. ilkini alalım X_test Örnek olarak tekrar değerler:

X_test[:1]

Bu, ilk satırını döndürür X_test NumPy dizisi olarak:

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]])

İlk denklemi takiben:

$$
p{X} = parça{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 + ldots + b_n * x_n)}}
$$

Python'da elimizde:

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

Bunun sonucu:

0.45273372469369133

tekrar bakarsak predict_proba ilk sonucu X_test satır, biz var:

logreg.predict_proba(X_test[:1])

Bu, orijinal lojistik regresyon denkleminin bize sınıfla ilgili girdi olasılığını verdiği anlamına gelir. 1, sınıf için hangi olasılığın olduğunu bulmak için 0, basitçe şunları yapabiliriz:

1 - px

Dikkat edin, her ikisi de px ve 1-px ile özdeş predict_proba Sonuçlar. Lojistik regresyon bu şekilde hesaplanır ve neden gerileme adının bir parçasıdır. Ama terim ne olacak lojistik?

Süreli lojistik gelen lojit, bu daha önce gördüğümüz bir işlevdir:

$$
Solda( frac{p}{1-p} sağda)
$$

Az önce onunla hesapladık px ve 1-px. Bu logit, aynı zamanda log-oran oranların logaritmasına eşit olduğu için p bir olasılıktır.

Sonuç

Bu kılavuzda, en temel makine öğrenimi sınıflandırma algoritmalarından birini inceledik, yani lojistik regresyon.

Başlangıçta lojistik regresyonu Scikit-Learn'in makine öğrenimi kitaplığıyla bir kara kutu olarak uyguladık ve daha sonra regresyon ve lojistik terimlerinin neden ve nereden geldiğini net bir şekilde anlamak için adım adım anladık.

Ayrıca, bir veri bilimi analizinin en önemli bölümlerinden biri olduğunu anlayarak verileri araştırdık ve inceledik.

Buradan oynamanı tavsiye ederim çok sınıflı lojistik regresyon, ikiden fazla sınıf için lojistik regresyon – aynı lojistik regresyon algoritmasını birden fazla sınıfı olan diğer veri kümeleri için uygulayabilir ve sonuçları yorumlayabilirsiniz.

Ayrıca L1 ve L2'yi incelemenizi tavsiye ederim. düzenlileştirmeler, daha yüksek verileri normale yakın hale getirmek için “cezalandırmanın” bir yoludur, modelin karmaşıklığını dışarıda tutar, böylece algoritma daha iyi bir sonuca ulaşabilir. Kullandığımız Scikit-Learn uygulaması, varsayılan olarak zaten L2 düzenlemesine sahiptir. Bakılması gereken başka bir şey, farklı çözücülerGibi lbgslojistik regresyon algoritması performansını optimize eden.

Şuraya bir göz atmak da önemlidir. istatistiksel lojistik regresyon yaklaşımı. sahip varsayımlar Verilerin davranışı ve tatmin edici sonuçları garanti etmek için tutulması gereken diğer istatistikler hakkında, örneğin:

• gözlemler bağımsızdır;
• açıklayıcı değişkenler arasında çoklu bağlantı yoktur;
• aşırı uç değerler yoktur;
• açıklayıcı değişkenler ile yanıt değişkeninin logiti arasında doğrusal bir ilişki vardır;
• örneklem büyüklüğü yeterince büyüktür.

Bu varsayımların kaç tanesinin analizimizde ve verileri ele alırken kapsandığına dikkat edin.

Umarım lojistik regresyonun tüm farklı yaklaşımlarında neler sunabileceğini keşfetmeye devam edersiniz!