Yapay Zeka & Machine Learning

Yapay Zeka Nedir?

Yapay Zeka (AI), makinelerin insan benzeri düşünme, öğrenme ve problem çözme yetenekleri sergilemesini sağlayan teknoloji alanıdır. AI, bilgisayarların algısal verileri işleyerek akıllı davranışlar sergilemesine olanak tanır.

AI Tarihçesi

AI terimi ilk kez 1956'da John McCarthy tarafından Dartmouth Konferansı'nda kullanıldı. O zamandan beri AI, uzman sistemlerden günümüzün derin öğrenme algoritmalarına kadar büyük bir evrim geçirdi.

AI'nın Ana Dalları:

Machine Learning: Veriden öğrenme
Deep Learning: Çok katmanlı sinir ağları
Natural Language Processing: Doğal dil işleme
Computer Vision: Görüntü işleme ve tanıma
Robotics: Otonom sistemler
Expert Systems: Uzman sistem tabanlı AI

Python AI Kütüphaneleri: TensorFlow, PyTorch, Keras, Scikit-learn, OpenCV, NLTK, Pandas, NumPy temel araçlardır.

AI sistemleri, makine öğrenmesi algoritmaları kullanarak verilerden destenler çıkarır ve gelecekteki durumlar için tahminler yapar. Bu süreç, geleneksel programlama yaklaşımından farklı olarak, açık kurallar yazmak yerine sistemin verilerden öğrenmesine dayanır.

Machine Learning Temelleri

Machine Learning (ML), bilgisayarların açıkça programlanmadan verilerden öğrenme yeteneğidir. ML algoritmaları, büyük veri setlerindeki kalıpları tanır ve bu kalıpları kullanarak yeni veriler hakkında tahminler yapar.

ML İş Akışı

1. Veri Toplama → 2. Veri Ön İşleme → 3. Model Seçimi → 4. Eğitim → 5. Değerlendirme → 6. Dağıtım

ML Öğrenme Türleri

Gözetimli Öğrenme: Etiketli verilerle eğitim
Gözetimsiz Öğrenme: Etiket olmadan desen bulma
Pekiştirmeli Öğrenme: Ödül-ceza sistemi ile öğrenme

Scikit-learn ile ML'e Başlangıç

Scikit-learn, Python'da machine learning için en popüler kütüphanedir. Basit ve etkili veri analizi araçları sunar ve machine learning algoritmalarının çoğunu içerir.

Kurulum: pip install scikit-learn

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Örnek veri seti yükle
boston = datasets.load_boston()
X, y = boston.data, boston.target

# Eğitim ve test verilerini ayır
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Model oluştur ve eğit
model = LinearRegression()
model.fit(X_train, y_train)

# Tahmin yap
predictions = model.predict(X_test)
mse = mean_squared_error(y_test, predictions)
print(f"Ortalama Kare Hatası: {mse:.2f}")

Scikit-learn'ün Temel Modülleri:

sklearn.datasets - Örnek veri setleri
sklearn.preprocessing - Veri ön işleme
sklearn.model_selection - Model seçimi
sklearn.metrics - Performans metrikleri
sklearn.linear_model - Lineer modeller
sklearn.ensemble - Topluluk yöntemleri

Gözetimli Öğrenme Algoritmaları

Gözetimli öğrenme, etiketli veriler kullanarak modelleri eğitir. Hedef değişken (target) bilinen verilerle algoritma öğrenir ve yeni veriler için tahminler yapar.

Lineer Regresyon

from sklearn.linear_model import LinearRegression
import numpy as np
import matplotlib.pyplot as plt

# Örnek veri
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

# Model oluştur ve eğit
model = LinearRegression()
model.fit(X, y)

# Tahmin
prediction = model.predict([[6]])
print(f"6 için tahmin: {prediction[0]:.2f}")

Lojistik Regresyon

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

# İris veri seti
iris = load_iris()
X, y = iris.data, iris.target

# Lojistik regresyon
log_model = LogisticRegression()
log_model.fit(X, y)

# Doğruluk skoru
accuracy = log_model.score(X, y)
print(f"Doğruluk: {accuracy:.3f}")

Karar Ağaçları ve Random Forest

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

# Karar ağacı
tree_model = DecisionTreeClassifier(random_state=42)
tree_model.fit(X_train, y_train)

