PyTorch Eğitimi: Regresyon, Görüntü Sınıflandırma Örneği

Pytorch Eğitim Özeti

Bu pytorch eğitiminde tüm kavramları sıfırdan öğreneceksiniz. Bu eğitimde pytorch tanımı, pytorch'un avantajları ve dezavantajları, karşılaştırma, kurulum, pytorch çerçevesi, regresyon ve görüntü sınıflandırması gibi temel ve ileri düzey konular ele alınmaktadır. Bu pytorch eğitimi tamamen ücretsizdir.

PyTorch nedir?

PyTorch kullanarak doğal dil işlemeye yönelik açık kaynaklı bir Torch tabanlı Makine Öğrenimi kütüphanesidir. Python. NumPy'ye benzer ancak güçlü GPU desteğine sahiptir. Autograd'ın yardımıyla hareket halindeyken değiştirebileceğiniz Dinamik Hesaplamalı Grafikler sunar. PyTorch ayrıca diğer bazı çerçevelerden daha hızlıdır. Facebook'un Yapay Zeka Araştırma Grubu tarafından 2016 yılında geliştirildi.

PyTorch'un Avantajları ve Dezavantajları

PyTorch'un avantajları ve dezavantajları şunlardır:

PyTorch'un Avantajları

1. Basit Kitaplık
   PyTorch kodu basittir. Anlaşılması kolaydır ve kütüphaneyi anında kullanırsınız. Örneğin aşağıdaki kod parçacığına bir göz atın:

