PyTorch ile Tensörleri İncelemek

Derin öğrenmede, temel veri yapısı olarak tensörler etrafında çokça tartışma görmek yaygındır. Google’ın amiral gemisi makine öğrenmesi kütüphanesinin adında bile Tensör geçer: “TensorFlow”. Tensörler, lineer cebirde kullanılan bir veri yapısı türüdür; vektörler ve matrisler gibi tensörlerle de aritmetik işlemler yapabilirsiniz.

Öte yandan, PyTorch, Facebook tarafından geliştirilmiş, iki üst düzey özellik sunan bir Python paketidir: 1) Güçlü GPU hızlandırmasıyla (NumPy gibi) Tensör hesaplama ve 2) bant tabanlı otomatik türev alma sistemi üzerine kurulu Derin Sinir Ağları.

Bu derste, tensörlerin ne olduğunu ve Python’da PyTorch ile nasıl işlenebileceğini keşfedeceksiniz.

O halde, daha fazla uzatmadan Tensörlere girişle başlayalım.

Tensörlere Giriş

Tensör, vektör ve matrislerin genellemesidir ve çok boyutlu bir dizi olarak kolayca anlaşılabilir. “Deep Learning” (Goodfellow ve diğerleri) adlı popüler derin öğrenme kitabına göre -

"Genel durumda, değişken sayıda eksenle düzenli bir ızgara üzerinde düzenlenmiş sayı dizisine tensör denir."

Skaler sıfırıncı dereceden veya sıfır rütbeli bir tensördür. Vektör tek boyutlu veya birinci dereceden bir tensördür ve matris iki boyutlu veya ikinci dereceden bir tensördür.

Aşağıdaki infografik tensörleri son derece anlaşılır biçimde açıklar:

Şimdi tensörlerin arkasındaki sezgiyi daha sade bir şekilde kuralım.

Tensör, modern makine öğrenmesinin temel yapı taşıdır. Özünde bir veri kabıdır. Çoğunlukla sayılar içerir. Bazen metinler de barındırabilir, ama bu nadirdir. Yani onu bir sayı kovası gibi düşünebilirsiniz.

Ancak insanlar tensörleri sık sık çok boyutlu dizilerle karıştırır. StackExchange’e göre:

Tensörler ve çok boyutlu diziler farklı türde nesnelerdir. İlki bir fonksiyon türüdür. İkincisi ise bir tensörü bir koordinat sisteminde temsil etmeye uygun bir veri yapısıdır.

Matematiksel olarak tensörler çok doğrusal (çok lineer) bir fonksiyon olarak tanımlanır. Çok doğrusal bir fonksiyon çeşitli vektör değişkenlerinden oluşur. Bir tensör alanı, değerleri tensör olan bir fonksiyondur. Sıkı bir matematiksel açıklama için burayı okuyabilirsiniz.

Özetle, tensörler tanımlamanız gereken fonksiyonlar veya kaplardır. Asıl hesaplama, veri beslendiğinde gerçekleşir. Diziler veya çok boyutlu (1B, 2B, …, NB) yapılar olarak gördüğünüz şeyler, genel tensörler olarak kabul edilebilir.

Şimdi biraz da Tensör gösteriminden bahsedelim.

Tensör gösterimi, büyük harfin bir tensörü; alt simge tamsayılarla yazılan küçük harflerin ise tensör içindeki skaler değerleri gösterdiği matris gösterimine benzer.

Skalerler, vektörler ve matrislerle yapılabilen birçok işlem, tensörlerle yapılacak şekilde yeniden formüle edilebilir.

Bir araç olarak tensörler ve tensör cebiri, fizik ve mühendislik alanlarında yaygın biçimde kullanılır. Makine öğrenmesinde de derin öğrenme modellerinin eğitimi ve çalıştırılması, tensörler bağlamında tanımlanabilen bir dizi kavram ve teknik içerir.

PyTorch’a Giriş

PyTorch, şu amaçlara yönelik, Python tabanlı bir bilimsel hesaplama paketidir:

• GPU’ların gücünden yararlanmak için NumPy’nin yerine geçmek.
• Maksimum esneklik ve hız sağlayan bir derin öğrenme araştırma platformu olmak.

