Python’da Temel Bileşen Analizi (PCA) Nasıl Yapılır

Temel bileşen analizi (PCA), yüksek boyutlu bir uzaydan veriyi daha düşük boyutlu bir alt uzaya projekte ederek bilgi çıkarmak için kullanılabilen doğrusal bir boyut indirgeme tekniğidir. Lineer cebir diline aşinaysanız, PCA’nın verideki en yüksek varyans yönlerini belirlemek için kovaryans matrisinin özvektörlerini bulmak olduğunu da söyleyebilirsiniz.

PCA hakkında dikkat edilmesi gereken önemli bir nokta, denetimsiz bir boyut indirgeme tekniği olmasıdır; yani, herhangi bir denetim (veya etiket) olmadan, aralarındaki korelasyona dayanarak benzer veri noktalarını kümelendirebilirsiniz.

Not: Özellikler, Boyutlar ve Değişkenler aynı şeyi ifade eder. Bu terimlerin birbirinin yerine kullanıldığını göreceksiniz.

PCA’yı Nerelerde Uygulayabilirsiniz?

• Veri Görselleştirme: Günümüzde veriyle ilgili herhangi bir problem üzerinde çalışırken asıl zorluk, verinin hacmi ve veriyi tanımlayan değişkenlerin/özelliklerin sayısıdır. Verinin kilit rol oynadığı bir sorunu çözmek için değişkenlerin nasıl korele olduğunun bulunması veya bazı değişkenlerin dağılımının anlaşılması gibi kapsamlı veri keşfine ihtiyaç vardır. Veri dağıldığı boyutların veya değişkenlerin sayısı fazla olduğunda görselleştirme zor ve neredeyse imkânsız hale gelebilir.

  Dolayısıyla PCA, veriyi daha düşük bir boyuta projekte ettiği için bunu sizin yerinize yapabilir; böylece veriyi çıplak gözle 2B veya 3B uzayda görselleştirmenize olanak tanır.

• Bir Makine Öğrenimi (ML) Algoritmasını Hızlandırma: PCA’nın temel fikri boyut indirgeme olduğundan, verinizde çok sayıda özellik bulunduğu ve ML algoritmanızın öğrenmesi çok yavaş olduğu durumlarda, modelinizin eğitim ve test süresini hızlandırmak için bundan yararlanabilirsiniz.

Özet düzeyinde, çok sayıda özelliğe sahip bir veri kümesi alır ve bu veri kümesini orijinal özelliklerden birkaç Principal Components seçerek basitleştirirsiniz.

Temel Bileşen (Principal Component) Nedir?

Temel bileşenler PCA’nın anahtarıdır; verinizin kaputunun altındakini temsil ederler. Basitçe söylemek gerekirse, veri yüksek boyutlu bir uzaydan daha düşük boyuta (örneğin üç boyuta) projekte edildiğinde, bu üç boyut verinizin varyansının (bilgisinin) çoğunu yakalayan üç temel bileşenden başka bir şey değildir.

Temel bileşenlerin hem yönü hem büyüklüğü vardır. Yön, verinin en çok hangi temel eksenler boyunca yayıldığını ya da en fazla varyansa sahip olduğunu gösterir; büyüklük ise o temel bileşenin, veri o eksene projekte edildiğinde yakaladığı varyans miktarını ifade eder. Temel bileşenler düz bir doğrudur ve birinci temel bileşen verideki en büyük varyansı tutar. Her bir sonraki temel bileşen, bir öncekine diktir ve daha az varyansa sahiptir. Bu şekilde, y örnek üzerinde x korele değişkenden oluşan bir küme için, aynı y örnek üzerinde u adet ilişkisiz temel bileşen elde edersiniz.

Orijinal özelliklerden ilişkisiz temel bileşenler elde etmenizin nedeni, korele özelliklerin aynı temel bileşene katkıda bulunmasıdır; böylece orijinal veri özellikleri, her biri farklı miktarlarda değişkenliğe sahip, farklı korele özellik kümelerini temsil eden ilişkisiz temel bileşenlere indirgenir. Her temel bileşen, veriden yakalanan toplam değişkenliğin bir yüzdesini temsil eder.

Bugünkü eğitimde, PCA’yı veri görselleştirme yoluyla içgörü elde etmek ve makine öğrenimi algoritmamızı hızlandırmak amacıyla uygulayacağız. Bu iki görevi başarmak için iki ünlü veri kümesini kullanacaksınız: Breast Cancer ve CIFAR-10. İlki sayısal bir veri kümesidir; ikincisi bir görüntü veri setidir. 

