Dijital Kampüs | Kodlama | Teknoloji | Uknay

Giriş
2026'da yapay zeka herkesin dilinde ve Python ekosistemi (Scikit-learn, PyTorch, Transformers) ile erişilebilir hale geldi. Bir yazılım mühendisi olarak ML projeleri artık portföyün vazgeçilmezi. Bu rehberde 3 seviyeli proje zinciri kuracağız:

• Klasik ML → Scikit-learn ile Iris + Titanic tahmini
• Derin öğrenme → PyTorch ile basit CNN (MNIST)
• Modern LLM → Hugging Face ile Türkçe sentiment analizi + fine-tuning

Kodlar 2026 paket sürümleriyle (PyTorch 2.5+, Transformers 4.45+) uyumlu olacak.

Gereksinimler
pip install scikit-learn pandas numpy matplotlib seaborn torch torchvision transformers datasets accelerate
jupyter notebook  # veya VS Code + Jupyter
1. Seviye: Klasik Makine Öğrenmesi (Scikit-learn)
Titanic hayatta kalma tahmini (en popüler beginner dataset).
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
import seaborn as sns
import matplotlib.pyplot as plt

# Veri yükleme (Kaggle'dan indir veya seaborn ile)
df = sns.load_dataset('titanic')

# Basit ön işleme
df = df[['survived', 'pclass', 'sex', 'age', 'sibsp', 'parch', 'fare', 'embarked']]
df['age'].fillna(df['age'].median(), inplace=True)
df['embarked'].fillna('S', inplace=True)
df = pd.get_dummies(df, columns=['sex', 'embarked'], drop_first=True)

X = df.drop('survived', axis=1)
y = df['survived']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

preds = model.predict(X_test)
print("Doğruluk:", accuracy_score(y_test, preds))
print(classification_report(y_test, preds))
İpuçları: GridSearchCV ile hiperparametre optimizasyonu ekle, feature importance görselleştir.

2. Seviye: Derin Öğrenme Giriş (PyTorch + CNN)
MNIST rakam tanıma.
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# Veri
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])

train_dataset = datasets.MNIST('data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('data', train=False, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

# Model
class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.fc1 = nn.Linear(9216, 128)  # 64*12*12 sonrası flatten
        self.fc2 = nn.Linear(128, 10)
   
    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(x, 2)
        x = torch.relu(self.conv2(x))
        x = torch.max_pool2d(x, 2)
        x = torch.flatten(x, 1)
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

model = SimpleCNN()
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

# Eğitim loop
for epoch in range(5):  # 5 epoch yeter demo için
    model.train()
    for data, target in train_loader:
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch+1} tamamlandı")

# Test
model.eval()
correct = 0
with torch.no_grad():
    for data, target in test_loader:
        output = model(data)
        pred = output.argmax(dim=1)
        correct += pred.eq(target).sum().item()

print(f"Doğruluk: {correct / len(test_dataset):.4f}")
İleri adım: GPU kullan (.to('cuda')), TensorBoard ile logla.

3. Seviye: LLM ile Türkçe Sentiment Analizi (Hugging Face)
Türkçe yorumları pozitif/negatif olarak sınıflandırma + fine-tuning.
from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset

# Hazır pipeline ile hızlı başla
sentiment_pipeline = pipeline("sentiment-analysis", model="savasy/bert-base-turkish-sentiment-cased")

ornek_yorumlar = [
    "Bu ürün harika, bayıldım!",
    "Çok kötü, para israfı.",
    "Orta halli, fena değil."
]

for yorum in ornek_yorumlar:
    print(yorum, "→", sentiment_pipeline(yorum)[0]['label'])

# Fine-tuning için örnek (küçük dataset)
dataset = load_dataset("turkish-nlp-suite/turkish-sentiment")  # veya kendi datasetini yükle

tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-turkish-cased")

def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=128)

tokenized_datasets = dataset.map(tokenize_function, batched=True)

model = AutoModelForSequenceClassification.from_pretrained("dbmdz/bert-base-turkish-cased", num_labels=3)  # pos, neg, neu

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["test"],
)

trainer.train()

# Inference
trainer.predict(tokenized_datasets["test"].select(range(5)))
Sonuç ve İleri Adımlar
Bu rehberle Python'da ML/AI'den full pipeline kurmuş oldun. 2026 trendleri:

• LLM fine-tuning için LoRA + PEFT (düşük kaynakta)
• LangChain / LlamaIndex ile RAG sistemleri
• Streamlit veya Gradio ile demo app
• MLOps için MLflow veya BentoML