PyTorch’un benzersiz özelliklerini hızlıca özetleyelim -

• PyTorch, dilimleme, indeksleme, matematiksel işlemler, lineer cebir, indirgemeler gibi bilimsel hesaplama ihtiyaçlarınızı hızlandırıp karşılayacak çok çeşitli tensör rutinleri sağlar. Hem de hızlıdırlar.

• PyTorch’un sinir ağları kurma yöntemi kendine hastır: bir teybi kullanıp geri oynatmak gibi.

• TensorFlow, Theano, Caffe ve CNTK gibi çoğu çatı dünyaya statik bakar. Bir sinir ağı kurup aynı yapıyı tekrar tekrar kullanmanız gerekir. Ağın davranışını değiştirmek, çoğu zaman baştan başlamayı gerektirir.

• PyTorch, ağınızın davranışını sıfır gecikme veya ek yükle keyfi olarak değiştirmenize olanak tanıyan Ters-mod otomatik türev alma (Reverse-mode auto-differentiation) tekniğini kullanır. Esin kaynağımız bu konudaki birkaç araştırma makalesinin yanı sıra autograd, Chainer vb. geçmiş ve güncel çalışmalardır.

(Bu teknik yalnızca PyTorch’a özgü olmasa da, bugüne kadarki en hızlı uygulamalardan biridir. Çılgın araştırmalarınız için hem hız hem esneklikten en iyi şekilde yararlanırsınız.)

• PyTorch’un çatı ek yükü çok azdır. Intel MKL ve NVIDIA (CuDNN, NCCL) gibi hızlandırma kütüphanelerini entegre ederek hızı en üst düzeye çıkarırız. Çekirdekte, CPU ve GPU Tensör ve Sinir Ağı arkauçları (TH, THC, THNN, THCUNN) C99 API’li bağımsız kütüphaneler olarak yazılmıştır. Olgunlaşmıştır ve yıllardır test edilmektedir.

(Bu nedenle PyTorch oldukça hızlıdır – küçük ya da büyük sinir ağları çalıştırmanız fark etmez.)

• PyTorch’ta bellek kullanımı Torch veya bazı alternatiflere kıyasla son derece verimlidir. PyTorch’un geliştiricileri, derin öğrenme modellerinizin belleği azami verimle kullanmasını sağlamak için GPU için özel bellek ayırıcıları yazmıştır. Bu sayede eskisine göre daha büyük derin öğrenme modelleri eğitebilirsiniz.

Şu blog yazısı PyTorch ile TensorFlow’u oldukça iyi karşılaştırır.

Not: Bu DataCamp blogu TensorFlow’a başlamak için mükemmel bir başlangıçtır.

PyTorch’un Kurulumu

PyTorch’un kurulumu oldukça basittir. PyTorch, verimli GPU hesaplamasını desteklediğinden, Cuda sürücülerinizle etkili biçimde haberleşir ve işleri daha hızlı yapar.

PyTorch’u kullanmak için torch ve torchvision gereklidir. Bunları bir Windows ortamı için kuralım. Sonrasında Linux ve Mac adımlarını da göreceksiniz.

Python 3.5 ve Anaconda kurulumum var. Ayrıca CUDA yok. torch ve torchvision’ı yüklemek için şu komutları çalıştırın:

• pip3 install http://download.pytorch.org/whl/cpu/torch-0.4.1-cp35-cp35m-win_amd64.whl
• pip3 install torchvision

(Lütfen PyTorch’un Python 2.7’i desteklemediğini unutmayın. Bu yüzden Python sürümünüzün => 3.5 olması şarttır.)

Makinenizde CUDA etkinse şunları çalıştırabilirsiniz (bu, CUDA 9.0 içindir):

• pip3 install http://download.pytorch.org/whl/cu90/torch-0.4.1-cp35-cp35m-win_amd64.whl
• pip3 install torchvision

Şimdi, Python 3.5 ve CUDA desteği olmadan bir Linux ortamı için kurulum adımlarına bakalım:

• pip3 install http://download.pytorch.org/whl/cpu/torch-0.4.1-cp35-cp35m-linux_x86_64.whl
• pip3 install torchvision

Evet, doğru tahmin ettiniz! Windows ile aynıdır.

