TensorFlow ile El Yazısı Rakam Tanıma Projesi

Merhaba, makine öğrenimi konusunda projeler ile adım adım ilerlerken çoğunuzun yakından bildiği bir proje üzerinde tensorflow ve model iyileştirme gibi konuları pekiştirme şansı bulacağız. Bu yazıda ünlü MNIST veriseti ile veri kümesinden yararlanarak, el yazısı tanıma projesi gerçekleştirecek ve sonuçları tartışacağız. Vakit kaybetmeden projeye geçelim.

MNIST Veri Kümesini Keşfetmek

El yazısı tanıma, algoritmaların el yazısı karakterleri dikkate değer bir doğruluk ve verimlilikle deşifre etmekle görevlendirildiği bilgisayarlı görme alanında mükemmel bir görev olarak duruyor. 

Modifiye Ulusal Standartlar ve Teknoloji Enstitüsü veritabanının kısaltması olan MNIST veri seti, makine öğrenimi ve görüntü sınıflandırma alanında bir temel taşı olarak duruyor. Özellikle bilgisayarlı görme ve derin öğrenme uygulamaları için makine öğreniminin “Merhaba Dünyası” olarak tanınan MNIST, optik karakter tanıma (OCR) teknolojisinin geliştirilmesi ve değerlendirilmesi için temel bir referans noktası olarak hizmet ediyor.

60.000 eğitim görüntüsü ve 10.000 test görüntüsünden oluşan MNIST, 0’dan 9’a kadar el yazısı rakamlardan oluşan kapsamlı bir koleksiyon sunuyor. Bu görüntüler iki farklı kaynaktan geliyor: Sayım Bürosu çalışanları tarafından yazılan rakamlar ve lise öğrencileri tarafından kaleme alınan rakamlar. MNIST’in yaratıcıları, bu kaynakları birleştirerek, güçlü makine öğrenimi deneylerine olanak sağlayan çeşitli ve temsili bir örnek sağladı.

MNIST veri kümesindeki her görüntü, 28×28 piksellik bir sınırlayıcı kutu içinde yer alan gri tonlamalı bir temsildir. Başlangıçta ikili olan bu görüntüler, grinin çeşitli tonlarını ortaya çıkarmak için işleme tabi tutuldu; böylece yalnızca ikili durumlardan ziyade karmaşık desenleri ayırt edebilen sinir ağlarının eğitimi için uygunlukları arttırıldı.

Veriseti hakkında daha detaylı bilgi –> MNIST Dataset

Tensorflow ile Proje Geliştirme Süreci

Bu proje, gerekli kütüphanelerin içe aktarılmasından modelin performansının değerlendirilmesine kadar adım adım bir geliştirme sürecini takip etmektedir. Modelimizin doğruluğunu ve sağlamlığını artırmak için veri artırma, düzenli hale getirme ve görselleştirme gibi teknikleri keşfedeceğiz. Şimdi her bir adımın detaylarına inelim.

Gerekli kütühaneler ve Verisetinin içe aktarılması

Başlamak için proje boyunca bize yardımcı olacak gerekli kütüphaneleri içe aktarmamız gerekiyor. Veri manipülasyonu için pandaları, sayısal hesaplamalar için numpy’yi, veri görselleştirmesi için matplotlib’i ve modelimizi oluşturmak ve eğitmek için TensorFlow’u içe aktarıyoruz. Ayrıca proje kapsamındaki belirli görevler için TSNE, seaborn ve datetime gibi diğer kütüphaneleri de içe aktarıyoruz.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import math
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.manifold import TSNE
import seaborn as sn
import datetime

Verileri Yükleme ve Ön İşleme

Projemizdeki ilk adım MNIST veri setini yüklemektir. Eğitim ve test verilerini pandas kütüphanesini kullanarak CSV dosyalarından okuyoruz.

train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')

Ardından, özellikleri (piksel değerleri) ve hedef değişkeni (etiketler) eğitim verilerinden ayırıyoruz. Ayrıca piksel değerlerini [0, 1] aralığına normalleştiriyoruz ve görüntüleri bir kanal boyutu içerecek şekilde yeniden şekillendiriyoruz. Bu adım, TensorFlow’un CNN mimarisiyle uyumluluğu sağlar.

X = train.iloc[:, 1:785]
y = train.iloc[:, 0]
X_test = test.iloc[:, 0:784]
X_tsn = X / 255
tsne = TSNE()
tsne_res = tsne.fit_transform(X_tsn)
plt.figure(figsize=(14, 12))
plt.scatter(tsne_res[:,0], tsne_res[:,1], c=y, s=2)
plt.xticks([])
plt.yticks([])
plt.colorbar();