Veriyi Anlamak

Veriyi yüklemeye geçmeden önce, üzerinde çalışacağınız veriyi anlamak ve incelemek faydalıdır!

Breast Cancer

Breast Cancer veri kümesi, iki sınıftan oluşan ve her bir sınıfın bir hastada meme kanseri olup olmadığını belirttiği, reel değerli çok değişkenli bir veridir. İki kategori: malign ve benign.

Malign sınıfta 212 örnek, benign sınıfta ise 357 örnek vardır.

Tüm sınıflar arasında paylaşılan 30 özelliği vardır: yarıçap, doku, çevre, alan, pürüzsüzlük, fraktal boyut vb.

Breast cancer veri setini buradan indirebilir ya da daha kolay bir yöntem olarak sklearn kütüphanesinin yardımıyla yükleyebilirsiniz.

CIFAR - 10

CIFAR-10 (Canadian Institute For Advanced Research) veri kümesi, her biri 32x32x3 renkli görüntü olan 60000 görüntüden oluşur; on sınıf ve sınıf başına 6000 görüntü vardır.

Veri kümesi 50000 eğitim ve 10000 test görüntüsünden oluşur.

Veri kümesindeki sınıflar: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, truck.

CIFAR veri setini buradan indirebilir veya Keras gibi bir derin öğrenme kütüphanesiyle anında yükleyebilirsiniz.

PCA ile Veri Keşfi

Şimdi Breast Cancer ve CIFAR-10 veri kümelerini yükleyip analiz edeceksiniz. Bu noktada her iki veri kümesinin de boyutsallığı hakkında bir fikriniz var.

Hadi, iki veri kümesini de hızlıca keşfedelim.

Breast cancer veri keşfi

Önce Breast Cancer veri kümesini keşfedelim.

sklearn’in datasets modülünü kullanacak ve buradan Breast Cancer veri kümesini içe aktaracaksınız.

from sklearn.datasets import load_breast_cancer

load_breast_cancer hem etiketleri hem veriyi sağlar. Veriyi almak için .data, etiketleri almak için .target çağrısı yapacaksınız.

Veride otuz özelliği olan 569 örnek vardır ve her örnekle ilişkili bir etiket bulunur. Bu veri kümesinde iki etiket vardır.

breast = load_breast_cancer()

breast_data = breast.data

Verinin şeklini kontrol edelim.

breast_data.shape

(569, 30)

Bu eğitim için etiketlere ihtiyacınız olmasa da daha iyi anlamak adına etiketleri de yükleyelim ve şeklini kontrol edelim.

breast_labels = breast.target

breast_labels.shape

(569,)

Şimdi numpy’yi içe aktaracağız; çünkü breast_labels’ı breast_data ile birleştirmek için yeniden şekillendirecek, ardından hem veriyi hem de etiketleri içeren bir DataFrame oluşturacağız.

import numpy as np

labels = np.reshape(breast_labels,(569,1))

Etiketleri reshaping ettikten sonra, veriyi ve etiketleri ikinci eksen boyunca concatenate edeceksiniz; bu da dizinin nihai şeklini 569 x 31 yapar.

final_breast_data = np.concatenate([breast_data,labels],axis=1)

final_breast_data.shape

(569, 31)

Şimdi veriyi tablo halinde temsil etmek için pandas’ı içe aktararak nihai verinin DataFrame’ini oluşturacağız.

import pandas as pd

breast_dataset = pd.DataFrame(final_breast_data)

Hızlıca breast cancer veri kümesinde bulunan özellikleri yazdıralım!

features = breast.feature_names

features

array(['mean radius', 'mean texture', 'mean perimeter', 'mean area',
       'mean smoothness', 'mean compactness', 'mean concavity',
       'mean concave points', 'mean symmetry', 'mean fractal dimension',
       'radius error', 'texture error', 'perimeter error', 'area error',
       'smoothness error', 'compactness error', 'concavity error',
       'concave points error', 'symmetry error',
       'fractal dimension error', 'worst radius', 'worst texture',
       'worst perimeter', 'worst area', 'worst smoothness',
       'worst compactness', 'worst concavity', 'worst concave points',
       'worst symmetry', 'worst fractal dimension'], dtype='<U23')

features dizisinde label alanının eksik olduğuna dikkat edin. Bu nedenle, bu diziyi breast_dataset veri çerçevenizin sütun adlarıyla eşitleyeceğiniz için, features dizisine bunu manuel olarak eklemeniz gerekecek.