CUDA desteğiniz (9.0) varsa adım şöyle olur:

• pip3 install torch torchvision

Python 3.5 ve CUDA desteği olmadan bir Mac ortamı için adımlar şöyledir:

• pip3 install torch torchvision

Ve CUDA desteğiyle (9.0):

• pip3 install torch torchvision

(MacOS ikili dosyaları CUDA’yı desteklemez; CUDA gerekiyorsa kaynaktan derleyin)

Umarım bu aşamada PyTorch kurulumunu tamamladınız!

Şimdi, doğrudan PyTorch ile bazı Tensör aritmetiğine dalalım.

PyTorch ile Tensör Aritmetiği

Önce gerekli tüm kütüphaneleri içe aktaralım.

from __future__ import print_function
import torch

PyTorch kurulumu başarılıysa, yukarıdaki kod satırlarını çalıştırmak hata vermez.

Şimdi, 5x3 boyutunda, başlatılmamış bir matris oluşturalım:

x = torch.rand(5, 3)
print(x)

tensor([[ 0.5991,  0.9365,  0.6120],
        [ 0.3622,  0.1408,  0.8811],
        [ 0.6248,  0.4808,  0.0322],
        [ 0.2267,  0.3715,  0.8430],
        [ 0.0145,  0.0900,  0.3418]])

Sıfırlarla dolu ve long veri tipinde bir matris oluşturun:

x = torch.zeros(5, 3, dtype=torch.long)
print(x)

tensor([[ 0,  0,  0],
        [ 0,  0,  0],
        [ 0,  0,  0],
        [ 0,  0,  0],
        [ 0,  0,  0]])

Veriden doğrudan bir tensör oluşturun:

x = torch.tensor([5.5, 3])
print(x)

tensor([ 5.5000,  3.0000])

Tensörleri doğru anladıysanız, yorumlarda x’in ne tür bir Tensör olduğunu söyleyin!

Mevcut bir tensöre dayanarak yeni bir tensör oluşturabilirsiniz. Bu yöntemler, kullanıcı yeni değerler sağlamadıkça, örneğin dtype (veri tipi) gibi giriş tensörünün özelliklerini yeniden kullanacaktır:

x = x.new_ones(5, 3, dtype=torch.double)    
print(x)

x = torch.randn_like(x, dtype=torch.float)    
print(x)

tensor([[ 1.,  1.,  1.],
        [ 1.,  1.,  1.],
        [ 1.,  1.,  1.],
        [ 1.,  1.,  1.],
        [ 1.,  1.,  1.]], dtype=torch.float64)
tensor([[-1.2174,  1.1807,  1.4249],
        [-1.1114, -0.8098,  0.4003],
        [ 0.0780, -0.5011, -1.0985],
        [ 1.8160, -0.3778, -0.8610],
        [-0.7109, -2.0509, -1.2079]])

Boyutunu alın:

print(x.size())

torch.Size([5, 3])

torch.Size’ın aslında bir demet (tuple) olduğunu ve tüm demet işlemlerini desteklediğini unutmayın.

Şimdi, Tensörler üzerinde toplama işlemi yapalım.

Tensör Toplama

Aynı boyutlara sahip iki tensörün eleman bazlı toplanması, ebeveyn tensörlerdeki skalerlerin eleman bazlı toplamlarının yer aldığı, aynı boyutlarda yeni bir tensör verir.

# PyTorch'ta tensör toplamaya dair Sözdizimi 1
y = torch.rand(5, 3)
print(x)
print(y)
print(x + y)

tensor([[-1.2174,  1.1807,  1.4249],
        [-1.1114, -0.8098,  0.4003],
        [ 0.0780, -0.5011, -1.0985],
        [ 1.8160, -0.3778, -0.8610],
        [-0.7109, -2.0509, -1.2079]])
tensor([[ 0.8285,  0.7619,  0.1147],
        [ 0.1624,  0.8994,  0.6119],
        [ 0.2802,  0.2950,  0.7098],
        [ 0.8132,  0.3382,  0.4383],
        [ 0.6738,  0.2022,  0.3264]])