Verileri ön işleme tabi tuttuktan sonra, sklearn’in train_test_split fonksiyonunu kullanarak onu eğitim ve doğrulama setlerine ayırdık. Bu, modelimizin görünmeyen veriler üzerindeki performansını değerlendirmemize olanak tanır.

X_train, X_validation, y_train, y_validation = train_test_split(X, y,
test_size=0.2, random_state=1212)

Verilerin Ön İşlemden Geçirilmesi

Şimdi son bir önişleme yapalım: Görüntü sınıflandırma bağlamında, ön işleme genellikle görüntülerin yeniden şekillendirilmesini ve piksel değerlerinin normalleştirilmesini içerir. MNIST veri kümesini kullanarak görüntü sınıflandırma görevimiz için verileri nasıl önceden işlediğimizi inceleyelim.

x_train_re = X_train.to_numpy().reshape(33600, 28, 28)
y_train_re = y_train.values
x_validation_re = X_validation.to_numpy().reshape(8400, 28, 28)
y_validation_re = y_validation.values
x_test_re = test.to_numpy().reshape(28000, 28, 28)
# Reshape the data to add color channel and normalize
(_, IMAGE_WIDTH, IMAGE_HEIGHT) = x_train_re.shape
IMAGE_CHANNELS = 1
x_train_with_chanels = x_train_re.reshape(
    x_train_re.shape[0],
    IMAGE_WIDTH,
    IMAGE_HEIGHT,
    IMAGE_CHANNELS
)
x_validation_with_chanels = x_validation_re.reshape(
    x_validation_re.shape[0],
    IMAGE_WIDTH,
    IMAGE_HEIGHT,
    IMAGE_CHANNELS
)
x_test_with_chanels = x_test_re.reshape(
    x_test_re.shape[0],
    IMAGE_WIDTH,
    IMAGE_HEIGHT,
    IMAGE_CHANNELS
)
x_train_normalized = x_train_with_chanels / 255
x_validation_normalized = x_validation_with_chanels / 255
x_test_normalized = x_test_with_chanels / 255

Bu ön işleme adımında:

• Veri dizilerini, konvolüsyonel sinir ağımıza (CNN) giriş için doğru boyutlara sahip olduklarından emin olmak için yeniden şekillendiriyoruz. Veri kümesindeki her görüntü 28×28 piksel ızgarası olarak temsil edilir.
• Görüntüler gri tonlamalı olduğu için tek bir kanala sahip olduklarını belirtiyoruz. Renkli görüntüler için tipik olarak üç kanalımız (kırmızı, yeşil ve mavi) olacaktır.
• Piksel değerlerini 255’e bölerek normalleştiriyoruz, bu da onları [0, 1] aralığına ölçeklendiriyor. Normalleştirme, eğitim algoritmasının yakınsamasını iyileştirmeye yardımcı olur ve modeli giriş verilerindeki değişikliklere karşı daha sağlam hale getirir.

Verileri bu şekilde ön işleme tabi tutarak, CNN modelimizi MNIST veri kümesi üzerinde eğitmek için uygun bir formatta olmasını sağlıyoruz. Bu, el yazısı rakamları etkili bir şekilde sınıflandırmak için modelin oluşturulmasına ve eğitilmesine zemin hazırlar.

Tensorflow ile Modeli Oluşturalım

Şimdi heyecan verici kısım geliyor – TensorFlow kullanarak konvolüsyonel sinir ağı modelimizi oluşturmak. Sıralı bir model tanımlıyor ve konvolüsyonel, havuzlama, düzleştirme ve yoğun katmanlar gibi çeşitli katmanlar ekliyoruz. Bu katmanlar, modelin girdi verilerinin hiyerarşik temsillerini öğrenmesine ve doğru tahminler yapmasına yardımcı olur.

model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Convolution2D(
    input_shape=(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS),
    kernel_size=5,
    filters=8,
    strides=1,
    activation=tf.keras.activations.relu,
    kernel_initializer=tf.keras.initializers.VarianceScaling()
))
model.add(tf.keras.layers.MaxPooling2D(
    pool_size=(2, 2),
    strides=(2, 2)
))
model.add(tf.keras.layers.Convolution2D(
    kernel_size=5,
    filters=16,
    strides=1,
    activation=tf.keras.activations.relu,
    kernel_initializer=tf.keras.initializers.VarianceScaling()
))
model.add(tf.keras.layers.MaxPooling2D(
    pool_size=(2, 2),
    strides=(2, 2)
))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(
    units=128,
    activation=tf.keras.activations.relu
))
model.add(tf.keras.layers.Dropout(0.2))
model.add(tf.keras.layers.Dense(
    units=10,
    activation=tf.keras.activations.softmax,
    kernel_initializer=tf.keras.initializers.VarianceScaling()
))