features_labels = np.append(features,'label')

Harika! Şimdi sütun adlarını breast_dataset veri çerçevesine gömeceksiniz.

breast_dataset.columns = features_labels

Veri çerçevesinin ilk birkaç satırını yazdıralım.

breast_dataset.head()

Orijinal etiketler 0,1 formatında olduğundan, .replace fonksiyonunu kullanarak etiketleri benign ve malignant olarak değiştireceksiniz. inplace=True kullanarak breast_dataset veri çerçevesini yerinde değiştireceksiniz.

breast_dataset['label'].replace(0, 'Benign',inplace=True)
breast_dataset['label'].replace(1, 'Malignant',inplace=True)

breast_dataset’in son birkaç satırını yazdıralım.

breast_dataset.tail()

CIFAR - 10 veri keşfi

Şimdi, CIFAR - 10 görüntü veri setini keşfedeceksiniz

CIFAR - 10 veri setini Keras adlı bir derin öğrenme kütüphanesiyle yükleyebilirsiniz.

from keras.datasets import cifar10

İçe aktardıktan sonra, veriyi indirmek için .load_data() metodunu kullanacaksınız; bu yöntem veriyi indirip Keras dizininize kaydeder. İnternet hızınıza bağlı olarak biraz zaman alabilir.

(x_train, y_train), (x_test, y_test) = cifar10.load_data()

Yukarıdaki kod satırı, eğitim ve test görüntülerini etiketleriyle birlikte döndürür.

Eğitim ve test görüntülerinin şeklini hızlıca yazdıralım.

print('Traning data shape:', x_train.shape)
print('Testing data shape:', x_test.shape)

Traning data shape: (50000, 32, 32, 3)
Testing data shape: (10000, 32, 32, 3)

Etiketlerin şeklini de yazdıralım.

y_train.shape,y_test.shape

((50000, 1), (10000, 1))

Toplam etiket sayısını ve verideki sınıf türlerini de bulalım.

# Find the unique numbers from the train labels
classes = np.unique(y_train)
nClasses = len(classes)
print('Total number of outputs : ', nClasses)
print('Output classes : ', classes)

Total number of outputs :  10
Output classes :  [0 1 2 3 4 5 6 7 8 9]

Şimdi CIFAR-10 görüntülerini çizdirmek için matplotlib’i içe aktaracak ve çıktıların doğrudan defterde gösterilmesi için jupyter notebook’a magic (%) komutu olan %matplotlib inline’ı kullanacaksınız!

import matplotlib.pyplot as plt
%matplotlib inline

Daha iyi anlamak için, kategorik sınıf etiketlerine karşılık gelen sınıf adlarını içeren bir sözlük oluşturalım.

label_dict = {
 0: 'airplane',
 1: 'automobile',
 2: 'bird',
 3: 'cat',
 4: 'deer',
 5: 'dog',
 6: 'frog',
 7: 'horse',
 8: 'ship',
 9: 'truck',
}

plt.figure(figsize=[5,5])

# Display the first image in training data
plt.subplot(121)
curr_img = np.reshape(x_train[0], (32,32,3))
plt.imshow(curr_img)
print(plt.title("(Label: " + str(label_dict[y_train[0][0]]) + ")"))

# Display the first image in testing data
plt.subplot(122)
curr_img = np.reshape(x_test[0],(32,32,3))
plt.imshow(curr_img)
print(plt.title("(Label: " + str(label_dict[y_test[0][0]]) + ")"))

Text(0.5, 1.0, '(Label: frog)')
Text(0.5, 1.0, '(Label: cat)')

Yukarıdaki iki görüntü bulanık olsa da yine de birincisinin etiket frog olan bir kurbağa, ikincisinin ise etiket cat olan bir kedi olduğunu bir şekilde gözlemleyebilirsiniz.

PCA ile Veri Görselleştirme

Şimdi bu eğitimin en heyecanlı kısmına geldik. Daha önce öğrendiğiniz gibi PCA, yüksek boyutlu veriyi düşük boyutlu temel bileşenlere projekte eder; şimdi bunu Python yardımıyla görselleştirme zamanı!

Breast cancer verisini görselleştirme

