Kütüphaneler

In [ ]:

import os, re, random

import pandas as pd
import numpy as np
import zipfile
np.random.seed(2)
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import seaborn as sns
%matplotlib inline
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
import itertools
from keras.utils.np_utils import to_categorical
from keras.models import Sequential
from keras import layers
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
from keras.layers import MaxPooling2D, GlobalMaxPooling2D, Activation
from keras.optimizers import RMSprop
from keras.preprocessing.image import ImageDataGenerator, load_img
from keras import optimizers
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from keras.models import Model
from keras.applications import VGG16
from keras.applications.resnet50 import ResNet50

In [ ]:

PATH = "../input/dogs-vs-cats-redux-kernels-edition"
PATH_TRAIN = "train_images/"
PATH_TEST = "test_images/"

In [ ]:

os.listdir(PATH)

In [ ]:

train_image_path = os.path.join(PATH, "train.zip")

test_image_path = os.path.join(PATH, "test.zip")

In [ ]:

os.mkdir('/kaggle/working/train_images')

In [ ]:

os.mkdir('/kaggle/working/test_images')
In [ ]:

archive = zipfile.ZipFile(train_image_path,"r")
for file in archive.namelist():
archive.extract(file, 'train_images/')

In [ ]:

train_images = os.listdir(f'{PATH_TRAIN}/train/')

In [ ]:

imagenames = np.array([f'{f}' for f in train_images])

In [ ]:

imagenames

In [ ]:

categories = []
for imagename in imagenames:

split_category = imagename.split('.')[0]

if split_category == 'cat':
categories.append(str(0))
else:
categories.append(str(1))

In [ ]:

animals = pd.DataFrame({
'Image name': imagenames,
'Category': categories
})
animals.head(5)

In [ ]:

animals['Category'].value_counts()
Gördüğümüz gibi, görevlerimiz başlangıçtaki 12500 görüntü veri seti dengelidir: hem 12500 köpek hem de kedi.

In [ ]:

img = plt.imread(f'{PATH_TRAIN}/train/{imagenames[1]}')
plt.imshow(img);

In [ ]:

X_train, X_val = train_test_split(animals, test_size=0.2, random_state=2)

X_train = X_train.reset_index()
X_val = X_val.reset_index()

Satır miktarını sayın. İki nedenden dolayı ihtiyacımız var. Birincisi: model uyum sürecinde parti boyutuna göre
ayrılmış parametre olarak kullanılacaktır. İkincisi: Comp için 1800 resim kesersek, 1800 resmin mevcut olup
olmadığını kontrol etmemiz için nedenler var.

In [ ]:

total_X_train = X_train.shape[0]
total_X_val = X_val.shape[0]

In [ ]:

total_X_train

20000
In [ ]:

total_X_val

5000

VGG-16

Mimari

VGG16 [2] CNN mimarisi 2014 yılında K. Simonyan ve A. Zisserman (Oxford Üniversitesi) tarafından “Büyük
Ölçekli Görüntü Tanıma için Çok Derin Evrişimli Ağlar” [5] adlı makalelerinde önerilmiştir. Model, 1000 sınıfa ait
14 milyondan fazla görüntüden oluşan bir veri seti olan ImageNet'te %92,7 ilk 5 test doğruluğuna ulaşıyor.
Temel şeması [2] aşağıda gösterilmiştir:

Gördüğümüz gibi, bu ağ 16 katmandan oluşur:

13 yığılmış Evrişimsel katman;

3 Yoğun katman.

Evrişim katmanları, görüntüden öznitelikleri çıkarır, tam bağlantılı katmanlar, ayıklanan öznitelikleri kullanarak
görüntüyü sınıflandırır. Evrişim katmanlarındaki filtrelerin sayısı artan bir model izler. Bilgilendirici özellikler,
mimaride farklı adımlarda uygulanan Maxpooling katmanları ile elde edilir. Yoğun katmanların her biri 4096,
4096 ve 1000 düğümden oluşur. Modellerin tam konfigürasyon tablosu [2]'de bulunabilir.

Fotoğraf Boyutu
In [ ]:

image_size = 224
input_shape = (image_size, image_size, 3)

Epoch & Batch

In [ ]:

epochs = 5
batch_size = 16
In [ ]:

pre_trained_model = VGG16(input_shape=input_shape, include_top=False, weights="imagenet")

Downloading data from https://storage.googleapis.com/tensorflow/keras-

applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5
(https://storage.googleapis.com/tensorflow/keras-
applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5) 58892288/58889256
[==============================]- 1s 0us/step

In [ ]:

print(pre_trained_model.summary())
In [ ]:

for layer in pre_trained_model.layers[:15]:

layer.trainable = False

for layer in pre_trained_model.layers[15:]:

layer.trainable = True

last_layer = pre_trained_model.get_layer('block5_pool')
last_output = last_layer.output