class Net(torch.nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

Yukarıda da bahsettiğimiz gibi ağ modelini kolaylıkla tanımlayabilir ve çok fazla eğitim gerektirmeden kodu hızlı bir şekilde anlayabilirsiniz.

2. Dinamik Hesaplamalı Grafik

Görüntü Kaynağı: PyTorch ile Derin Öğrenmeyi Keşfetmek

Pytorch, Dinamik Hesaplamalı Grafik (DAG) sunar. Hesaplamalı grafikler, düğümler ve kenarlar gibi grafik modellerinde veya teorilerinde matematiksel ifadeleri ifade etmenin bir yoludur. Düğüm matematiksel işlemi yapacak ve kenar, düğümlere beslenecek ve düğümün çıktısını Tensor'da taşıyacak bir Tensördür.

DAG, keyfi bir şekle sahip olan ve farklı giriş grafikleri arasında işlem yapabilen bir grafiktir. Her yinelemede yeni bir grafik oluşturulur. Yani aynı graf yapısına sahip olmak veya farklı bir işlemle yeni bir graf oluşturmak mümkün ya da buna dinamik graf diyebiliriz.

3. Daha İyi Performans

Topluluklar ve araştırmacılar, hangisinin daha hızlı olduğunu görmek için çerçeveleri kıyaslayın ve karşılaştırın. GitHub deposu Derin Öğrenme Çerçeveleri ve GPU'lara İlişkin Karşılaştırma PyTorch'un saniyede işlenen görseller açısından diğer çerçevelerden daha hızlı olduğunu bildirdi.

Aşağıda görebileceğiniz gibi vgg16 ve resnet152 ile karşılaştırma grafikleri

4. Yerli Python

PyTorch daha çok python tabanlıdır. Örneğin, bir modeli eğitmek istiyorsanız döngü ve özyinelemeler gibi yerel kontrol akışını, bunları çalıştırabilmek için daha fazla özel değişken veya oturum eklemenize gerek kalmadan kullanabilirsiniz. Bu, eğitim süreci için çok faydalıdır.

Pytorch aynı zamanda Zorunlu Programlamayı da uygular ve kesinlikle daha esnektir. Yani bir hesaplama sürecinin ortasında tensör değerinin çıktısını almak mümkündür.

PyTorch'un Dezavantajı

PyTorch, Görselleştirme için üçüncü taraf uygulamaları gerektirir. Ayrıca üretim için bir API sunucusuna da ihtiyacı var.

Bu PyTorch eğitiminde bir sonraki adımda PyTorch ve TensorFlow arasındaki farkı öğreneceğiz.

PyTorch Vs. Tensor akışı

Parametre	PyTorch	tensör akışı
Model Tanımı	Model bir alt sınıfta tanımlanmış olup, kullanımı kolay bir paket sunmaktadır.	Model birçok kişiyle tanımlanır ve sözdizimini anlamanız gerekir
GPU Desteği	Evet	Evet
Grafik Türü	Dinamik	Statik
Tools	Görselleştirme aracı yok	Tensorboard görselleştirme aracını kullanabilirsiniz
Topluluk	Topluluk hala büyüyor	Büyük aktif topluluklar

PyTorch'u Yükleme

Linux

Linux'ta kurulumu kolaydır. Sanal bir ortam kullanmayı veya doğrudan root erişimiyle kurmayı seçebilirsiniz. Bu komutu terminale yazın

pip3 install --upgrade torch torchvision

AWS Bilge Yapıcı

Sagemaker, platformlardan biridir. Amazon İnternet servisi Veri bilimcilerin veya geliştiricilerin her ölçekte model oluşturması, eğitmesi ve dağıtması için önceden yüklenmiş derin öğrenme yapılandırmalarına sahip güçlü bir Makine Öğrenimi motoru sunar.

İlk aç Amazon adaçayı Konsola gidin ve Not defteri örneği oluştur'a tıklayın ve not defteriniz için tüm ayrıntıları doldurun.

Sonraki Adım, Dizüstü bilgisayar örneğinizi başlatmak için Aç'a tıklayın.

Son olarak, Jupyter, Yeni'ye tıklayın ve conda_pytorch_p36'yı seçin; dizüstü bilgisayarınızı Pytorch yüklü olarak kullanmaya hazırsınız.

Bu PyTorch eğitiminde bir sonraki adımda PyTorch çerçevesinin temellerini öğreneceğiz.

PyTorch Çerçeve Temelleri

Derinlemesine dalmadan önce PyTorch'un temel kavramlarını öğrenelim. PyTorch, numpy'nin ndarray'ine benzer ancak GPU hesaplama desteğine sahip her değişken için Tensor'u kullanır. Burada ağ modelini, kayıp fonksiyonunu, Backprop'u ve Optimizer'ı açıklayacağız.

Ağ Modeli

Ağ, torch.nn dosyasının alt sınıflandırılmasıyla oluşturulabilir. 2 ana bölüm var,

1. İlk bölüm kullanacağınız parametreleri ve katmanları tanımlamaktır.
2. İkinci kısım, bir girdi alıp çıktıyı tahmin edecek ileri süreç adı verilen ana görevdir.

Import torch
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
 def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(3, 20, 5)
        self.conv2 = nn.Conv2d(20, 40, 5)
self.fc1 = nn.Linear(320, 10)

def forward(self, x):
       x = F.relu(self.conv1(x))
       x = F.relu(self.conv2(x))
       x = x.view(-1, 320)
       x = F.relu(self.fc1(x))
       return F.log_softmax(x)

net = Model()

Yukarıda gördüğünüz gibi nn.Module'ün Model adında bir sınıfını oluşturuyorsunuz. 2 Conv2d katmanı ve bir Doğrusal katman içerir. İlk conv2d katmanı 3 girdisini ve 20 çıktı şeklini alır. İkinci katman 20 girdisini alır ve 40 çıktı şeklini üretir. Son katman 320 şeklinde tamamen bağlı bir katmandır ve üretecektir. 10 çıktı.

İleri işlem, bir X girdisi alacak ve onu conv1 katmanına besleyecek ve ReLU işlevini gerçekleştirecektir,

Benzer şekilde conv2 katmanını da besleyecektir. Bundan sonra x, (-1, 320) şeklinde yeniden şekillendirilecek ve son FC katmanına beslenecektir. Çıkışı göndermeden önce softmax aktivasyon fonksiyonunu kullanacaksınız.

Geriye doğru süreç, autograd tarafından otomatik olarak tanımlanır, bu nedenle yalnızca ileri süreci tanımlamanız gerekir.

Kayıp İşlevi

Kayıp fonksiyonu, tahmin modelinin beklenen sonuçları ne kadar iyi tahmin edebildiğini ölçmek için kullanılır. PyTorch'un torch.nn modülünde zaten birçok standart kayıp işlevi vardır. Örneğin, çok sınıflı bir PyTorch sınıflandırma problemini çözmek için Çapraz Entropi Kaybını kullanabilirsiniz. Kayıp fonksiyonunu tanımlamak ve kayıpları hesaplamak kolaydır:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

PyTorch ile kendi kayıp fonksiyonu hesaplamanızı kullanmak kolaydır.

Arka pervane

Geri yayılımı gerçekleştirmek için los.backward() işlevini çağırmanız yeterlidir. Hata hesaplanacaktır ancak mevcut degradeyi sıfır_grad() ile temizlemeyi unutmayın.

net.zero_grad() # to clear the existing gradient
loss.backward() # to perform backpropragation

Doktoru

torch.optim ortak optimizasyon algoritmaları sağlar. Bir optimize ediciyi basit bir adımla tanımlayabilirsiniz:

optimizer = torch.optim.SGD(net.parameters(), lr = 0.01, momentum=0.9)

Ağ modeli parametrelerini ve öğrenme oranını iletmeniz gerekir, böylece her yinelemede parametreler backprop işleminden sonra güncellenecektir.

PyTorch ile Basit Regresyon

PyTorch örnekleriyle basit regresyonu öğrenelim:

Adım 1) Ağ modelimizi oluşturma

