Derin Öğrenme Nedir?
Derin öğrenme (Deep Learning), makine öğrenmesinin bir alt dalıdır ve insan beyninin nöron ağlarından ilham alan yapay sinir ağlarını (Artificial Neural Networks - ANN) kullanır. "Derin" terimi, bu ağların birden fazla gizli katmana sahip olmasından gelir. Geleneksel makine öğrenmesi yöntemlerinden farklı olarak, derin öğrenme modelleri ham verilerden otomatik olarak özellik çıkarımı yapabilir ve karmaşık kalıpları öğrenebilir.
Derin öğrenme, özellikle büyük veri setleri ve yüksek hesaplama gücü mevcut olduğunda, görüntü tanıma, doğal dil işleme, konuşma tanıma ve oyun oynama gibi alanlarda çığır açan başarılar elde etmiştir. AlphaGo'nun Go oyununda dünya şampiyonunu yenmesi, GPT modellerinin doğal dil üretimi ve ChatGPT gibi uygulamaların yaygınlaşması, derin öğrenmenin gücünü gösteren örneklerdir.
Yapay Sinir Ağlarının Temelleri
Yapay sinir ağları, biyolojik nöronların matematiksel modellemesidir. Temel yapı taşı olan yapay nöron (perceptron), birden fazla girdiyi alır, bunları ağırlıklandırır, toplar ve bir aktivasyon fonksiyonu uygulayarak çıktı üretir.
Bir sinir ağı genellikle şu katmanlardan oluşur:
1.Girdi Katmanı (Input Layer): Ham veriyi alan katman
2.Gizli Katmanlar (Hidden Layers): Veriyi işleyen ve özellik çıkarımı yapan katmanlar
3.Çıktı Katmanı (Output Layer): Final tahminleri üreten katman
Derin Öğrenmenin Avantajları
•Otomatik Özellik Çıkarımı: Manuel özellik mühendisliği gerektirmez
•Karmaşık Kalıpları Öğrenme: Doğrusal olmayan ilişkileri modelleyebilir
•Büyük Veri ile Ölçeklenebilirlik: Daha fazla veri ile performans artar
•Transfer Learning: Önceden eğitilmiş modelleri yeni görevlere uyarlayabilir
Derin Öğrenmenin Dezavantajları
•Yüksek Hesaplama Maliyeti: GPU/TPU gibi özel donanım gerektirir
•Büyük Veri Gereksinimi: Etkili öğrenme için çok miktarda veri gerekir
•Kara Kutu Problemi: Modelin karar verme süreci anlaşılması zor
•Aşırı Öğrenme (Overfitting) Riski: Karmaşık modeller eğitim verisini ezberleyebilir
TensorFlow'a Giriş
TensorFlow, Google tarafından geliştirilen açık kaynaklı bir derin öğrenme kütüphanesidir. Hem araştırma hem de üretim ortamları için tasarlanmış olup, ölçeklenebilir makine öğrenmesi modelleri oluşturmak için kapsamlı araçlar sunar.
TensorFlow'un Temel Özellikleri
•Esnek Mimari: CPU, GPU ve TPU'larda çalışabilir
•Keras API: Yüksek seviyeli, kullanıcı dostu API
•TensorBoard: Model görselleştirme ve izleme aracı
•TensorFlow Serving: Üretim ortamında model dağıtımı
•TensorFlow Lite: Mobil ve gömülü cihazlar için optimize edilmiş
TensorFlow Kurulumu
Bash
pip install tensorflow
Basit Bir Sinir Ağı Örneği (TensorFlow/Keras)
Aşağıda, MNIST el yazısı rakam tanıma veri seti üzerinde basit bir sinir ağı eğitimi örneği bulunmaktadır:
Python
import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
# Veri setini yükleme
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
# Veri ön işleme
x_train = x_train.astype('float32') / 255.0 # Normalizasyon (0-1 aralığına)
x_test = x_test.astype('float32') / 255.0
# Veri şeklini düzenleme (28x28 -> 784)
x_train = x_train.reshape(-1, 28*28)
x_test = x_test.reshape(-1, 28*28)
print(f"Eğitim veri şekli: {x_train.shape}")
print(f"Test veri şekli: {x_test.shape}")
# Model oluşturma
model = keras.Sequential([
keras.layers.Dense(128, activation='relu', input_shape=(784,)),
keras.layers.Dropout(0.2), # Aşırı öğrenmeyi önlemek için
keras.layers.Dense(64, activation='relu'),
keras.layers.Dropout(0.2),
keras.layers.Dense(10, activation='softmax') # 10 sınıf (0-9 rakamları)
])
# Model derleme
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Model özetini görüntüleme
model.summary()
# Model eğitimi
history = model.fit(x_train, y_train,
epochs=10,
batch_size=32,
validation_split=0.1,
verbose=1)
# Model değerlendirme
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
print(f"Test doğruluğu: {test_accuracy:.4f}")
# Eğitim geçmişini görselleştirme
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Eğitim Doğruluğu')
plt.plot(history.history['val_accuracy'], label='Doğrulama Doğruluğu')
plt.title('Model Doğruluğu')
plt.xlabel('Epoch')
plt.ylabel('Doğruluk')
plt.legend()
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Eğitim Kaybı')
plt.plot(history.history['val_loss'], label='Doğrulama Kaybı')
plt.title('Model Kaybı')
plt.xlabel('Epoch')
plt.ylabel('Kayıp')
plt.legend()
plt.tight_layout()
plt.show()
# Tahmin yapma
predictions = model.predict(x_test[:5])
predicted_classes = np.argmax(predictions, axis=1)
actual_classes = y_test[:5]
print("İlk 5 test örneği için tahminler:")
for i in range(5):
print(f"Gerçek: {actual_classes[i]}, Tahmin: {predicted_classes[i]}")
PyTorch'a Giriş
PyTorch, Facebook (Meta) tarafından geliştirilen açık kaynaklı bir derin öğrenme kütüphanesidir. Dinamik hesaplama grafikleri ve Pythonic API'si ile araştırmacılar arasında çok popülerdir.
PyTorch'un Temel Özellikleri
•Dinamik Hesaplama Grafikleri: Çalışma zamanında graf oluşturma
•Pythonic API: Python'a doğal entegrasyon
•Güçlü GPU Desteği: CUDA ile hızlandırma
•TorchScript: Üretim ortamı için model optimizasyonu
•Geniş Ekosistem: TorchVision, TorchText, TorchAudio
PyTorch Kurulumu
Bash
pip install torch torchvision torchaudio
Basit Bir Sinir Ağı Örneği (PyTorch)
Aynı MNIST veri seti üzerinde PyTorch kullanarak bir sinir ağı eğitimi:
Python
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
# Cihaz seçimi (GPU varsa kullan)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Kullanılan cihaz: {device}")
# Veri dönüşümleri
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,)) # MNIST için standart normalizasyon
])
# Veri setlerini yükleme
train_dataset = datasets.MNIST('data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('data', train=False, transform=transform)
# Veri yükleyicileri
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)
# Sinir ağı modeli tanımlama
class SimpleNN(nn.Module):
def __init__(self):
super(SimpleNN, self).__init__()
self.fc1 = nn.Linear(28*28, 128)
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 10)
self.dropout = nn.Dropout(0.2)
def forward(self, x):
x = x.view(-1, 28*28) # Düzleştirme
x = F.relu(self.fc1(x))
x = self.dropout(x)
x = F.relu(self.fc2(x))
x = self.dropout(x)
x = self.fc3(x)
return F.log_softmax(x, dim=1)
# Model, kayıp fonksiyonu ve optimizör
model = SimpleNN().to(device)
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# Eğitim fonksiyonu
def train(model, device, train_loader, optimizer, criterion, epoch):
model.train()
total_loss = 0
correct = 0
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
total_loss += loss.item()
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
if batch_idx % 100 == 0:
print(f'Epoch {epoch}, Batch {batch_idx}, Loss: {loss.item():.6f}')
avg_loss = total_loss / len(train_loader)
accuracy = 100. * correct / len(train_loader.dataset)
return avg_loss, accuracy
# Test fonksiyonu
def test(model, device, test_loader, criterion):
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
test_loss += criterion(output, target).item()
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader)
accuracy = 100. * correct / len(test_loader.dataset)
return test_loss, accuracy
# Model eğitimi
epochs = 10
train_losses, train_accuracies = [], []
test_losses, test_accuracies = [], []
for epoch in range(1, epochs + 1):
train_loss, train_acc = train(model, device, train_loader, optimizer, criterion, epoch)
test_loss, test_acc = test(model, device, test_loader, criterion)
train_losses.append(train_loss)
train_accuracies.append(train_acc)
test_losses.append(test_loss)
test_accuracies.append(test_acc)
print(f'Epoch {epoch}: Train Acc: {train_acc:.2f}%, Test Acc: {test_acc:.2f}%')
# Sonuçları görselleştirme
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(train_accuracies, label='Eğitim Doğruluğu')
plt.plot(test_accuracies, label='Test Doğruluğu')
plt.title('Model Doğruluğu')
plt.xlabel('Epoch')
plt.ylabel('Doğruluk (%)')
plt.legend()
plt.subplot(1, 2, 2)
plt.plot(train_losses, label='Eğitim Kaybı')
plt.plot(test_losses, label='Test Kaybı')
plt.title('Model Kaybı')
plt.xlabel('Epoch')
plt.ylabel('Kayıp')
plt.legend()
plt.tight_layout()
plt.show()
TensorFlow vs PyTorch Karşılaştırması
Özellik | TensorFlow | PyTorch |
Öğrenme Eğrisi | Orta-Zor | Kolay |
API Tasarımı | Keras ile yüksek seviye | Pythonic, sezgisel |
Hesaplama Grafikleri | Statik (TF 2.0'da dinamik) | Dinamik |
Üretim Desteği | Mükemmel (TF Serving) | İyi (TorchScript) |
Topluluk | Büyük, endüstri odaklı | Büyük, araştırma odaklı |
Görselleştirme | TensorBoard | TensorBoard, Visdom |
Mobil Destek | TensorFlow Lite | PyTorch Mobile |
Masaüstü Uygulamalarında Derin Öğrenme
Derin öğrenme modellerini masaüstü uygulamalarına entegre etmek için çeşitli yaklaşımlar mevcuttur:
1. Model Kaydetme ve Yükleme
TensorFlow:
Python
# Model kaydetme
model.save('my_model.h5')
# Model yükleme
loaded_model = keras.models.load_model('my_model.h5')
PyTorch:
Python
# Model kaydetme
torch.save(model.state_dict(), 'model_weights.pth')
# Model yükleme
model = SimpleNN()
model.load_state_dict(torch.load('model_weights.pth'))
model.eval()
2. Basit Masaüstü Uygulaması Örneği
Tkinter kullanarak basit bir görüntü sınıflandırma uygulaması:
Python
import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image, ImageTk
import numpy as np
import tensorflow as tf
class ImageClassifierApp:
def __init__(self, root):
self.root = root
self.root.title("Derin Öğrenme Görüntü Sınıflandırıcı")
self.root.geometry("600x500")
# Önceden eğitilmiş modeli yükle
try:
self.model = tf.keras.models.load_model('my_model.h5')
self.model_loaded = True
except:
self.model_loaded = False
messagebox.showerror("Hata", "Model dosyası bulunamadı!")
self.setup_ui()
def setup_ui(self):
# Başlık
title_label = tk.Label(self.root, text="Görüntü Sınıflandırıcı",
font=("Arial", 16, "bold"))
title_label.pack(pady=10)
# Görüntü seçme butonu
select_btn = tk.Button(self.root, text="Görüntü Seç",
command=self.select_image,
font=("Arial", 12))
select_btn.pack(pady=10)
# Görüntü gösterme alanı
self.image_label = tk.Label(self.root, text="Görüntü seçilmedi",
width=40, height=15, bg="lightgray")
self.image_label.pack(pady=10)
# Tahmin butonu
predict_btn = tk.Button(self.root, text="Tahmin Et",
command=self.predict_image,
font=("Arial", 12), state="disabled")
predict_btn.pack(pady=10)
self.predict_btn = predict_btn
# Sonuç gösterme alanı
self.result_label = tk.Label(self.root, text="",
font=("Arial", 14, "bold"))
self.result_label.pack(pady=10)
self.selected_image_path = None
def select_image(self):
file_path = filedialog.askopenfilename(
title="Görüntü Seç",
filetypes=[("Görüntü dosyaları", "*.png *.jpg *.jpeg *.bmp *.gif")]
)
if file_path:
self.selected_image_path = file_path
self.display_image(file_path)
if self.model_loaded:
self.predict_btn.config(state="normal")
def display_image(self, image_path):
# Görüntüyü yükle ve yeniden boyutlandır
image = Image.open(image_path)
image = image.resize((200, 200), Image.Resampling.LANCZOS)
photo = ImageTk.PhotoImage(image)
# Görüntüyü göster
self.image_label.config(image=photo, text="")
self.image_label.image = photo # Referansı koru
def predict_image(self):
if not self.selected_image_path or not self.model_loaded:
return
try:
# Görüntüyü model için hazırla
image = Image.open(self.selected_image_path)
image = image.resize((28, 28)) # MNIST için 28x28
image = image.convert('L') # Gri tonlama
image_array = np.array(image) / 255.0
image_array = image_array.reshape(1, 28*28)
# Tahmin yap
prediction = self.model.predict(image_array)
predicted_class = np.argmax(prediction)
confidence = np.max(prediction) * 100
# Sonucu göster
result_text = f"Tahmin: {predicted_class}\nGüven: {confidence:.1f}%"
self.result_label.config(text=result_text)
except Exception as e:
messagebox.showerror("Hata", f"Tahmin yapılırken hata oluştu: {str(e)}")
if __name__ == "__main__":
root = tk.Tk()
app = ImageClassifierApp(root)
root.mainloop()
Sonuç
Bu derste, derin öğrenmenin temel kavramlarını ve TensorFlow ile PyTorch kütüphanelerinin nasıl kullanılacağını öğrendiniz. Derin öğrenme, karmaşık problemleri çözmek için güçlü bir araçtır ve masaüstü uygulamalarınıza akıllı özellikler kazandırabilir. Bir sonraki derslerde, görüntü işleme ve doğal dil işleme gibi spesifik uygulama alanlarını inceleyeceğiz.