• PCA’nın çıktısı verinin özelliklerinin ölçeğinden etkilendiği için veriyi önce Standardize ederek başlarsınız.

  Herhangi bir makine öğrenimi algoritmasına vermeden önce verinizi normalleştirmek yaygın bir uygulamadır.

  Normalleştirme uygulamak için sklearn kütüphanesinden StandardScaler modülünü içe aktaracak ve Veri Keşfi adımında oluşturduğunuz breast_dataset’ten yalnızca özellikleri seçeceksiniz. Özellikleri aldıktan sonra, özellik verisi üzerinde fit_transform yaparak ölçekleme uygulayacaksınız.

  StandardScaler uygularken, verinizin her bir özelliği normal dağılıma sahip olacak şekilde dönüştürülür; dağılım ortalaması sıfır ve standart sapması bir olacak şekilde ölçeklenir.

from sklearn.preprocessing import StandardScaler
x = breast_dataset.loc[:, features].values
x = StandardScaler().fit_transform(x) # normalizing the features

x.shape

(569, 30)

Normalleştirilmiş verinin ortalamasının sıfır ve standart sapmasının bir olup olmadığını kontrol edelim.

np.mean(x),np.std(x)

(-6.826538293184326e-17, 1.0)

Normalleştirilmiş özellikleri DataFrame yardımıyla tablo formatına dönüştürelim.

feat_cols = ['feature'+str(i) for i in range(x.shape[1])]

normalised_breast = pd.DataFrame(x,columns=feat_cols)

normalised_breast.tail()

• Şimdi kritik kısım geliyor; aşağıdaki birkaç satır kod, otuz boyutlu Breast Cancer verisini iki boyutlu temel bileşenlere projekte edecek.

  sklearn kütüphanesini kullanarak PCA modülünü içe aktaracak, PCA metodunda bileşen sayısını (n_components=2) geçecek ve son olarak tümleşik veride fit_transform çağıracaksınız. Burada bileşen sayısı, yüksek boyutlu verinizi projekte edeceğiniz daha düşük boyutu temsil eder.

from sklearn.decomposition import PCA
pca_breast = PCA(n_components=2)
principalComponents_breast = pca_breast.fit_transform(x)

Sonraki adımda, 569 örneğin tümü için temel bileşen değerlerini içerecek bir DataFrame oluşturalım.

principal_breast_Df = pd.DataFrame(data = principalComponents_breast
             , columns = ['principal component 1', 'principal component 2'])

principal_breast_Df.tail()

• Temel bileşenleri elde ettikten sonra explained_variance_ratio değerini bulabilirsiniz. Bu, veriyi daha düşük boyutlu alt uzaya projekte ettikten sonra her temel bileşenin tuttuğu bilgi veya varyans miktarını verir.

print('Explained variability per principal component: {}'.format(pca_breast.explained_variance_ratio_))

Explained variability per principal component: [0.44272026 0.18971182]

Yukarıdaki çıktıya göre, principal component 1 bilginin %44,2’sini tutarken, principal component 2 yalnızca %19’unu tutmaktadır. Ayrıca dikkat edilmesi gereken bir diğer nokta, otuz boyutlu veriyi iki boyuta projekte ederken %36,8 bilginin kaybolmuş olmasıdır.

569 örneğin görselleştirmesini principal component - 1 ve principal component - 2 eksenleri boyunca çizelim. Bu, örneklerinizin iki sınıf arasında nasıl dağıldığına dair iyi bir içgörü sağlamalıdır.

plt.figure()
plt.figure(figsize=(10,10))
plt.xticks(fontsize=12)
plt.yticks(fontsize=14)
plt.xlabel('Principal Component - 1',fontsize=20)
plt.ylabel('Principal Component - 2',fontsize=20)
plt.title("Principal Component Analysis of Breast Cancer Dataset",fontsize=20)
targets = ['Benign', 'Malignant']
colors = ['r', 'g']
for target, color in zip(targets,colors):
    indicesToKeep = breast_dataset['label'] == target
    plt.scatter(principal_breast_Df.loc[indicesToKeep, 'principal component 1']
               , principal_breast_Df.loc[indicesToKeep, 'principal component 2'], c = color, s = 50)

plt.legend(targets,prop={'size': 15})

<matplotlib.legend.Legend at 0x14552a630>




<Figure size 432x288 with 0 Axes>

Yukarıdaki grafikten, iki sınıfın benign ve malignant iki boyutlu bir uzaya projekte edildiğinde bir ölçüde doğrusal olarak ayrılabildiğini gözlemleyebilirsiniz. Diğer bir gözlem de benign sınıfının malignant sınıfına kıyasla daha yaygın olmasıdır.

CIFAR - 10 verisini görselleştirme

CIFAR-10 verisini görselleştirmek için aşağıdaki kod satırları, Breast Cancer verisinin PCA görselleştirmesine oldukça benzerdir.

