Sinirsel evrimsel bilimler

[dogukankeceli]

'''
Deep Learning Türkiye topluluğu tarafından hazırlanmıştır.

Amaç: El yazısı rakamların tanınması.
Veriseti: MNIST (http://yann.lecun.com/exdb/mnist/)
Algoritma: Evrişimli Sinir Ağları (Convolutional Neural Networks)

10 epoch sonunda testde 98% doğruluk oranı elde edilmiştir.

Nasıl çalıştırılır ?
python main.py
CUDA_VISIBLE_DEVICES=2 python main.py # İstenilen GPU'da çalıştırmak için.
'''

Gerekli kütüphanelerin dahil edilmesi:

from future import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable

Terminal komutundan alınan bilginin işlenmesi:

parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=10, metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=10, metavar='N',
help='how many batches to wait before logging training status')
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available() # Cuda var mı diye kontrol edilir.

Rastgele sayı üretmek için:

torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)

MNIST verisetini içe aktarılması:

kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data', train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])),
batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data', train=False, transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])),
batch_size=args.test_batch_size, shuffle=True, **kwargs)

Evrişimli Sinir Ağları modelinin oluşturulması:

class Net(nn.Module):
def init(self):
super(Net, self).init()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5) # Giriş kanalı: 1, Çıkış kanalı: 10, Filtre boyutu: 5x5
self.conv2 = nn.Conv2d(10, 20, kernel_size=5) # Giriş kanalı: 10, Çıkış kanalı: 20, Filtre boyutu: 5x5

    # Rastgele olacak şekilde nöronların %50'sini kapatıyoruz (modelin ezberlemesini engeller):
    self.conv2_drop = nn.Dropout2d() # Fonksiyonun varsayılan kapama oranı %50

    self.fc1 = nn.Linear(320, 50) # Giriş nöron sayısı: 320, Çıkış nöron sayısı: 50
    # Modele yeni bir katmanda 50 nöron eklemiş olduk.

    self.fc2 = nn.Linear(50, 10) # Giriş nöron sayısı: 50, Çıkış nöron sayısı: 10
    # 10 sınıfımızı temsil edecek 10 nöron.

# Modelin akış şemasını oluşturalım:
def forward(self, x):
    # Giriş(x) boyutu: [1, 28, 28] x 64(batch_size) Kanal syaısı: 1, Görselin boyutu: 28x28

    # Girişi, yukarıda tanımladığımız "conv1" katmanından geçiriyoruz,
    # sonra 2x2 boyutunda çerçeveden oluşan MaxPooling katmanımızı ekliyoruz,
    # daha sonra ReLu aktivasyon fonksiyonumuzdan geçiriyoruz:
    x = F.relu(F.max_pool2d(self.conv1(x), 2))
    # Çıkış boyutu: [10, 12, 12]

    # Yukarıda aldığımız çıktıyı "conv2" katmanından geçiriyoruz,
    # sonra yukarıda tanımladığımız Dropout katmanımızı ekliyoruz,
    # daha sonra 2x2 boyutunda çerçeveden oluşan MaxPooling katmanımızı uyguluyoruz,
    # en sonda ReLu aktivasyon fonksiyonumuzdan geçiriyoruz:
    x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
    # Çıkış boyutu: [20, 4, 4]

    x = x.view(-1, 320) # Yeniden boyutlandırma yapıyoruz.
    # 4x4 boyutlu 20 kanallı fotoğrafı 1 boyutlu vectöre çeviriyoruz.
    # -1 boyutu giriş boyutuna ve belirlenen diğer boyutlara bakılarak bulunur.
    # 20x4x4 = 320:
    # Çıkış boyutu: [320]

    # Yukarıda tanımladığımız "fc1" katmanımızdaki 50 nöronu modelimize ekliyoruz,
    # daha sonra çıktımızı ReLu aktivasyon fonksiyonumuzdan geçiriyoruz:
    x = F.relu(self.fc1(x))
    # Çıkış boyutu: [50]

    # Modelin ezberlemesini önlemek için Dropout katmanımızı ekliyoruz:
    x = F.dropout(x, training=self.training)

    # Yukarıda tanımladığımız "fc2" katmanımızdaki 10 nöronu modelimize ekliyoruz,
    # daha sonra çıktımızı ReLu aktivasyon fonksiyonumuzdan geçiriyoruz:
    x = self.fc2(x)
    # Çıkış boyutu: [10]
    # Verisetimizdeki 10 sınıfı temsil edecek 10 çıktıyı elde ettik.

    # Son olarak sınıflandırma yapmak için Softmax fonksiyoumuzu kullanıyoruz:
    return F.log_softmax(x)