Modelin Derlenmesi ve Eğitimi

Modeli oluşturduktan sonra, optimize ediciyi, kayıp fonksiyonunu ve değerlendirme metriklerini belirleyerek derlememiz gerekir. Bu projede, Adam optimize edicisini, kategorik çapraz entropi kaybını ve değerlendirme ölçütü olarak doğruluğu kullanıyoruz.

adam_optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(
    optimizer=adam_optimizer,
    loss=tf.keras.losses.sparse_categorical_crossentropy,
    metrics=['accuracy']
)
log_dir=".logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
training_history = model.fit(
    x_train_normalized,
    y_train_re,
    epochs=10,
    validation_data=(x_validation_normalized, y_validation_re),
    callbacks=[tensorboard_callback]
)

Modeli 10 epoch boyunca eğittim ve eğitim sürecini izlemek için TensorBoard callback’ini kullandım. TensorBoard, eğitim ve doğrulama doğruluğu, kayıp değerleri ve modelin iç işleyişine dair değerli bilgiler sağlayan görselleştirmeler oluşturmaya olanak tanır.

Eğitim sürecinin sonunda, model eğitim veri setinde %99.30, doğrulama veri setinde ise %98.82 doğruluk oranına ulaştı. Bu sonuçlar, modelin el yazısı rakamları tanımada oldukça başarılı olduğunu gösteriyor.

Kayıp ve Doğruluk Grafiği

# Loss plot curve for training and validation
plt.xlabel('Epoch Number')
plt.ylabel('Accuracy')
plt.plot(training_history.history['loss'], label='training set')
plt.plot(training_history.history['val_loss'], label='validation set')
plt.legend()
plt.show()
# Accuracy plot curve for training and validation
plt.xlabel('Epoch Number')
plt.ylabel('Accuracy')
plt.plot(training_history.history['accuracy'], label='training set')
plt.plot(training_history.history['val_accuracy'], label='validation set')
plt.legend()
plt.show()
# Evaluate the model on the validation set
model.evaluate(x_validation_normalized, y_validation_re)
# Predictions on the validation set
y_pred_probabilities = model.predict(x_validation_normalized)
y_pred = np.argmax(y_pred_probabilities, axis=1)

• Doğruluk Grafiği: Eğitim doğruluğu, epoch sayısıyla birlikte istikrarlı bir şekilde artarak %99.38’e ulaşmıştır. Doğrulama doğruluğu da benzer şekilde artmış ve %98.82’ye ulaşmıştır. Bu, modelin hem eğitim hem de doğrulama veri setlerinde iyi bir performans sergilediğini gösterir.
• Kayıp Grafiği: Hem eğitim hem de doğrulama kayıpları, epoch sayısıyla birlikte azalmıştır. Bu da modelin, el yazısı rakamları sınıflandırmayı giderek daha iyi öğrendiğini gösterir.

Karışıklık matrisi (Confusion Matrix)

Karışıklık matrisi, modelin performansını değerlendirmek ve hangi alanlarda iyileştirme yapılabileceğini belirlemek için oldukça faydalı bir araçtır.

# Confusion matrix
conf_matrix = tf.math.confusion_matrix(labels=y_validation_re, predictions=y_pred).numpy()
# Display confusion matrix
plt.figure(figsize=(10, 7))
sn.heatmap(conf_matrix, annot=True, fmt='d')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.show()

• Genel yüksek doğruluk: Matrisin köşegenindeki yüksek değerler, modelin çoğu rakamı doğru bir şekilde tanıdığını göstermektedir. 813 rakam 0 olarak doğru tahmin edilmiş, 909 rakam 1 olarak doğru tahmin edilmiş ve bu şekilde devam ediyor.
• 5 ve 3 rakamlarında karışıklık: Modelin en sık karıştırdığı rakamlar 5 ve 3’tür. 5 rakam 1 kere 3 olarak yanlış tahmin edilmiş, 3 rakam ise 1 kere 5 olarak yanlış tahmin edilmiş. Bu rakamların benzer şekillere sahip olmasından kaynaklanabilir.
• 9 rakamında bazı karışıklıklar: Model, 9 rakamını 4 ve 7 rakamlarıyla bir miktar karıştırmaktadır. 9 rakam 1 kere 4 olarak yanlış tahmin edilmiş, 4 kere 7 olarak yanlış tahmin edilmiş ve 4 kere de 9 olarak yanlış tahmin edilmiş. Bu, bu rakamların da birbirlerine benzer şekillere sahip olmasından kaynaklanabilir.