Ağ modelimiz, giriş ve çıkış şekli 1 olan basit bir Doğrusal katmandır.

from __future__ import print_function

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable

class Net(nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

net = Net()
print(net)

Ve ağ çıktısı şöyle olmalı

Net(
  (hidden): Linear(in_features=1, out_features=1, bias=True)
)

Adım 2) Verileri Test Edin

Eğitim sürecine başlamadan önce verilerimizi bilmeniz gerekiyor. Modelimizi test etmek için rastgele bir fonksiyon yapıyorsunuz. Y = x³ sin(x)+ 3x+0.8 rand(100)

# Visualize our data
import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.sin(x) * np.power(x,3) + 3*x + np.random.rand(100)*0.8

plt.scatter(x, y)
plt.show()

İşte fonksiyonumuzun dağılım grafiği:

Eğitim sürecine başlamadan önce numpy dizisini aşağıdaki PyTorch regresyon örneğinde gösterildiği gibi Torch ve autograd tarafından desteklenen Değişkenlere dönüştürmeniz gerekir.

# convert numpy array to tensor in shape of input size
x = torch.from_numpy(x.reshape(-1,1)).float()
y = torch.from_numpy(y.reshape(-1,1)).float()
print(x, y)

Adım 3) Optimize Edici ve Kayıp

Daha sonra eğitim sürecimiz için Optimize Edici ve Kayıp Fonksiyonunu tanımlamanız gerekir.

# Define Optimizer and Loss Function
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
loss_func = torch.nn.MSELoss()

Adım 4) Eğitim

Şimdi eğitim sürecimize başlayalım. 250'lik bir dönemle, hiperparametrelerimiz için en iyi değeri bulmak amacıyla verilerimizi yineleyeceksiniz.

inputs = Variable(x)
outputs = Variable(y)
for i in range(250):
   prediction = net(inputs)
   loss = loss_func(prediction, outputs) 
   optimizer.zero_grad()
   loss.backward()        
   optimizer.step()       

   if i % 10 == 0:
       # plot and show learning process
       plt.cla()
       plt.scatter(x.data.numpy(), y.data.numpy())
       plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=2)
       plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 10, 'color':  'red'})
       plt.pause(0.1)

plt.show()

Adım 5) Sonuç

Aşağıda görebileceğiniz gibi bir sinir ağı ile PyTorch regresyonunu başarıyla gerçekleştirdiniz. Aslında her yinelemede grafikteki kırmızı çizgi güncellenecek ve verilere uyacak şekilde konumunu değiştirecektir. Ancak bu resimde size yalnızca aşağıdaki PyTorch örneğinde gösterildiği gibi nihai sonuç gösterilir:

PyTorch ile Görüntü Sınıflandırma Örneği

Temellerini öğrenmenin popüler yöntemlerinden biri derin öğrenme MNIST veri kümesiyle birliktedir. Derin öğrenmede “Merhaba Dünya”dır. Veri seti, halihazırda 0×9 piksel boyutunda etiketlenmiş toplam 60,000 eğitim örneği ve 10,000 test örneğinden oluşan 28 – 28 arası el yazısıyla yazılan sayıları içerir.

Adım 1) Verileri Ön İşleme

Bu PyTorch sınıflandırma örneğinin ilk adımında torchvision modülünü kullanarak veri kümesini yükleyeceksiniz.

Eğitim sürecine başlamadan önce verileri anlamanız gerekir. Torchvision veri kümesini yükleyecek ve görüntüleri şekil ve normalleştirme gibi ağ için uygun gereksinimlerle dönüştürecektir.

import torch
import torchvision
import numpy as np
from torchvision import datasets, models, transforms