x = GlobalMaxPooling2D()(last_output)

x = Dense(512, activation='relu')(x)

x = Dropout(0.5)(x)

x = layers.Dense(1, activation='sigmoid')(x)

model_mod = Model(pre_trained_model.input, x)

In [ ]:

model_mod.compile(loss='binary_crossentropy',
optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy']
)

Modellerin hiperparametrelerini seçmek (ayarlamalarının yanı sıra) neredeyse ampirik bir süreçtir. Yani
kombinasyonların yeniden düzenlenmesi test edilip, çalıştırıldıktan sonra değiştirilebilir.

ImageDataGenerator

Keras - ImageDataGenerator sınıfının kullanılması.

In [ ]:

train_datagen = ImageDataGenerator(
rotation_range=15,
rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest',
width_shift_range=0.1,
height_shift_range=0.1
)
In [ ]:

train_generator = train_datagen.flow_from_dataframe(
X_train,
"/kaggle/working/train_images/train",
x_col='Image name',
y_col='Category',
class_mode='binary',
target_size=(image_size, image_size),
batch_size=batch_size,
#validate_filenames = False
)

Doğrulama (ImageDataGenerator)
In [ ]:

validation_datagen = ImageDataGenerator(
rescale=1./255
)

In [ ]:

validation_generator = validation_datagen.flow_from_dataframe(
X_val,
"/kaggle/working/train_images/train",
x_col='Image name',
y_col='Category',
class_mode='binary',
target_size=(image_size, image_size),
batch_size=batch_size,
#validate_filenames = False
)

In [ ]:

generated_example_df = X_train.sample(n=1).reset_index(drop=True)
example_generator = train_datagen.flow_from_dataframe(
generated_example_df,
"/kaggle/working/train_images/train",
x_col='Image name',
y_col='Category',
class_mode='categorical',
#validate_filenames = False
)

In [ ]:

plt.figure(figsize=(10, 10))
for i in range(0, 9):
plt.subplot(3, 3, i+1)
for X_batch, Y_batch in example_generator:
image = X_batch[0]
plt.imshow(image)
break
plt.tight_layout()
plt.show()
Geribildirim

İki tane faydalı olanı var: erken durdurma ve öğrenme oranını azaltmak.

Erken Durdurma

Overfitting'i önlemek için, val_loss değeri azalmadığında 10 epoch'tan sonra model öğrenmeyi durdurur.

Öğrenme Hızı Azaltma

Doğruluk iki sürekli adım için artmadığında öğrenme oranını azaltalım.

In [ ]:

earlystop = EarlyStopping(patience=10,
verbose=1,
mode='auto'
)

In [ ]:

learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy',
patience=2,
verbose=1,
factor=0.5,
min_lr=0.00001
)

In [ ]:

callbacks = [earlystop, learning_rate_reduction]

In [ ]:

callbacks

Model Uyumu & Epoch Hesaplama

In [ ]:

history = model_mod.fit_generator(
train_generator,
epochs=epochs,
validation_data=validation_generator,
validation_steps=total_X_val//batch_size,
steps_per_epoch=total_X_train//batch_size,
callbacks=callbacks
)
In [ ]:

# Epoch 1/5
# 1250/1250 [==============================] - 404s 323ms/step - loss: 0.3144 - accuracy: 0
# Epoch 2/5
# 1250/1250 [==============================] - 385s 308ms/step - loss: 0.1555 - accuracy: 0
# Epoch 3/5
# 1250/1250 [==============================] - 382s 305ms/step - loss: 0.1305 - accuracy: 0
# Epoch 4/5
# 1250/1250 [==============================] - 381s 305ms/step - loss: 0.1125 - accuracy: 0
# Epoch 5/5
# 1250/1250 [==============================] - 381s 305ms/step - loss: 0.1051 - accuracy: 0

In [ ]:

model_mod.save_weights('model_wieghts.h5')
model_mod.save('model_keras.h5')

Model Doğruluk Oranı & Kayıp

In [ ]:

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(7, 7))

ax1.plot(history.history['loss'], color='r', label="Train loss")

ax1.plot(history.history['val_loss'], color='b', label="Validation loss")
ax1.set_xticks(np.arange(1, epochs, 1))
legend = ax1.legend(loc='best', shadow=True)

ax2.plot(history.history['accuracy'], color='r', label="Train accuracy")

ax2.plot(history.history['val_accuracy'], color='b',label="Validation accuracy")
ax2.set_xticks(np.arange(1, epochs, 1))
legend = ax2.legend(loc='best', shadow=True)

plt.tight_layout()
plt.show()
Doğrulama Verileri Tahmini
In [ ]:

Y_val = X_val['Category']
Y_pred = model_mod.predict_generator(validation_generator)

In [ ]:

threshold = 0.5

