Veri Biliminde Ön İşleme (Bölüm 3): Sentezlenmiş Verilerin Ölçeklenmesi

Sentezlenmiş veriyi görselleştirme

Şimdi sentezlediğimiz veriyi düzlemde çizelim. Her eksen bir öngördürücü değişkeni, renk ise hedef değişkene ilişkin anahtarı gösteriyor:

%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('ggplot')
plt.figure(figsize=(20,5));
plt.subplot(1, 2, 1 );
plt.scatter(X[:,0] , X[:,1],  c = y, alpha = 0.7);
plt.subplot(1, 2, 2);
plt.hist(y)
plt.show()Altyapı:

Not: 2. grafikte tüm olası hedef değişkenlerin eşit biçimde temsil edildiğini görüyoruz. Bu durumda (ya da yaklaşık olarak eşit temsil edildiklerinde), y sınıfının dengeli olduğunu söyleriz.

Şimdi de özelliklerin (öngördürücü değişkenlerin) histogramlarını çizmek istiyorum:

import pandas as pd
df = pd.DataFrame(X)
pd.DataFrame.hist(df, figsize=(20,5));Altyapı:

Şimdi test ve eğitim setlerine ayıralım ve her iki seti de çizelim:

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
plt.figure(figsize=(20,5));
plt.subplot(1, 2, 1 );
plt.title('training set')
plt.scatter(X_train[:,0] , X_train[:,1],  c = y_train, alpha = 0.7);
plt.subplot(1, 2, 2);
plt.scatter(X_test[:,0] , X_test[:,1],  c = y_test, alpha = 0.7);
plt.title('test set')
plt.show()Altyapı:

Güzel görünüyor! Şimdi bir en Yakın K Komşu oylama sınıflandırıcısı başlatalım ve eğitim setimiz üzerinde eğitelim:

from sklearn import neighbors, linear_model
knn = neighbors.KNeighborsClassifier()
knn_model = knn.fit(X_train, y_train)Altyapı:

Modelimizi eğittiğimize göre, şimdi test setimize uygulayıp doğruluğu hesaplayabiliriz:

print('k-NN score for test set: %f' % knn_model.score(X_test, y_test))Altyapı:

`k-NN score for test set: 0.935000`Altyapı:

Ayrıca eğitim setimize yeniden uygulayıp doğruluğu hesaplayabiliriz. Eğitim setinde test setine kıyasla daha iyi performans bekleriz:

print('k-NN score for training set: %f' % knn_model.score(X_train, y_train))Altyapı:

`k-NN score for training set: 0.941875`Altyapı:

Tekrarlamakta fayda var: scikit-learn’de k-NN için varsayılan puanlama yöntemi doğruluktur. Başka pek çok metriğe bakmak için scikit-learn’ün sınıflandırma raporunu da kullanabiliriz:

from sklearn.metrics import classification_report
y_true, y_pred = y_test, knn_model.predict(X_test)
print(classification_report(y_true, y_pred))Altyapı:

                 precision    recall  f1-score   support
    
              0       0.87      0.90      0.88       106
              1       0.98      0.93      0.95       102
              2       0.90      0.92      0.91       100
              3       1.00      1.00      1.00        92
    
    avg / total       0.94      0.94      0.94       400Altyapı:

Şimdi ölçekleme ile

Şimdi öngördürücü değişkenleri ölçekleyip tekrar k-NN kullanacağım:

from sklearn.preprocessing import scale
Xs = scale(X)
Xs_train, Xs_test, y_train, y_test = train_test_split(Xs, y, test_size=0.2, random_state=42)
plt.figure(figsize=(20,5));
plt.subplot(1, 2, 1 );
plt.scatter(Xs_train[:,0] , Xs_train[:,1],  c = y_train, alpha = 0.7);
plt.title('scaled training set')
plt.subplot(1, 2, 2);
plt.scatter(Xs_test[:,0] , Xs_test[:,1],  c = y_test, alpha = 0.7);
plt.title('scaled test set')
plt.show()Altyapı:

knn_model_s = knn.fit(Xs_train, y_train)
print('k-NN score for test set: %f' % knn_model_s.score(Xs_test, y_test))Altyapı:

`k-NN score for test set: 0.935000`Altyapı:

Ölçekleme ile daha iyi performans göstermiyor! Bunun muhtemel nedeni, her iki özelliğin de zaten benzer aralıklarda olması. Değişkenlerin aralıkları çok farklı olduğunda ölçekleme yapmak gerçek anlam kazanır. Bunu göstermek için bir özellik daha ekleyeceğiz. Dahası, bu özellik hedef değişkenle hiçbir ilişkisi olmayacak: saf gürültü olacak.

Sinyale gürültü ekleme:

Ortalamasi 0 ve değişken standart sapması \(\sigma\) olan üçüncü bir Gauss gürültüsü değişkeni ekliyoruz. \(\sigma\)’yı gürültünün gücü olarak adlandıracağız ve gürültü güçlendikçe en Yakın K Komşuların performansının kötüleştiğini göreceğiz.

# Add noise column to predictor variables
ns = 10**(3) # Strength of noise term
newcol = np.transpose([ns*np.random.randn(n_samples)])
Xn = np.concatenate((X, newcol), axis = 1)Altyapı:

Şimdi 3B veriyi çizmek için mplot3d paketini kullanacağız:

from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure(figsize=(15,10));
ax = fig.add_subplot(111, projection='3d' , alpha = 0.5);
ax.scatter(Xn[:,0], Xn[:,1], Xn[:,2], c = y);Altyapı:

Şimdi modelimizin yeni verilerde nasıl performans gösterdiğine bakalım:

Xn_train, Xn_test, y_train, y_test = train_test_split(Xn, y, test_size=0.2, random_state=42)
knn = neighbors.KNeighborsClassifier()
knn_model = knn.fit(Xn_train, y_train)
print('k-NN score for test set: %f' % knn_model.score(Xn_test, y_test))Altyapı:

k-NN score for test set: 0.400000

Bu berbat bir model! Ölçekleyip performansa bakalım mı?

Xns = scale(Xn)
s = int(.2*n_samples)
Xns_train = Xns[s:]
y_train = y[s:]
Xns_test = Xns[:s]
y_test = y[:s]
knn = neighbors.KNeighborsClassifier()
knn_models = knn.fit(Xns_train, y_train)
print('k-NN score for test set: %f' % knn_models.score(Xns_test, y_test))Altyapı:

`k-NN score for test set: 0.907500`Altyapı:

Harika, verileri ölçekledikten sonra model, gürültü hiç eklenmemiş gibi neredeyse aynı performansı gösteriyor. Şimdi model performansını gürültü gücünün bir fonksiyonu olarak inceleyelim.

Gürültü güçlendikçe sorun büyüyor:

Şimdi gürültü gücünün model doğruluğunu nasıl etkilediğini göreceğiz. Aynı kodu birkaç kez kullanmamız gerekeceğinden, ana kısımları küçük bir fonksiyonda toparlayalım:

def accu( X, y):
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    knn = neighbors.KNeighborsClassifier()
    knn_model = knn.fit(X_train, y_train)
    return(knn_model.score(X_test, y_test))Altyapı:

noise = [10**i for i in np.arange(-1,6)]
A1 = np.zeros(len(noise))
A2 = np.zeros(len(noise))
count = 0
for ns in noise:
    newcol = np.transpose([ns*np.random.randn(n_samples)])
    Xn = np.concatenate((X, newcol), axis = 1)
    Xns = scale(Xn)
    A1[count] = accu( Xn, y)
    A2[count] = accu( Xns, y)
    count += 1Altyapı:

Şimdi doğruluğu gürültü gücünün bir fonksiyonu olarak çiziyoruz (log x eksenine dikkat):

plt.scatter( noise, A1 )
plt.plot( noise, A1, label = 'unscaled', linewidth = 2)
plt.scatter( noise, A2 , c = 'r')
plt.plot( noise, A2 , label = 'scaled', linewidth = 2)
plt.xscale('log')
plt.xlabel('Noise strength')
plt.ylabel('Accuracy')
plt.legend(loc=3);Altyapı:

Yukarıdaki şekilde görebileceğiniz gibi, rahatsızlık değişkenindeki gürültü arttıkça k-NN modeli için verinizi ölçeklemek daha da önemli hale geliyor! Aşağıda aynı işlemi lojistik regresyon için de yapma fırsatınız olacak. Sonuç olarak, veri bilimi hattında ön işlemenin, özellikle ölçekleme ve merkezleme biçiminde, ne kadar temel bir yere sahip olduğunu gördük ve bunu makine öğreniminin zorluklarına bütüncül bir yaklaşıma katkı sağlamak için yaptık. İlerideki yazılarda, sayısal veri dönüşümleri ve kategorik verilerin ön işlemesi gibi diğer ön işleme türlerine de değinmeyi umuyorum; bunların ikisi de her veri bilimcisinin araç kutusunun vazgeçilmez parçalarıdır.