• CIFAR-10 eğitim görüntülerinin maksimum ve minimum değerlerini hızlıca kontrol edelim ve pikselleri 0 ile 1 arasında normalize edelim.

np.min(x_train),np.max(x_train)

(0.0, 1.0)

x_train = x_train/255.0

np.min(x_train),np.max(x_train)

(0.0, 0.00392156862745098)

x_train.shape

(50000, 32, 32, 3)

Sonraki adımda, görüntülerin piksel değerlerini, satır-sütun formatında ilgili etiketleriyle birlikte tutacak bir DataFrame oluşturacaksınız.

Ancak ondan önce, görüntü boyutlarını üçten bire yeniden şekillendirelim (görüntüleri düzleştirelim).

x_train_flat = x_train.reshape(-1,3072)

feat_cols = ['pixel'+str(i) for i in range(x_train_flat.shape[1])]

df_cifar = pd.DataFrame(x_train_flat,columns=feat_cols)

df_cifar['label'] = y_train
print('Size of the dataframe: {}'.format(df_cifar.shape))

Size of the dataframe: (50000, 3073)

Mükemmel! Veri çerçevesinin boyutu doğru; çünkü 50.000 eğitim görüntüsü vardır, her birinde 3072 piksel ve ayrıca etiketler için ek bir sütun bulunur; toplamda 3073.

PCA, her görüntü için etiket olan son sütun hariç tüm sütunlara uygulanacaktır.

df_cifar.head()

• Ardından, PCA metodunu oluşturacak ve bileşen sayısını iki olarak verip eğitim verisi üzerinde fit_transform uygulayacaksınız; 50.000 örnek olduğu için bu birkaç saniye sürebilir

pca_cifar = PCA(n_components=2)
principalComponents_cifar = pca_cifar.fit_transform(df_cifar.iloc[:,:-1])

Daha sonra, 50.000 görüntünün her biri için temel bileşenleri bir numpy dizisinden pandas DataFrame’e dönüştüreceksiniz.

principal_cifar_Df = pd.DataFrame(data = principalComponents_cifar
             , columns = ['principal component 1', 'principal component 2'])
principal_cifar_Df['y'] = y_train

principal_cifar_Df.head()

• Temel bileşenlerin tuttuğu bilgi veya varyansı hızlıca bulalım.

print('Explained variability per principal component: {}'.format(pca_cifar.explained_variance_ratio_))

Explained variability per principal component: [0.2907663  0.11253144]

Görünen o ki, veriler 3072 boyuttan yalnızca iki temel bileşene projekte edilmiş olmasına rağmen, 1 ve 2. temel bileşenler makul miktarda bilgi tutmayı başardı.

Artık CIFAR-10 verisini iki boyutlu bir uzayda görselleştirme zamanı. Bu veri setinde bazı semantik sınıf örtüşmeleri olduğunu unutmayın; bu, bir kurbağanın bir kediye ya da bir geyiğin bir köpeğe biraz benzer şekle sahip olabileceği anlamına gelir; özellikle iki boyutlu bir uzaya projekte edildiğinde. Aralarındaki farklar o kadar iyi yakalanamayabilir.

import seaborn as sns
plt.figure(figsize=(16,10))
sns.scatterplot(
    x="principal component 1", y="principal component 2",
    hue="y",
    palette=sns.color_palette("hls", 10),
    data=principal_cifar_Df,
    legend="full",
    alpha=0.3
)

<matplotlib.axes._subplots.AxesSubplot at 0x12a5ba8d0>

Yukarıdaki şekilde, iki temel bileşen ekseni boyunca projekte edildiğinde noktalarda bir miktar yapı olduğu için, temel bileşenlerin bazı varyasyonları yakaladığını gözlemleyebilirsiniz. Aynı sınıfa ait noktalar birbirine yakındır ve semantik olarak çok farklı olan noktalar veya görüntüler birbirinden daha uzaktadır.

PCA ile Derin Öğrenme Eğitimini Hızlandırma

Eğitimin bu son bölümünde, Derin Öğrenme Modelinizin eğitim sürecini PCA kullanarak nasıl hızlandırabileceğinizi öğreneceksiniz.

Not: Bu bölümde kullanılacak temel terimleri öğrenmek için lütfen bu eğitime göz atabilirsiniz.

Önce eğitim ve test görüntülerini normalleştirelim. Hatırlarsanız eğitim görüntüleri PCA görselleştirmesi kısmında normalleştirilmişti, bu yüzden yalnızca test görüntülerini normalleştirmeniz gerekiyor. Hızlıca yapalım!

