PyTorch ile evrişimli sinir ağı nasıl kurulur?

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

# İşlemci veya kullanılabilir CUDA aygıtını seç
cihaz = "cuda" if torch.cuda.is_available() else "cpu"
print("Kullanılan aygıt:", cihaz)

# Eğitim ve test verilerini yükle
transform = ToTensor()

train_data = datasets.MNIST(
    root="data",
    train=True,
    download=True,
    transform=transform,
)

test_data = datasets.MNIST(
    root="data",
    train=False,
    download=True,
    transform=transform,
)

train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=64, shuffle=False)

class EvrisimliAg(nn.Module):
    def __init__(self):
        super().__init__()
        self.ozellikler = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        self.siniflandirici = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 7 * 7, 128),
            nn.ReLU(),
            nn.Linear(128, 10),
        )

    def forward(self, x):
        x = self.ozellikler(x)
        return self.siniflandirici(x)

model = EvrisimliAg().to(cihaz)
kayip_fonksiyonu = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

def egit(model, veri_yukleyici, kayip_fonksiyonu, optimizer):
    model.train()
    toplam_kayip = 0.0

    for goruntuler, etiketler in veri_yukleyici:
        goruntuler = goruntuler.to(cihaz)
        etiketler = etiketler.to(cihaz)

        tahminler = model(goruntuler)
        kayip = kayip_fonksiyonu(tahminler, etiketler)

        optimizer.zero_grad()
        kayip.backward()
        optimizer.step()

        toplam_kayip += kayip.item()

    return toplam_kayip / len(veri_yukleyici)

def test_et(model, veri_yukleyici, kayip_fonksiyonu):
    model.eval()
    toplam_kayip = 0.0
    dogru = 0
    toplam = 0

    with torch.no_grad():
        for goruntuler, etiketler in veri_yukleyici:
            goruntuler = goruntuler.to(cihaz)
            etiketler = etiketler.to(cihaz)

            tahminler = model(goruntuler)
            toplam_kayip += kayip_fonksiyonu(tahminler, etiketler).item()
            dogru += (tahminler.argmax(dim=1) == etiketler).sum().item()
            toplam += etiketler.size(0)

    ortalama_kayip = toplam_kayip / len(veri_yukleyici)
    dogruluk = 100 * dogru / toplam
    return ortalama_kayip, dogruluk

for donem in range(1, 4):
    egitim_kaybi = egit(
        model,
        train_loader,
        kayip_fonksiyonu,
        optimizer,
    )
    test_kaybi, test_dogrulugu = test_et(
        model,
        test_loader,
        kayip_fonksiyonu,
    )
    print(
        f"Dönem {donem}: "
        f"eğitim kaybı={egitim_kaybi:.4f}, "
        f"test kaybı={test_kaybi:.4f}, "
        f"test doğruluğu={test_dogrulugu:.2f}%"
    )

# Bir test görüntüsü için örnek tahmin
model.eval()
goruntu, gercek_etiket = test_data[0]
with torch.no_grad():
    skorlar = model(goruntu.unsqueeze(0).to(cihaz))
    tahmin = skorlar.argmax(dim=1).item()

print("Gerçek etiket:", gercek_etiket)
print("Tahmin edilen etiket:", tahmin)