Modelin Değerlendirilmesi: Tensorflow değerlendirmesi

Model eğitildikten sonra, doğrulama kümesi üzerindeki performansını değerlendirebiliriz. TensorFlow tarafından sağlanan değerlendirme işlevini kullanarak doğruluğu ve kaybı hesaplıyoruz.

print('Train loss: ', train_loss)
print('Train accuracy: ', train_accuracy)

Train loss:  0.010645214468240738
Train accuracy:  0.9963988065719604

Eğitim kaybı: Eğitim kaybı 0,0106’dır ve bu çok düşük bir değerdir. Bu, modelin eğitim verilerine iyi uyum sağlayabildiğini ve çok fazla hata yapmadığını gösterir.

Eğitim doğruluğu: Eğitim doğruluğu 0,9964’tür ve bu da oldukça yüksektir. Bu, modelin neredeyse tüm eğitim örneklerini doğru şekilde sınıflandırabildiği anlamına gelir.

Test Verileri Üzerinde Tahmin Yapma

Son olarak, eğitilmiş modelimizi kullanarak test verileri üzerinde tahminler yapabiliriz. Test verilerini yeniden şekillendirir ve modelin tahmin işlevinden geçirmeden önce normalleştiririz.

import math
import matplotlib.pyplot as plt
import numpy as np
# Define the number of images to display
numbers_to_display = 196
num_cells = math.ceil(math.sqrt(numbers_to_display))
# Counter to track the number of iterations
iteration_count = 0
# Set up the figure
plt.figure(figsize=(15, 15))
# Loop to display images only three times
while iteration_count < 3:
    # Generate random indices to select images
    random_indices = np.random.choice(len(x_validation_normalized), numbers_to_display, replace=False)
    for plot_index, index in enumerate(random_indices):    
        predicted_label = predictions[index]
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)
        color_map = 'Greens' if predicted_label == y_validation_re[index] else 'Reds'
        plt.subplot(num_cells, num_cells, plot_index + 1)
        plt.imshow(x_validation_normalized[index].reshape((IMAGE_WIDTH, IMAGE_HEIGHT)), cmap=color_map)
        plt.xlabel(predicted_label)
    plt.subplots_adjust(hspace=1, wspace=0.5)
    plt.show()
    # Increment the iteration count
    iteration_count += 1

Görüntülemek istediğimiz resim sayısını tanımlayarak başlıyoruz, bu sayı bizim durumumuzda 196 olarak ayarlanmıştır. Bu sayı ekran ızgaramızın boyutunu belirler. Kod daha sonra üç kez çalışacak bir döngüye girer. Bu sınır, izleyiciyi çok fazla resimle boğmamamızı sağlar.

Döngünün her bir yinelemesinde, doğrulama veri kümesinden 196 görüntüyü değiştirmeden rastgele seçiyoruz. Seçilen her görüntü için modelimizin tahminlerinden öngörülen etiketi alıyoruz. Bu tahminler daha sonra görüntülenen görüntüleri renklendirmek için kullanılır: doğru tahminler yeşil, yanlış olanlar ise kırmızı renkle gösterilir.

Görüntüler, tahmin edilen etiketleriyle birlikte matplotlib kullanılarak bir ızgara düzeninde görüntülenir. Alt grafik düzeni, görüntüler arasında uygun boşluk sağlamak için ayarlanmıştır. Bu görsel temsil, modelin performansını hızlı bir şekilde değerlendirmemize ve iyileştirme için herhangi bir kalıp veya alanı belirlememize olanak tanır.

Görüldüğü gibi tahminler oldukça tatmin edici bu sebeple Tensorflow modelimizi başarılı sayabiliriz.

Tensorflow, Keras ve diğer önemli ML konuları burada

Bu projede, TensorFlow ve MNIST veri kümesini kullanarak el yazısı rakam tanımayı geliştirme sürecini araştırdık. Kütüphaneleri içe aktarmaktan başlayarak modelin performansını değerlendirmeye kadar adım adım bir yaklaşım izledik. Konvolüsyonel sinir ağlarından yararlanarak modelimizde etkileyici bir doğruluk ve sağlamlık elde ettik.

Makine öğreniminde adım adım projeler gerçekleştirerek bunları burada yayınlamaya çalışacağım. Bazen kütüphaneleri, bazen modelleri bazen yeni araçları burada sizlerle paylaşacağım. Yolun henüz başındayım bu sebeple hatalarım, eksiklerim ve bilmediklerim konusunda hoşgörünüzü bekliyorum. Teşekkürler, bizi takip etmeye devam edin!

Herkese sağlıklı günler.

Kaynak ve Proje Dosyaları

• Kaggle Notebook
  
• MNIST Dataset