Y_pred_conv = np.where(Y_pred > threshold, 1,0)

In [ ]:

Y_pred_conv[:,0]

array([1, 0, 1, ........, 1, 1, 0])

In [ ]:

pd.Series(Y_pred_conv[:,0]).hist()
Bir Karışıklık matrisi hesaplamak için, aynı veri tipinde tahmin ve doğrulama kümelerimize sahip olmamız
gerekir.

In [ ]:

Y_pred_conv.dtype

dtype('int64')

In [ ]:

Y_val.dtype

dtype('O')

In [ ]:

Y_val_str = Y_val.astype(int)

In [ ]:

confusion_mtx = confusion_matrix(Y_val_str, Y_pred_conv)

f,ax = plt.subplots(figsize=(8, 8))

sns.heatmap(confusion_mtx, annot=True)
plt.xlabel("Predicted Label")
plt.ylabel("Validation (aka True) Label")
plt.title("Confusion Matrix")
plt.show()
Sensitivity & Specificity
Duyarlılık: Bir testin duyarlılığı, hasta vakalarını doğru bir şekilde belirleme yeteneğidir. Bunu tahmin etmek için,
hasta vakalarındaki gerçek pozitif oranını hesaplamalıyız. Matematiksel olarak bu şu şekilde ifade edilebilir.

True positive (TP) False negative (FN) Sensitivity=TP/(TP+FN)

Özgüllük: Bir testin özgüllüğü, sağlıklı vakaları doğru bir şekilde belirleme yeteneğidir. Bunu tahmin etmek için
sağlıklı vakalarda gerçek negatif oranını hesaplamalıyız. Matematiksel olarak bu şu şekilde ifade edilebilir:

True negative (TN) False positive (FP) Specificity=TN/(TN+FP)

In [ ]:

TP = confusion_matrix[0 , 0]
FP = confusion_matrix[0 , 1]
FN = confusion_matrix[1 , 0]
TN = confusion_matrix[1 , 1]

Sensitivity = TP / (TP + FN)

Specificity = TN / (TN + FP)

In [ ]:

Sensitivity

0.5
In [ ]:

Specificity

0.5

ROC Curve
True Positive Rate (TPR), geri çağırma ile eşanlamlıdır ve bu nedenle aşağıdaki gibi tanımlanır:

TPR = TP/(TP+FN)

Yanlış Pozitif Oranı (FPR) şu şekilde tanımlanır:

FPR = FP/(FP+TN)

In [ ]:

fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
fpr[i], tpr[i], _ = roc_curve(Y_val[:, i], Y_pred_conv[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])

plt.figure()
lw = 2
plt.plot(
fpr[2],
tpr[2],
color="darkorange",
lw=lw,
label="ROC curve (area = %0.2f)" % roc_auc[2],
)
plt.plot([0, 1], [0, 1], color="navy", lw=lw, linestyle="--")
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.0])
plt.xlabel("**True positive rate(Sensitivity)**")
plt.ylabel("**False positive rate(1-Specificity)**")
plt.show()
Test
In [ ]:

test_images = os.listdir('/kaggle/working/test_images/test')
X_test = pd.DataFrame({
'test_imagename': test_images
})
samples = X_test.shape[0]

In [ ]:

X_test.count()

test_imagename 12500 dtype: int64

In [ ]:

# 1800 fotoğraf ile test etmek için GPU sorunu:

# X_test_cpu = X_test.sample(n=1800).reset_index()
# X_test_cpu.count()
In [ ]:

test_datagen = ImageDataGenerator(
rescale=1./255
)

In [ ]:

test_generator = test_datagen.flow_from_dataframe(
X_test,
"/kaggle/working/test_images/test",
x_col='test_imagename',
y_col=None,
class_mode=None,
batch_size=batch_size,
target_size=(image_size, image_size),
shuffle=False
)

In [ ]:

test_generator

<keras_preprocessing.image.dataframe_iterator.DataFrameIterator at 0x7ff9840b8750>

Test Verileri Tahmini

In [ ]:

predict = model_mod.predict_generator(test_generator, steps=np.ceil(samples/batch_size))

In [ ]:

predict.shape

(12500, 1)

In [ ]:

X_test.shape

In [ ]:

threshold = 0.5
X_test['Category'] = np.where(predict > threshold, 1,0)

Sonuçlar
In [ ]:

submit = X_test.copy()
submit['id'] = submit['test_imagename'].str.split('.').str[0]
submit['label'] = submit['Category']
submit.drop(['test_imagename', 'Category'], axis=1, inplace=True)
submit.to_csv('submission_vgg16.csv', index=False)

In [ ]:

plt.figure(figsize=(10,5))
sns.countplot(submit['label'])
plt.title("(Final answer on test data (Model - VGG16))")

Text(0.7, 1.7, '(Final answer on test data (Model - VGG16))')