# Random Forest
rf_model = RandomForestClassifier(n_estimators=100)
rf_model.fit(X_train, y_train)

print(f"RF Doğruluk: {rf_model.score(X_test, y_test):.3f}")

Algoritma Seçimi İpuçları

Küçük veri: Lojistik/Lineer Regresyon
Yüksek boyutlu: SVM, Random Forest
Yorumlanabilirlik: Karar Ağaçları
Yüksek performans: Gradient Boosting

Gözetimsiz Öğrenme

Gözetimsiz öğrenme, etiket bilgisi olmadan verilerden gizli kalıpları keşfetmeye odaklanır. Kümeleme ve boyut indirgeme en yaygın gözetimsiz öğrenme yöntemleridir.

K-Means Kümeleme

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Örnek veri oluştur
X = np.random.rand(100, 2) * 10

# K-Means kümeleme
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X)

# Sonuçları görselleştir
plt.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis')
plt.scatter(kmeans.cluster_centers_[:, 0], 
           kmeans.cluster_centers_[:, 1], 
           c='red', marker='x', s=200)
plt.title("K-Means Kümeleme")
plt.show()

Principal Component Analysis (PCA)

from sklearn.decomposition import PCA

# PCA ile boyut indirgeme
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(iris.data)

print(f"Açıklanan varyans oranı: {pca.explained_variance_ratio_}")
print(f"Toplam açıklanan varyans: {sum(pca.explained_variance_ratio_):.3f}")

Model Değerlendirme Metrikleri

Machine learning modellerinin performansını değerlendirmek için çeşitli metrikler kullanılır. Hangi metriği kullanacağınız, probleminizin türüne bağlıdır.

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import confusion_matrix, classification_report, roc_curve

# Sınıflandırma metrikleri
y_true = [0, 1, 1, 0, 1]
y_pred = [0, 1, 0, 0, 1]

accuracy = accuracy_score(y_true, y_pred)
precision = precision_score(y_true, y_pred)
recall = recall_score(y_true, y_pred)
f1 = f1_score(y_true, y_pred)

print(f"Doğruluk: {accuracy:.3f}")
print(f"Kesinlik: {precision:.3f}")
print(f"Duyarlılık: {recall:.3f}")
print(f"F1 Skoru: {f1:.3f}")

Metrik Açıklamaları:

Doğruluk (Accuracy): Doğru tahminlerin oranı
Kesinlik (Precision): Pozitif tahminlerin doğru olma oranı
Duyarlılık (Recall): Gerçek pozitiflerin yakalanma oranı
F1 Skoru: Precision ve Recall'un harmonik ortalaması
ROC Eğrisi: True Positive Rate vs False Positive Rate

Confusion Matrix

Confusion Matrix, sınıflandırma problemlerinde modelin hangi sınıfları nasıl tahmin ettiğini gösterir:
confusion_matrix(y_true, y_pred)

Deep Learning'e Giriş

Deep Learning, çok katmanlı yapay sinir ağları kullanarak karmaşık kalıpları öğrenen machine learning alt dalıdır. İnsan beynindeki nöronları taklit eden yapılar kullanır.

Deep Learning vs Classical ML

Deep Learning: Otomatik özellik çıkarımı, büyük veri gerektir
Classical ML: Manuel özellik mühendisliği, küçük veri ile çalışabilir

TensorFlow ile Derin Öğrenme

TensorFlow, Google tarafından geliştirilen açık kaynaklı bir machine learning platformudur. Özellikle derin öğrenme uygulamaları için güçlü araçlar sunar.

Kurulum: pip install tensorflow

import tensorflow as tf
from tensorflow import keras

# Basit bir sinir ağı
model = keras.Sequential([
    keras.    layers.Dense(128, activation='relu', input_shape=(784,)),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')
])

# Modeli derle
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Eğitim
model.fit(x_train, y_train, epochs=5, batch_size=128)

GPU Kullanımı: TensorFlow GPU desteği için pip install tensorflow-gpu veya CUDA kurulumu gerekebilir.

Yapay Sinir Ağları (ANN)

Yapay Sinir Ağları, insan beynindeki nöronları taklit eden matematiksel modellerdir. Her nöron, girdileri alır, işler ve çıktı üretir.

Aktivasyon Fonksiyonları

