PyTorch Eğitimi

Py nedir?TorH?

PyTorch açık kaynaklı Torch tabanlı makine öğrenimi kütüphanesi ile doğal dil işleme PythonNumPy'ye benzer ancak güçlü GPU desteğine sahiptir. Otomatik gradyan yardımıyla anında değiştirebileceğiniz Dinamik Hesaplama Grafikleri sunar.Torch ayrıca diğer bazı çerçevelerden daha hızlıdır. 2016 yılında Facebook'un Yapay Zeka Araştırma Grubu tarafından geliştirilmiştir.

Py'nin ne olduğunu bilmekTorBu, güçlü ve zayıf yönlerine dengeli bir bakış açısı sunuyor.

PyTorAvantajlar ve Dezavantajlar

Aşağıda Py'nin avantajları ve dezavantajları yer almaktadır.Torch:

Py'nin AvantajlarıTorch

1. Basit Kitaplık
   PyTorBu kod basit. Anlaşılması kolay ve kütüphaneyi anında kullanabilirsiniz. Örneğin, aşağıdaki kod parçası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

Resim Kaynağı: Py ile Derin Öğrenmeyi KeşfetmekTorch

PyTorch, Dinamik Hesaplamalı Grafik (DAG) sunmaktadır. Hesaplamalı grafikler, matematiksel ifadeleri düğümler ve kenarlar gibi grafik modelleri veya teorileriyle ifade etmenin bir yoludur. Düğüm matematiksel işlemi gerçekleştirir ve kenar, düğümlere beslenen ve düğümün çıktısını Tensor olarak taşıyan bir Tensor'dur.

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 Py'nin bildirdiğine göreTorch, saniyede işlenen görüntü sayısı açısından diğer çerçevelerden daha hızlıdır.

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 model eğitmek istiyorsanız, loo gibi yerel kontrol akışını kullanabilirsiniz.ping Ayrıca, çalıştırmak için daha fazla özel değişken veya oturum eklemeye gerek kalmadan özyinelemeli işlemleri gerçekleştirebilirsiniz. Bu, eğitim süreci için çok faydalıdır.

PyTorch ayrıca Zorunlu Programlamayı da uyguluyor ve kesinlikle daha esnek. Bu nedenle, hesaplama sürecinin ortasında tensör değerini yazdırmak mümkün.

Py'nin DezavantajıTorch

PyTorch, görselleştirme için üçüncü taraf uygulamalara ihtiyaç duyar. Ayrıca üretim için bir API sunucusuna da ihtiyaç duyar.

Sırada bu Py'deTorBu eğitimde, Py ile Py arasındaki farkı öğreneceğiz.Torch ve TensorFlow.

PyTorch ile TensorFlow karşılaştırması

Bu karşılaştırmayı göz önünde bulundurarak, bir sonraki adım Py'yi edinmek.Torch yerel olarak veya bulutta çalıştırılabilir.

Py'yi yüklemeTorch

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, JupyterYeni'ye tıklayın ve conda_pytorch_p36'yı seçin; artık Py ile notebook örneğinizi kullanmaya hazırsınız.Torch yüklendi.

Sırada bu Py'deTorBu eğitimde Python hakkında bilgi edineceğiz.Torch çerçevesinin temelleri.

Kurulum tamamlandıktan sonraki adım API'nin kendisidir.

PyTorch Çerçeve Temelleri

Python'ın temel kavramlarını öğrenelim.TorDerinlemesine incelemeye başlamadan önce...Torch, NumPy'nin ndarray'ine benzer şekilde her değişken için Tensor kullanır, ancak GPU hesaplama desteğiyle birlikte. Burada ağ modelini, kayıp fonksiyonunu, geri yayılımı ve optimizasyon algoritmasını 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, torch.nn modülünde zaten birçok standart kayıp fonksiyonuna sahiptir. Örneğin, çok sınıflı bir Py problemini çözmek için Çapraz Entropi Kaybı'nı kullanabilirsiniz.TorSınıflandırma problemi. Kayıp fonksiyonunu tanımlamak ve kayıpları hesaplamak kolaydır:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Python ile kendi kayıp fonksiyonu hesaplamalarınızı yapmak çok kolay.Torch.

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.

API'yi öğrenmenin en temiz yolu, küçük, uçtan uca bir örnek üzerinden ilerlemektir.

Python ile Basit RegresyonTorch

Python ile basit regresyon hesaplamaları öğrenelim.Torch örnekleri:

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 desteklenen değişkenlere dönüştürmeniz gerekir. TorAşağıdaki Py'de gösterildiği gibi ch ve autogradTorch regresyon örneği.

# 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, Py işlemini başarıyla gerçekleştirdiniz.TorSinir ağı ile regresyon analizi. Aslında, her yinelemede, grafikteki kırmızı çizgi güncellenir ve veriye uyacak şekilde konumunu değiştirir. Ancak bu resimde, aşağıdaki Py kodunda gösterildiği gibi yalnızca nihai sonuç gösterilmektedir.TorÖrnek:

Regresyon bir ısınma egzersizidir; görüntü sınıflandırması ise Python'ın derin öğrenme yeteneklerini geliştirir.Torch.

Python ile Görüntü Sınıflandırma ÖrneğiTorch

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 Py'nin ilk adımındaTorSınıflandırma örneği için, veri setini torchvision modülünü kullanarak yükleyeceksiniz.

Eğitim sürecine başlamadan önce verileri anlamanız gerekiyor. Torchvision, veri setini yükleyecek ve görüntüleri, şekil ve normalleştirme gibi ağın gereksinimlerine uygun şekilde 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 Py'deTorÖrneğin, Python için basit bir sinir ağı oluşturacaksınız.Torch görüntü sınıflandırması.

Burada, Python'da ağ modeli oluşturmanın başka bir yolunu tanıtıyoruz.TorBölüm 1. nn.Module'ün bir alt sınıfını oluşturmak yerine, bir sıralı model 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. Optimizasyon algoritması olarak ise aşağıdaki Py kodunda gösterildiği gibi 0.001 öğrenme oranı ve 0.9 momentum ile SGD'yi kullanacaksınız.TorÖrneğin.

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()

SSS