tensor([[-0.3889,  1.9426,  1.5396],
        [-0.9490,  0.0897,  1.0122],
        [ 0.3583, -0.2061, -0.3887],
        [ 2.6292, -0.0396, -0.4227],
        [-0.0371, -1.8487, -0.8815]])

# PyTorch'ta tensör toplamaya dair Sözdizimi 2
print(torch.add(x, y))

tensor([[-0.3889,  1.9426,  1.5396],
        [-0.9490,  0.0897,  1.0122],
        [ 0.3583, -0.2061, -0.3887],
        [ 2.6292, -0.0396, -0.4227],
        [-0.0371, -1.8487, -0.8815]])

Şimdi Tensör çıkarma yapalım.

Tensör Çıkarma

Aynı boyutlara sahip iki tensörden birinin diğerinden eleman bazlı çıkarılması, ebeveyn tensörlerdeki skalerlerin eleman bazlı farklarının yer aldığı, aynı boyutlarda yeni bir tensör verir.

Şimdi de Tensör Çarpımına bir göz atalım:

Tensör Çarpımı

mat1 ve mat2 matrislerinin matris çarpımını gerçekleştirir.

mat1 (n×m) tensörü ise, mat2 (m×p) tensörüdür; sonuç (n×p) bir tensördür.

PyTorch’ta Tensör çarpımını aşağıdaki gibi yaparsınız:

mat1 = torch.randn(2, 3)
mat2 = torch.randn(3, 3)
print(mat1)
print(mat2)
print(torch.mm(mat1, mat2))

tensor([[ 1.9490, -0.6503, -1.9448],
        [-0.7126,  1.0519, -0.4250]])
tensor([[ 0.0846,  0.4410, -0.0625],
        [-1.3264, -0.5265,  0.2575],
        [-1.3324,  0.6644,  0.3528]])
tensor([[ 3.6185, -0.0901, -0.9753],
        [-0.8892, -1.1504,  0.1654]])

torch.mm()’in yayınlama (broadcast) yapmadığını unutmayın. Biraz da broadcasting hakkında konuşalım.

Broadcasting

Broadcasting terimi, aritmetik işlemler sırasında farklı şekillere sahip dizilerin nasıl ele alındığını açıklar. Bazı kısıtlar dahilinde, küçük dizi daha geniş diziye “yayınlanır” ve böylece uyumlu şekillere sahip olurlar. Broadcasting, döngülerin Python yerine C’de gerçekleşmesini sağlayarak dizi işlemlerinin vektörleştirilmesine imkân verir. Bunu gereksiz veri kopyaları oluşturmadan yapar ve genellikle verimli algoritma uygulamalarına yol açar. Ancak, belleği verimsiz kullanıp hesaplamayı yavaşlattığı için broadcasting’in kötü bir fikir olduğu durumlar da vardır.

İki tensör, aşağıdaki kurallar sağlanıyorsa “broadcast edilebilir”dir:

• Her tensörün en az bir boyutu vardır.
• Boyutları, sondan başlayarak yinelediğinizde, boyutlar ya eşit olmalı, ya biri 1 olmalı ya da biri hiç var olmamalıdır.

Bunu PyTorch ile aşağıdaki kod parçacığı üzerinden anlayalım:

x=torch.empty(5,7,3)
y=torch.empty(5,7,3)
# aynı şekiller her zaman broadcast edilebilir (yani yukarıdaki kurallar her zaman sağlanır)

x=torch.empty((0,))
y=torch.empty(2,2)
# x ve y broadcast edilemez, çünkü x'in en az 1 boyutu yoktur

# sondaki boyutları hizalayabilirsiniz
x=torch.empty(5,3,4,1)
y=torch.empty(  3,1,1)
# x ve y broadcast edilebilir.
# 1. sondaki boyut: ikisinin de boyutu 1
# 2. sondaki boyut: y'nin boyutu 1
# 3. sondaki boyut: x boyutu == y boyutu
# 4. sondaki boyut: y boyutu yok

# ama:
>>> x=torch.empty(5,2,4,1)
>>> y=torch.empty(  3,1,1)
# x ve y broadcast edilemez, çünkü 3. sondaki boyutta 2 != 3

Artık broadcasting hakkında makul bir fikir edindiğinize göre, iki tensör “broadcast edilebilir” ise ortaya çıkacak sonuç tensörünün ne olacağına bakalım.