x_test = x_test/255.0

x_test = x_test.reshape(-1,32,32,3)

Test verisini reshape edelim.

x_test_flat = x_test.reshape(-1,3072)

Sonraki adımda PCA modelinin örneğini oluşturacaksınız.

Burada, PCA’nın ne kadar varyansı yakalamasını istediğinizi de belirtebilirsiniz. PCA modeline parametre olarak 0.9 geçelim; bu, PCA’nın varyansın %90’ını tutacağı ve %90 varyansı yakalamak için gereken bileşen sayısının kullanılacağı anlamına gelir.

Daha önce n_components parametresini geçtiğinizi ve o iki bileşenin ne kadar varyans yakaladığını bulabildiğinizi unutmayın. Burada ise PCA’nın ne kadar varyans yakalamasını istediğimizi açıkça belirtiyoruz; dolayısıyla n_components varyans parametresine göre değişecektir.

Herhangi bir varyans değeri geçmezseniz, bileşen sayısı verinin orijinal boyutuna eşit olur.

pca = PCA(0.9)

Ardından, PCA örneğini eğitim görüntüleri üzerinde fit edeceksiniz.

pca.fit(x_train_flat)

PCA(copy=True, iterated_power='auto', n_components=0.9, random_state=None,
  svd_solver='auto', tol=0.0, whiten=False)

Şimdi, PCA’nın 0.9 varyansı yakalamak için kaç n_components kullandığını bulalım.

pca.n_components_

99

Yukarıdaki çıktıya göre, %90 varyansa ulaşmak için boyut, gerçek 3072 boyuttan 99 temel bileşene indirgenmiştir.

Son olarak, fit metodundan üretilen parametrelerden dönüştürülmüş bir veri kümesi oluşturmak için hem eğitim hem de test setinde transform uygulayacaksınız.

train_img_pca = pca.transform(x_train_flat)
test_img_pca = pca.transform(x_test_flat)

Şimdi derin öğrenme modelini çalıştırmak için gerekli kütüphaneleri hızlıca içe aktaralım.

from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils
from keras.optimizers import RMSprop

Şimdi eğitim ve test etiketlerinizi one-hot kodlamalı vektöre dönüştüreceksiniz.

y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)

Modeliniz için epoch sayısını, sınıf sayısını ve batch boyutunu tanımlayalım.

batch_size = 128
num_classes = 10
epochs = 20

Şimdi Sequential modelinizi tanımlayacaksınız!

model = Sequential()
model.add(Dense(1024, activation='relu', input_shape=(99,)))
model.add(Dense(1024, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))

Model özetini yazdıralım.

model.summary()

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_1 (Dense)              (None, 1024)              102400    
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 512)               524800    
_________________________________________________________________
dense_4 (Dense)              (None, 256)               131328    
_________________________________________________________________
dense_5 (Dense)              (None, 10)                2570      
=================================================================
Total params: 1,810,698
Trainable params: 1,810,698
Non-trainable params: 0
_________________________________________________________________

Son olarak, modeli derleme ve eğitme zamanı!

model.compile(loss='categorical_crossentropy',
              optimizer=RMSprop(),
              metrics=['accuracy'])

history = model.fit(train_img_pca, y_train,batch_size=batch_size,epochs=epochs,verbose=1,
                    validation_data=(test_img_pca, y_test))