import numpy as np
import matplotlib.pyplot as plt

# Aktivasyon fonksiyonları
def relu(x):
    return np.maximum(0, x)

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def tanh(x):
    return np.tanh(x)

# Test verileri
x = np.linspace(-5, 5, 100)

plt.figure(figsize=(12, 4))
plt.subplot(1, 3, 1)
plt.plot(x, relu(x))
plt.title('ReLU')
plt.grid(True)

Kayıp Fonksiyonları

Yaygın Kayıp Fonksiyonları:

Mean Squared Error (MSE): Regresyon problemleri
Cross-Entropy: Sınıflandırma problemleri
Binary Cross-Entropy: İkili sınıflandırma
Huber Loss: Outlier'lara dayanıklı regresyon

Optimizasyon Algoritmaları

from tensorflow.keras import optimizers

# Farklı optimizer'lar
sgd = optimizers.SGD(learning_rate=0.01)
adam = optimizers.Adam(learning_rate=0.001)
rmsprop = optimizers.RMSprop(learning_rate=0.001)

# Model derleme
model.compile(optimizer=adam, loss='categorical_crossentropy')

Optimizer Karşılaştırması

SGD: Basit, yavaş konvergans
Adam: Hızlı, yaygın kullanım
RMSprop: RNN'ler için uygun

Evrişimli Sinir Ağları (CNN)

Convolutional Neural Networks (CNN), görüntü işleme ve bilgisayarlı görü uygulamaları için özelleşmiş sinir ağı mimarisidir. CNN'ler, görüntülerdeki yerel özellikleri tespit etmek için evrişim (convolution) işlemi kullanır.

from tensorflow.keras import layers, models

# CNN modeli
cnn_model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D(2, 2),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D(2, 2),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

cnn_model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

CNN Katman Türleri:

Conv2D: Evrişim katmanı - özellik çıkarımı
MaxPooling2D: Boyut azaltma ve özellik seçimi
Flatten: 2D'den 1D'ye dönüştürme
Dense: Tam bağlantılı katman
Dropout: Overfitting önleme

CNN Uygulama Alanları

Görüntü Tanıma: Nesne, yüz, el yazısı
Medikal Görüntüleme: X-ray, MRI analizi
Otonom Araçlar: Yol işaretleri, nesne tespiti

Tekrarlayan Sinir Ağları (RNN, LSTM, GRU)

Recurrent Neural Networks (RNN), sıralı verilerle çalışmak için tasarlanmış sinir ağlarıdır. Geçmiş bilgileri hatırlayarak gelecek tahminler yapabilir.

from tensorflow.keras import layers, models

# LSTM modeli
lstm_model = models.Sequential([
    layers.LSTM(50, return_sequences=True, input_shape=(timesteps, features)),
    layers.Dropout(0.2),
    layers.LSTM(50, return_sequences=False),
    layers.Dropout(0.2),
    layers.Dense(1)
])

lstm_model.compile(optimizer='adam', loss='mse')

# GRU alternatifi
gru_model = models.Sequential([
    layers.GRU(50, return_sequences=True),
    layers.GRU(50),
    layers.Dense(1)
])

RNN Varyantları:

Vanilla RNN: Temel yapı, vanishing gradient sorunu
LSTM: Long Short-Term Memory, uzun dönem bağımlılık
GRU: Gated Recurrent Unit, LSTM'in basitleştirilmiş hali
Bidirectional RNN: İki yönlü işleme

RNN Uygulama Alanları

Doğal Dil İşleme: Metin üretimi, çeviri
Zaman Serisi: Hisse senedi, hava durumu tahmini
Ses İşleme: Konuşma tanıma, müzik analizi

Transformer Mimarisi

Transformer, "Attention is All You Need" makalesi ile tanıtılan ve modern AI'nın temelini oluşturan mimaridir. GPT, BERT gibi büyük dil modelleri Transformer tabanlıdır.

Transformer Yapısı

Input Embeddings → Positional Encoding → Multi-Head Attention → Feed Forward → Output

import torch
import torch.nn as nn