İki tensör x, y “broadcast edilebilir” ise, sonuç tensörünün boyutu şu şekilde hesaplanır:

x ve y’nin boyut sayıları eşit değilse, daha az boyutlu tensörün boyutlarının başına 1 ekleyerek eşit uzunluğa getirin. Ardından her boyut için sonuç boyutu, o boyuttaki x ve y boyutlarının maksimumudur. Örneğin:

# okumayı kolaylaştırmak için sondaki boyutları hizalayabilirsiniz
x=torch.empty(5,1,4,1)
y=torch.empty(  3,1,1)
(x+y).size()
torch.Size([5, 3, 4, 1])

torch.Size([5, 3, 4, 1])

# ama şart değil:
x=torch.empty(1)
y=torch.empty(3,1,7)
(x+y).size()
torch.Size([3, 1, 7])

torch.Size([3, 1, 7])

x=torch.empty(5,2,4,1)
y=torch.empty(3,1,1)
(x+y).size()

---------------------------------------------------------------------------

RuntimeError                              Traceback (most recent call last)

<ipython-input-17-72fb34250db7> in <module>()
      1 x=torch.empty(5,2,4,1)
      2 y=torch.empty(3,1,1)
----> 3 (x+y).size()


RuntimeError: The size of tensor a (2) must match the size of tensor b (3) at non-singleton dimension 1

Artık kavramı anladınız!

Tensör çarpımı, karşılaşabileceğiniz en yaygın tensör çarpma biçimidir, ancak tensör nokta çarpımı ve tensör daraltma gibi başka birçok tensör çarpımı türü de vardır.

Bir Torch Tensörünü bir NumPy dizisine ve tersini çevirmek çocuk oyuncağıdır. Bu kavrama NumPy Köprüsü denir. Bir bakalım.

NumPy Köprüsü

Torch Tensörü ve NumPy dizisi, alttaki bellek konumlarını paylaşır; birinde yapılan değişiklik diğerini de değiştirir.

Bir Torch Tensörünü NumPy Dizisine dönüştürme.

# 5 adet 1'den oluşan 1B tensör
a = torch.ones(5)
print(a)

tensor([ 1.,  1.,  1.,  1.,  1.])

# Torch tensörünü NumPy dizisine dönüştür
b = a.numpy()
print(b)

[1. 1. 1. 1. 1.]

NumPy dizisinin değerinin nasıl değiştiğine bakın.

Yani, yukarıdaki bölümlerde toplama, çıkarma ve tensör çarpımı gibi bazı temel Tensör aritmetiği yaptınız. Şimdi sonraki bölümde PyTorch ile basit bir sinir ağı uygulayacaksınız.

PyTorch kullanarak basit bir sinir ağı uygulamak

Sinir ağlarıyla ilgili bir hatırlatmaya ihtiyacınız varsa, bu DataCamp makalesi bakılacak en iyi kaynaktır. Şu bağlantılara da göz atmak isteyebilirsiniz:

• https://matrices.io/deep-neural-network-from-scratch/
• http://neuralnetworksanddeeplearning.com
• https://www.youtube.com/watch?v=bxe2T-V8XRs

Uygulamaya geçmeden önce, PyTorch’taki tüm sinir ağlarının merkezinde yer alan Otomatik Türev Alma adlı bir kavramı biraz tartışalım. Bu, geri yayılım sırasında gradyanları hesaplamak için özellikle kullanışlıdır.

autograd paketi, Tensörler üzerindeki tüm işlemler için otomatik türev alma sağlar. Bu, çalıştırarak tanımla (define-by-run) bir çerçevedir; yani geri yayılım, kodunuzun nasıl çalıştığına göre tanımlanır ve her tek yineleme farklı olabilir.

Otomatik Türev Almayı çok basit bir kod örneğiyle görelim.

# Tamamı 1'lerden oluşan 2. dereceden bir tensör oluşturun
x = torch.ones(2, 2, requires_grad=True)
print(x)

tensor([[ 1.,  1.],
        [ 1.,  1.]])

Bir toplama işlemi yapın.

y = x + 2
print(y)

tensor([[ 3.,  3.],
        [ 3.,  3.]])