WARNING:tensorflow:From /Users/adityasharma/blog/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:2704: calling reduce_sum (from tensorflow.python.ops.math_ops) with keep_dims is deprecated and will be removed in a future version.
Instructions for updating:
keep_dims is deprecated, use keepdims instead
WARNING:tensorflow:From /Users/adityasharma/blog/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:1257: calling reduce_mean (from tensorflow.python.ops.math_ops) with keep_dims is deprecated and will be removed in a future version.
Instructions for updating:
keep_dims is deprecated, use keepdims instead
Train on 50000 samples, validate on 10000 samples
Epoch 1/20
50000/50000 [==============================] - 7s - loss: 1.9032 - acc: 0.2962 - val_loss: 1.6925 - val_acc: 0.3875
Epoch 2/20
50000/50000 [==============================] - 7s - loss: 1.6480 - acc: 0.4055 - val_loss: 1.5313 - val_acc: 0.4412
Epoch 3/20
50000/50000 [==============================] - 7s - loss: 1.5205 - acc: 0.4534 - val_loss: 1.4609 - val_acc: 0.4695
Epoch 4/20
50000/50000 [==============================] - 7s - loss: 1.4322 - acc: 0.4849 - val_loss: 1.6164 - val_acc: 0.4503
Epoch 5/20
50000/50000 [==============================] - 7s - loss: 1.3621 - acc: 0.5120 - val_loss: 1.3626 - val_acc: 0.5081
Epoch 6/20
50000/50000 [==============================] - 7s - loss: 1.2995 - acc: 0.5330 - val_loss: 1.4100 - val_acc: 0.4940
Epoch 7/20
50000/50000 [==============================] - 7s - loss: 1.2473 - acc: 0.5529 - val_loss: 1.3589 - val_acc: 0.5251
Epoch 8/20
50000/50000 [==============================] - 7s - loss: 1.2010 - acc: 0.5669 - val_loss: 1.3315 - val_acc: 0.5232
Epoch 9/20
50000/50000 [==============================] - 7s - loss: 1.1524 - acc: 0.5868 - val_loss: 1.3903 - val_acc: 0.5197
Epoch 10/20
50000/50000 [==============================] - 7s - loss: 1.1134 - acc: 0.6013 - val_loss: 1.2722 - val_acc: 0.5499
Epoch 11/20
50000/50000 [==============================] - 7s - loss: 1.0691 - acc: 0.6160 - val_loss: 1.5911 - val_acc: 0.4768
Epoch 12/20
50000/50000 [==============================] - 7s - loss: 1.0325 - acc: 0.6289 - val_loss: 1.2515 - val_acc: 0.5602
Epoch 13/20
50000/50000 [==============================] - 7s - loss: 0.9977 - acc: 0.6420 - val_loss: 1.5678 - val_acc: 0.4914
Epoch 14/20
50000/50000 [==============================] - 8s - loss: 0.9567 - acc: 0.6567 - val_loss: 1.3525 - val_acc: 0.5418
Epoch 15/20
50000/50000 [==============================] - 9s - loss: 0.9158 - acc: 0.6713 - val_loss: 1.3525 - val_acc: 0.5540
Epoch 16/20
50000/50000 [==============================] - 10s - loss: 0.8948 - acc: 0.6816 - val_loss: 1.5633 - val_acc: 0.5156
Epoch 17/20
50000/50000 [==============================] - 9s - loss: 0.8690 - acc: 0.6903 - val_loss: 1.6980 - val_acc: 0.5084
Epoch 18/20
50000/50000 [==============================] - 9s - loss: 0.8586 - acc: 0.7002 - val_loss: 1.6325 - val_acc: 0.5247
Epoch 19/20
50000/50000 [==============================] - 8s - loss: 0.9367 - acc: 0.6853 - val_loss: 1.8253 - val_acc: 0.5165
Epoch 20/20
50000/50000 [==============================] - 8s - loss: 2.3761 - acc: 0.5971 - val_loss: 6.0192 - val_acc: 0.4409

Yukarıdaki çıktıda, her epoch’un eğitim süresinin CPU’da sadece 7 saniye olduğunu gözlemleyebilirsiniz. Model eğitim verisinde %70 doğruluk elde ederek fena olmayan bir iş çıkarmış, ancak test verisinde yalnızca %56 doğruluk sağlamıştır. Bu, eğitim verisine aşırı uyum sağladığı anlamına gelir. Yine de verinin 3072 boyuttan 99 boyuta projekte edildiğini ve buna rağmen iyi iş çıkardığını unutmayın!

Son olarak, modelin orijinal veri kümesi üzerinde eğitilirken ne kadar zaman aldığını ve aynı derin öğrenme modeliyle hangi doğruluğa ulaşabildiğini görelim.