class SimpleTransformer(nn.Module):
    def __init__(self, vocab_size, d_model, nhead, num_layers):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.transformer = nn.Transformer(
            d_model=d_model,
            nhead=nhead,
            num_encoder_layers=num_layers,
            num_decoder_layers=num_layers
        )
        self.fc = nn.Linear(d_model, vocab_size)
        
    def forward(self, src, tgt):
        src = self.embedding(src)
        tgt = self.embedding(tgt)
        output = self.transformer(src, tgt)
        return self.fc(output)

Transformer Avantajları

Paralelleştirme: RNN'lere göre daha hızlı eğitim
Attention Mechanism: Uzun mesafeli bağımlılıkları yakalama
Transfer Learning: Önceden eğitilmiş modeller

İleri Düzey Konular ve Pratikler

AI ve ML alanında derinleşmek için aşağıdaki konuları inceleyin ve bol bol pratik yapın:

İleri Konular:

Transfer Learning: Önceden eğitilmiş modelleri kullanma
Generative AI: GANs, VAEs, Diffusion modelleri
Reinforcement Learning: Q-Learning, Policy Gradients
MLOps: Model deployment ve monitoring
Federated Learning: Dağıtık öğrenme
Explainable AI: Model yorumlanabilirliği

Etik Considerations: AI modellerinizde bias, fairness ve privacy konularını göz önünde bulundurun. Responsible AI principles'a uygun geliştirme yapın.

Proje Önerileri

Başlangıç: İris sınıflandırması, house price prediction
Orta: Handwritten digit recognition, sentiment analysis
İleri: Object detection, chatbot, recommendation system

Öğrenmeye Devam İçin:
• Kaggle yarışmalarına katılın
• Papers With Code'da son makaleleri takip edin
• GitHub'da açık kaynak projelere katkıda bulunun
• Google Colab ile ücretsiz GPU kullanın

# Kapsamlı bir ML projesi için temel şablon
import pandas as pd
import numpy as np
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

# Pipeline kullanarak daha organize kod
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', RandomForestClassifier())
])

# Cross-validation ile model performansı
cv_scores = cross_val_score(pipeline, X, y, cv=5)
print(f"CV Ortalama: {cv_scores.mean():.3f} (+/- {cv_scores.std() * 2:.3f})")

AI Yolculuğunuza Başlayın!

Son Öneriler

Teori + Pratik: Algoritmaları anlayın, sonra uygulayın
Veri kalitesi: İyi veri, iyi model demektir
Sabırlı olun: AI öğrenmek maraton, sprint değildir
Topluluk: AI/ML topluluklarına katılın ve networking yapın
Güncel kalın: AI hızla gelişen bir alan

import future
from AI import success

Yapay zeka ile geleceği şekillendirin!

PyTorch ile Dinamik Neural Networks

PyTorch, Facebook (Meta) tarafından geliştirilen ve dinamik hesaplama grafikleri sunan deep learning kütüphanesidir. Araştırma topluluğunda çok popülerdir.

Kurulum: pip install torch torchvision

import torch
import torch.nn as nn
import torch.optim as optim

# Basit neural network tanımı
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# Model oluştur
model = SimpleNet()
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

print(model)

TensorFlow vs PyTorch

TensorFlow: Üretim odaklı, geniş ekosistem
PyTorch: Araştırma odaklı, kolay debugging
Ortak: GPU desteği, otomatik türev hesabı

Keras: Kolay Deep Learning

Keras, deep learning modellerini hızlı bir şekilde prototipleştirmek için tasarlanmış yüksek seviye bir API'dir. TensorFlow 2.0 ile birlikte entegre edilmiştir.

import tensorflow.keras as keras
from tensorflow.keras import layers

# MNIST el yazısı rakam tanıma
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Veri ön işleme
x_train = x_train.reshape(60000, 784).astype('float32') / 255
x_test = x_test.reshape(10000, 784).astype('float32') / 255

# Model oluştur
model = keras.Sequential([
    layers.Dense(128, activation='relu', input_shape=(784,)),
    layers.Dropout(0.2),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')
])

# Model derle
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Model eğit
history = model.fit(
    x_train, y_train,
    epochs=5,
    batch_size=128,
    validation_data=(x_test, y_test)
)

# Değerlendir
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test accuracy: {test_acc:.4f}')

Keras Avantajları

Kolay Kullanım: Minimal kod ile güçlü modeller
Hızlı Prototipleme: Araştırma için ideal
TensorFlow Entegrasyonu: Güçlü backend desteği