y üzerinde birkaç işlem daha yapın.

z = y * y * 3
out = z.mean()

print(z, out)

tensor([[ 27.,  27.],
        [ 27.,  27.]]) tensor(27.)

Şimdi geri yayılım yapalım; çünkü out tek bir skaler içerdiğinden, out.backward() çağrısı out.backward(torch.tensor(1)) ile eşdeğerdir.

out.backward()

# gradyanları yazdır d(out)/dx
print(x.grad)

tensor([[ 4.5000,  4.5000],
        [ 4.5000,  4.5000]])

Artık Otomatik Türev Almayı ve PyTorch’un bunu nasıl ele aldığını biliyorsunuz. Şimdi PyTorch kullanarak basit bir sinir ağı kodlayacaksınız.

Tek gizli katmanlı ve tek çıktılı basit bir sinir ağı oluşturacaksınız. Gizli katmanda ReLU, çıktı katmanında ise sigmoid aktivasyonunu kullanacaksınız.

Önce PyTorch kütüphanesini içe aktarmanız gerekir. Sinir ağları torch.nn paketi kullanılarak oluşturulabilir.

import torch
import torch.nn as nn

Ardından tüm katmanların boyutlarını ve yığın boyutunu tanımlarsınız:

n_in, n_h, n_out, batch_size = 10, 5, 1, 10

Şimdi, bazı sahte giriş verileri x ve bazı sahte hedef verileri y oluşturacaksınız. Bu verileri depolamak için PyTorch Tensörlerini kullanacaksınız. PyTorch Tensörleri, NumPy dizileri gibi kullanılabilir ve değiştirilebilir; ancak PyTorch tensörlerinin GPU’larda çalıştırılabilmesi gibi ek bir avantajı vardır. Bu derste bunları CPU’da çalıştıracaksınız. Yine de, GPU’ya taşımak oldukça kolaydır.

x = torch.randn(batch_size, n_in)
y = torch.tensor([[1.0], [0.0], [0.0], [1.0], [1.0], [1.0], [0.0], [0.0], [1.0], [1.0]])

Ve şimdi, modelimizi tek satır kodla tanımlayacaksınız.

model = nn.Sequential(nn.Linear(n_in, n_h),
                     nn.ReLU(),
                     nn.Linear(n_h, n_out),
                     nn.Sigmoid())

Bu, giriş -> linear -> relu -> linear -> sigmoid şeklinde bir model oluşturur. Modellerinizi tanımlamanın, daha karmaşık ve özel modeller oluşturmak için kullanılan başka bir yolu daha vardır. Bunu bir sınıfta modelimizi tanımlayarak yaparız. Bunun hakkında buradan okuyabilirsiniz.

Şimdi, kayıp fonksiyonunuzu oluşturma zamanı. Ortalama Kare Hata (MSE) Kaybını kullanacaksınız.

criterion = torch.nn.MSELoss()

Ayrıca, eniyileyicinizi (optimizer) tanımlamayı unutmayın. Bu örnekte güçlü Stokastik Gradyan İnişi’ni ve 0.01 öğrenme oranını kullanacaksınız. model.parameters(), modelinizin parametreleri (ağırlıklar ve sapmalar) üzerinde bir yineleyici döndürür.

optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

Şimdi, 50 epoch boyunca Gradyan İnişi çalıştıracaksınız. Bu, sırasıyla ileri yayılım, kayıp hesaplama, geri yayılım ve parametre güncellemelerini yapar.

for epoch in range(50):
    # İleri Yayılım
    y_pred = model(x)
    # Kaybı hesapla ve yazdır
    loss = criterion(y_pred, y)
    print('epoch: ', epoch,' loss: ', loss.item())
    # Gradyanları sıfırla
    optimizer.zero_grad()

    # geri yayılım gerçekleştir
    loss.backward()

    # Parametreleri güncelle
    optimizer.step()