model = Net() # Modelimizi tanımlıyoruz.
if args.cuda:
model.cuda() # Verileri GPU'ya taşır.

"SGD" optimizasyon fonksiyonumuzu oluşturuyoruz:

optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)

Modeli eğitecek fonksiyonumuzu oluşturuyoruz:

def train(epoch):
model.train() # Modelimizi eğitim moduna alıyoruz.
for batch_idx, (data, target) in enumerate(train_loader): # Verisetini batch'lere bölüyoruz.
if args.cuda:
data, target = data.cuda(), target.cuda() # Verileri GPU'ya taşır.
data, target = Variable(data), Variable(target) # Verilerimizi PyTorch değişkenlerine(Tensor) çeviriyoruz.
optimizer.zero_grad() # Tüm optimize edilmiş değişkenlerin verilerini temizler.
output = model(data) # Girdi verisini modelimizde işliyoruz ve çıktımızı alıyoruz.
# Çıkması gereken sonuç ile modelimizin ürettiği çıktıyı karşılaştırarak hata hesaplamamızı yapıyoruz:
loss = F.nll_loss(output, target) # Hata fonksiyonumuz: The negative log likelihood loss(NLLLoss)
loss.backward() # Bulduğumuz hata oranıyla geri-yayılım uyguluyoruz.
optimizer.step() # Modelimizi(ağırlıkları) daha optimize sonuç için güncelliyoruz.

    # Belli aralıklarla(log_interval, varsayılan değer: 10) modelin başarını ekrana yazdırıyoruz:
    if batch_idx % args.log_interval == 0:
        print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
            epoch, batch_idx * len(data), len(train_loader.dataset),
            100. * batch_idx / len(train_loader), loss.data[0]))

Modeli test edecek fonksiyonumuzu oluşturuyoruz:

def test():
model.eval() # Modeli test moduna alıyoruz.
test_loss = 0
correct = 0
for data, target in test_loader: # Test verimizi alıyoruz.
if args.cuda:
data, target = data.cuda(), target.cuda() # Verileri GPU'ya taşır.
data, target = Variable(data, volatile=True), Variable(target) # Verilerimizi PyTorch değişkenlerine(Tensor) çeviriyoruz.
output = model(data) # Girdi verisini modelimizde işliyoruz ve çıktımızı alıyoruz.
test_loss += F.nll_loss(output, target, size_average=False).data[0] # Batch hata oranının hesaplanması ve toplam hata oranına eklenmesi.
# Çıkması gereken sonuç ile modelimizin ürettiği çıktıyı karşılaştırarak hata hesaplamamızı yapıyoruz:
pred = output.data.max(1)[1] # Maksimim olasılık indeksi alınarak sonuç elde edilir.
correct += pred.eq(target.data.view_as(pred)).cpu().sum() # Modelin başarısı hesaplanır.

# Modelin başarısını ekrana yazdırıyoruz:
test_loss /= len(test_loader.dataset)
print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
    test_loss, correct, len(test_loader.dataset),
    100. * correct / len(test_loader.dataset)))

Eğitimi başlatıyoruz:

for epoch in range(1, args.epochs + 1):
train(epoch) # Model eğitilir.
test() # Model test edilir.