Meraklı okur için egzersiz: Yukarıdaki sentezlenmiş veri kümelerine bir lojistik regresyon modeli uydurmayı deneyin ve model performansına bakın. Doğruluk, sırasıyla ölçeklenmiş ve ölçeklenmemiş veriler için gürültü gücünün bir fonksiyonu olarak nasıl değişiyor? Bunu aşağıdaki DataCamp Light bileşeniyle yapabilirsiniz! Gürültü miktarını değiştirmek için 10’un üssünü değiştirin (önce k-NN için yukarıda denediğim aralığı deneyin) ve özelliklerinizi ölçeklemek istiyorsanız sc = True olarak ayarlayın. Ayrıca Github’da DataCamp Light’a da göz atabilirsiniz!

	# Below, change the exponent of 10 to alter the amount of noise
	ns = 10**(3) # Strength of noise term
	# Set sc = True if you want to scale your features
	sc = False
    
	#Import packages
	import numpy as np
	from sklearn.cross_validation import train_test_split
	from sklearn import neighbors, linear_model
	from sklearn.preprocessing import scale
	from sklearn.datasets.samples_generator import make_blobs
    
	#Generate some data
	n_samples=2000
	X, y = make_blobs(n_samples, centers=4, n_features=2,
                  random_state=0)

	# Add noise column to predictor variables
	newcol = np.transpose([ns*np.random.randn(n_samples)])
	Xn = np.concatenate((X, newcol), axis = 1)

	#Scale if desired
	if sc == True:
		Xn = scale(Xn)
    
	#Train model and test after splitting
	Xn_train, Xn_test, y_train, y_test = train_test_split(Xn, y, test_size=0.2, random_state=42)
	lr = linear_model.LogisticRegression()
	lr_model = lr.fit(Xn_train, y_train)
	print('logistic regression score for test set: %f' % lr_model.score(Xn_test, y_test))

Sözlük

Denetimli öğrenme: Hedef değişkenin öngördürücü değişkenlerden çıkarılması görevi. Örneğin, hedef değişken olarak ‘kalp hastalığı varlığı’nın; ‘yaş’, ‘cinsiyet’ ve ‘sigara içme durumu’ gibi öngördürücü değişkenlerden çıkarılması.

Sınıflandırma görevi: Eğer hedef değişken kategorilerden oluşuyorsa (ör. ‘tıklama’ veya ‘tıklama yok’, ‘malign’ veya ‘benign’ tümör), bir denetimli öğrenme görevi sınıflandırma görevidir.

Regresyon görevi: Eğer hedef değişken sürekli değişen bir değişkense (ör. bir evin fiyatı) ya da ‘şarap kalite puanı’ gibi sıralı kategorik bir değişkense, bir denetimli öğrenme görevi regresyon görevidir.

en Yakın K Komşu: Bir veri noktasına, en yakın k komşusunun çoğunluk oyuyla belirlenen etiketin atandığı sınıflandırma görevleri için bir algoritma.

Ön işleme: Veri bilimcilerin, verilerini yapmak istedikleri işlem için daha uygun bir biçime getirmek amacıyla kullanacakları çok sayıda işlem. Örneğin, Twitter verilerinin duygu analizi yapılmadan önce, HTML etiketlerini ve boşlukları temizlemek, kısaltmaları açmak ve tweet’leri içerdiği sözcüklerin listelerine bölmek isteyebilirsiniz.

Merkezleme ve Ölçekleme: Her ikisi de sayısal verilerin (örneğin kategoriler veya dizeler yerine sayılardan oluşan veriler) ön işlemesinin biçimleridir; bir değişkeni merkezlemek, yeni değişkenin ortalaması 0 olacak şekilde her veri noktasından o değişkenin ortalamasını çıkarmaktır; bir değişkeni ölçeklemek ise verinin aralığını değiştirmek için her veri noktasını bir sabitle çarpmaktır. Önemleri ve örnekler için yazının gövdesine bakın.

Bu makale bir Jupyter defterinden üretildi. Defteri buradan indirebilirsiniz.