epoch:  0  loss:  0.2399429827928543
epoch:  1  loss:  0.23988191783428192
epoch:  2  loss:  0.23982088267803192
epoch:  3  loss:  0.2397598922252655
epoch:  4  loss:  0.23969893157482147
epoch:  5  loss:  0.23963800072669983
epoch:  6  loss:  0.23957709968090057
epoch:  7  loss:  0.23951618373394012
epoch:  8  loss:  0.23945537209510803
epoch:  9  loss:  0.23939454555511475
epoch:  10  loss:  0.23933371901512146
epoch:  11  loss:  0.23927298188209534
epoch:  12  loss:  0.23921218514442444
epoch:  13  loss:  0.23915143311023712
epoch:  14  loss:  0.2390907108783722
epoch:  15  loss:  0.23903003334999084
epoch:  16  loss:  0.23896940052509308
epoch:  17  loss:  0.23890872299671173
epoch:  18  loss:  0.23884813487529755
epoch:  19  loss:  0.23878750205039978
epoch:  20  loss:  0.23872694373130798
epoch:  21  loss:  0.2386663407087326
epoch:  22  loss:  0.2386058121919632
epoch:  23  loss:  0.23854532837867737
epoch:  24  loss:  0.23848481476306915
epoch:  25  loss:  0.23842433094978333
epoch:  26  loss:  0.2383638620376587
epoch:  27  loss:  0.23830339312553406
epoch:  28  loss:  0.2382429838180542
epoch:  29  loss:  0.23818258941173553
epoch:  30  loss:  0.2381247729063034
epoch:  31  loss:  0.2380656749010086
epoch:  32  loss:  0.23800739645957947
epoch:  33  loss:  0.2379491776227951
epoch:  34  loss:  0.2378900945186615
epoch:  35  loss:  0.23783239722251892
epoch:  36  loss:  0.23777374625205994
epoch:  37  loss:  0.23771481215953827
epoch:  38  loss:  0.23765745759010315
epoch:  39  loss:  0.23759838938713074
epoch:  40  loss:  0.23753997683525085
epoch:  41  loss:  0.2374821901321411
epoch:  42  loss:  0.23742322623729706
epoch:  43  loss:  0.23736533522605896
epoch:  44  loss:  0.23730707168579102
epoch:  45  loss:  0.23724813759326935
epoch:  46  loss:  0.23719079792499542
epoch:  47  loss:  0.23713204264640808
epoch:  48  loss:  0.23707345128059387
epoch:  49  loss:  0.2370160073041916

• y_pred, modelimizin ileri geçişinden (forward pass) elde edilen tahmin değerlerini alır. Bunu, hedef değerler y ile birlikte, kaybı hesaplayan criterion’a verirsiniz.

• Ardından optimizer.zero_grad() tüm gradyanları sıfırlar. Bunu, önceki gradyanların birikmeye devam etmemesi için yapmanız gerekir.

• Sonra loss.backward() PyTorch’un Autograd özelliğini kullanan asıl sihirdir. Autograd, dinamik olarak oluşturduğu hesaplama grafiğine dayanarak tüm parametreler için tüm gradyanları otomatik olarak hesaplar. Temelde bu, gradyan inişinin geri yayılımını gerçekleştirir.

• Son olarak optimizer.step() çağrısı, yeni gradyanları kullanarak tüm parametrelerde tek bir güncelleme yapar.

İşte sonuna geldiniz. Bu yazıda Tensörlerden Otomatik Türev Almaya ve daha fazlasına kadar bir dizi konuyu ele aldınız! Ayrıca PyTorch ve onun tensör sistemiyle basit bir sinir ağı uyguladınız.

PyTorch hakkında daha fazla öğrenmek ve derinlemesine dalmak isterseniz, PyTorch’un resmi dokümantasyon ve eğitimlerine göz atın. Gerçekten çok iyi yazılmışlar. Buradan bulabilirsiniz.

Bu öğreticiyi yazmama yardımcı olan bazı referanslar şunlardır:

• A Student’s Guide to Vectors and Tensors, 2011. bağlantı
• PyTorch’un resmi dokümantasyonu (bağlantıyı zaten belirtmiştim).
• Tensörlere nazik bir giriş - Machine Learning Mastery blogu.

Bir şey sormak veya tartışmak isterseniz yorumlarda bana bildirin!

Python hakkında daha fazla bilgi edinmekle ilgileniyorsanız, DataCamp’in Python’da İstatistiksel Düşünme (Bölüm 1) kursunu alın.