# This is used to transform the images to Tensor and normalize it
transform = transforms.Compose(
   [transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

training = torchvision.datasets.MNIST(root='./data', train=True,
                                       download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(training, batch_size=4,
                                         shuffle=True, num_workers=2)

testing = torchvision.datasets.MNIST(root='./data', train=False,
                                      download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(testing, batch_size=4,
                                        shuffle=False, num_workers=2)

classes = ('0', '1', '2', '3',
          '4', '5', '6', '7', '8', '9')
         
import matplotlib.pyplot as plt
import numpy as np

#create an iterator for train_loader
# get random training images
data_iterator = iter(train_loader)
images, labels = data_iterator.next()

#plot 4 images to visualize the data
rows = 2
columns = 2
fig=plt.figure()
for i in range(4):
   fig.add_subplot(rows, columns, i+1)
   plt.title(classes[labels[i]])
   img = images[i] / 2 + 0.5     # this is for unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

Transform işlevi görüntüleri tensöre dönüştürür ve değeri normalleştirir. torchvision.transforms.MNIST fonksiyonu dizindeki veri setini (mevcut değilse) indirecek, gerekiyorsa eğitim için veri setini ayarlayacak ve dönüştürme işlemini gerçekleştirecektir.

Veri kümesini görselleştirmek için bir sonraki resim ve etiket grubunu almak üzere data_iterator'ı kullanırsınız. Bu görüntüleri ve uygun etiketlerini çizmek için matplot'u kullanırsınız. Aşağıda görebileceğiniz gibi görsellerimiz ve etiketlerimiz.

Adım 2) Ağ Modeli Yapılandırması

Şimdi bu PyTorch örneğinde, PyTorch görüntü sınıflandırması için basit bir sinir ağı oluşturacaksınız.

Burada size PyTorch'ta Ağ modelini oluşturmanın başka bir yolunu tanıtıyoruz. nn.Module'ün bir alt sınıfını oluşturmak yerine bir dizi modeli oluşturmak için nn.Sequential'ı kullanacağız.

import torch.nn as nn

# flatten the tensor into 
class Flatten(nn.Module):
   def forward(self, input):
       return input.view(input.size(0), -1)

#sequential based model
seq_model = nn.Sequential(
           nn.Conv2d(1, 10, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           nn.Dropout2d(),
           nn.Conv2d(10, 20, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           Flatten(),
           nn.Linear(320, 50),
           nn.ReLU(),
           nn.Linear(50, 10),
           nn.Softmax(),
         )

net = seq_model
print(net)

İşte ağ modelimizin çıktısı

Sequential(
  (0): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))
  (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (2): ReLU()
  (3): Dropout2d(p=0.5)
  (4): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1))
  (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (6): ReLU()
  (7): Flatten()
  (8): Linear(in_features=320, out_features=50, bias=True)
  (9): ReLU()
  (10): Linear(in_features=50, out_features=10, bias=True)
  (11): Softmax()
)

Ağ Açıklaması

1. Sıra şu şekildedir; ilk katman, giriş şekli 2 ve çıkış şekli 1 olan, çekirdek boyutu 10 olan bir Conv5D katmanıdır.
2. Daha sonra bir MaxPool2D katmanınız var
3. Bir ReLU aktivasyon işlevi
4. Düşük olasılık değerlerini düşürmek için bir Bırakma katmanı.
5. Daha sonra son katmandan giriş şekli 2 ve çekirdek boyutu 10 olan çıkış şekli 20 olan ikinci bir Conv5d
6. Sonraki bir MaxPool2d katmanı
7. ReLU aktivasyon fonksiyonu.
8. Bundan sonra tensörü Doğrusal katmana beslemeden önce düzleştireceksiniz.
9. Doğrusal Katman, çıktımızı softmax aktivasyon işleviyle ikinci Doğrusal katmanda eşleyecektir.

Adım 3)Modeli Eğitin

Eğitim sürecine başlamadan önce kriter ve optimize edici fonksiyonunun ayarlanması gerekmektedir.

Kriter olarak CrossEntropyLoss'u kullanacaksınız. Optimize Edici için, aşağıdaki PyTorch örneğinde gösterildiği gibi, öğrenme oranı 0.001 ve momentumu 0.9 olan SGD'yi kullanacaksınız.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

İleriye doğru işlem giriş şeklini alacak ve onu ilk conv2d katmanına aktaracaktır. Daha sonra oradan maxpool2d'ye beslenecek ve son olarak ReLU aktivasyon fonksiyonuna yerleştirilecektir. Aynı işlem ikinci conv2d katmanında da gerçekleşecektir. Bundan sonra giriş (-1,320) olarak yeniden şekillendirilecek ve çıkışı tahmin etmek için fc katmanına beslenecektir.

Artık eğitim sürecine başlayacaksınız. Veri setimizi 2 kez veya 2 dönemle yineleyecek ve her 2000 partide mevcut kaybı yazdıracaksınız.

for epoch in range(2): 

#set the running loss at each epoch to zero
   running_loss = 0.0
# we will enumerate the train loader with starting index of 0
# for each iteration (i) and the data (tuple of input and labels)
   for i, data in enumerate(train_loader, 0):
       inputs, labels = data

# clear the gradient
       optimizer.zero_grad()

#feed the input and acquire the output from network
       outputs = net(inputs)

#calculating the predicted and the expected loss
       loss = criterion(outputs, labels)

#compute the gradient
       loss.backward()

#update the parameters
       optimizer.step()

       # print statistics
       running_loss += loss.item()
       if i % 1000 == 0:
           print('[%d, %5d] loss: %.3f' %
                 (epoch + 1, i + 1, running_loss / 1000))
           running_loss = 0.0

Her çağda, numaralandırıcı bir sonraki girdi grubunu ve karşılık gelen etiketleri alacaktır. Girişi ağ modelimize beslemeden önce önceki degradeyi temizlememiz gerekiyor. Bu gereklidir çünkü geriye doğru süreçten sonra (geri yayılım süreci), gradyan değiştirilmek yerine biriktirilecektir. Daha sonra beklenen çıktıdan, tahmin edilen çıktıdan kaynaklanan kayıpları hesaplayacağız. Bundan sonra gradyanı hesaplamak için geriye yayılım yapacağız ve son olarak parametreleri güncelleyeceğiz.

İşte eğitim sürecinin çıktısı

[1, 	1] loss: 0.002
[1,  1001] loss: 2.302
[1,  2001] loss: 2.295
[1,  3001] loss: 2.204
[1,  4001] loss: 1.930
[1,  5001] loss: 1.791
[1,  6001] loss: 1.756
[1,  7001] loss: 1.744
[1,  8001] loss: 1.696
[1,  9001] loss: 1.650
[1, 10001] loss: 1.640
[1, 11001] loss: 1.631
[1, 12001] loss: 1.631
[1, 13001] loss: 1.624
[1, 14001] loss: 1.616
[2, 	1] loss: 0.001
[2,  1001] loss: 1.604
[2,  2001] loss: 1.607
[2,  3001] loss: 1.602
[2,  4001] loss: 1.596
[2,  5001] loss: 1.608
[2,  6001] loss: 1.589
[2,  7001] loss: 1.610
[2,  8001] loss: 1.596
[2,  9001] loss: 1.598
[2, 10001] loss: 1.603
[2, 11001] loss: 1.596
[2, 12001] loss: 1.587
[2, 13001] loss: 1.596
[2, 14001] loss: 1.603

Adım 4) Modeli Test Edin

Modelimizi eğittikten sonra diğer görüntü gruplarıyla test etmeniz veya değerlendirme yapmanız gerekir.

Test_loader için bir yineleyici kullanacağız ve bu, eğitilen modele aktarılacak bir dizi resim ve etiket oluşturacaktır. Tahmin edilen çıktı görüntülenecek ve beklenen çıktıyla karşılaştırılacaktır.

#make an iterator from test_loader
#Get a batch of training images
test_iterator = iter(test_loader)
images, labels = test_iterator.next()

results = net(images)
_, predicted = torch.max(results, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

fig2 = plt.figure()
for i in range(4):
   fig2.add_subplot(rows, columns, i+1)
   plt.title('truth ' + classes[labels[i]] + ': predict ' + classes[predicted[i]])
   img = images[i] / 2 + 0.5     # this is to unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

ÖZET

• PyTorch açık kaynaklı bir Torch tabanlıdır Makine öğrenme için kütüphane doğal dil işleme kullanma Python.
• PyTorch'un Avantajları: 1) Basit Kütüphane, 2) Dinamik Hesaplamalı Grafik, 3) Daha İyi Performans, 4) Yerel Python
• PyTorch, numpy'nin ndarray'ine benzer ancak GPU hesaplama desteğine sahip her değişken için Tensor'u kullanır.
• Derin öğrenmenin temellerini öğrenmenin popüler yöntemlerinden biri MNIST veri kümesidir.