model = Sequential()
model.add(Dense(1024, activation='relu', input_shape=(3072,)))
model.add(Dense(1024, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
              optimizer=RMSprop(),
              metrics=['accuracy'])

history = model.fit(x_train_flat, y_train,batch_size=batch_size,epochs=epochs,verbose=1,
                    validation_data=(x_test_flat, y_test))

Train on 50000 samples, validate on 10000 samples
Epoch 1/20
50000/50000 [==============================] - 23s - loss: 2.0657 - acc: 0.2200 - val_loss: 2.0277 - val_acc: 0.2485
Epoch 2/20
50000/50000 [==============================] - 22s - loss: 1.8727 - acc: 0.3166 - val_loss: 1.8428 - val_acc: 0.3215
Epoch 3/20
50000/50000 [==============================] - 22s - loss: 1.7801 - acc: 0.3526 - val_loss: 1.7657 - val_acc: 0.3605
Epoch 4/20
50000/50000 [==============================] - 22s - loss: 1.7141 - acc: 0.3796 - val_loss: 1.6345 - val_acc: 0.4132
Epoch 5/20
50000/50000 [==============================] - 22s - loss: 1.6566 - acc: 0.4001 - val_loss: 1.6384 - val_acc: 0.4076
Epoch 6/20
50000/50000 [==============================] - 22s - loss: 1.6083 - acc: 0.4209 - val_loss: 1.7507 - val_acc: 0.3574
Epoch 7/20
50000/50000 [==============================] - 22s - loss: 1.5626 - acc: 0.4374 - val_loss: 1.7125 - val_acc: 0.4010
Epoch 8/20
50000/50000 [==============================] - 22s - loss: 1.5252 - acc: 0.4486 - val_loss: 1.5914 - val_acc: 0.4321
Epoch 9/20
50000/50000 [==============================] - 24s - loss: 1.4924 - acc: 0.4620 - val_loss: 1.5352 - val_acc: 0.4616
Epoch 10/20
50000/50000 [==============================] - 25s - loss: 1.4627 - acc: 0.4728 - val_loss: 1.4561 - val_acc: 0.4798
Epoch 11/20
50000/50000 [==============================] - 24s - loss: 1.4349 - acc: 0.4820 - val_loss: 1.5044 - val_acc: 0.4723
Epoch 12/20
50000/50000 [==============================] - 24s - loss: 1.4120 - acc: 0.4919 - val_loss: 1.4740 - val_acc: 0.4790
Epoch 13/20
50000/50000 [==============================] - 23s - loss: 1.3913 - acc: 0.4981 - val_loss: 1.4430 - val_acc: 0.4891
Epoch 14/20
50000/50000 [==============================] - 27s - loss: 1.3678 - acc: 0.5098 - val_loss: 1.4323 - val_acc: 0.4888
Epoch 15/20
50000/50000 [==============================] - 27s - loss: 1.3508 - acc: 0.5148 - val_loss: 1.6179 - val_acc: 0.4372
Epoch 16/20
50000/50000 [==============================] - 25s - loss: 1.3443 - acc: 0.5167 - val_loss: 1.5868 - val_acc: 0.4656
Epoch 17/20
50000/50000 [==============================] - 25s - loss: 1.3734 - acc: 0.5101 - val_loss: 1.4756 - val_acc: 0.4913
Epoch 18/20
50000/50000 [==============================] - 26s - loss: 5.5126 - acc: 0.3591 - val_loss: 5.7580 - val_acc: 0.3084
Epoch 19/20
50000/50000 [==============================] - 27s - loss: 5.6346 - acc: 0.3395 - val_loss: 3.7362 - val_acc: 0.3402
Epoch 20/20
50000/50000 [==============================] - 26s - loss: 6.4199 - acc: 0.3030 - val_loss: 13.9429 - val_acc: 0.1326

Voila! Yukarıdaki çıktıya bakıldığında, her epoch’un eğitim süresinin CPU’da yaklaşık 23 saniye olduğu açıkça görülüyor; bu da PCA çıktısı üzerinde eğitilen modelden neredeyse üç kat daha fazladır.

Ayrıca, hem eğitim hem test doğruluğu, 99 temel bileşeni modelin girdisi olarak kullandığınızda elde ettiğiniz doğruluktan daha düşüktür.

Dolayısıyla, eğitim verisine PCA uygulayarak derin öğrenme algoritmanızı yalnızca hızlı eğitmekle kalmadınız; aynı zamanda, orijinal eğitim verisiyle eğitilen derin öğrenme algoritmasına kıyasla test verisinde daha iyi doğruluk elde ettiniz.

Daha İleri Gidin!

Eğitimi tamamladığınız için tebrikler.

Bu eğitim, PCA’nın hem teorik hem de pratik kavramlarını kapsayan harika ve kapsamlı bir Python’a giriş niteliğindeydi.

Boyut indirgeme tekniklerine daha derinlemesine dalmak isterseniz, yaygın olarak tSNE olarak bilinen t-dağıtımlı Stokastik Komşu Gömme tekniğini okumayı düşünün; bu doğrusal olmayan, olasılıksal bir boyut indirgeme tekniğidir.

PCA gibi denetimsiz öğrenme teknikleri hakkında daha fazla bilgi edinmek isterseniz, DataCamp’in Python ile Denetimsiz Öğrenme kursunu alın.

İleri okuma için kaynaklar:

• Sklearn’de PCA
• R ile Temel Bileşen Analizi
• Python (scikit-learn) ile PCA