Graf Sinir Ağlarına (GNN) Kapsamlı Bir Giriş

Graf Nedir?

Graf, düğümler ve kenarlar içeren bir veri yapısı türüdür. Bir düğüm bir kişi, yer veya nesne olabilir; kenarlar ise düğümler arasındaki ilişkiyi tanımlar. Kenarlar, yönsel bağımlılıklara bağlı olarak yönlü veya yönsüz olabilir. 

Aşağıdaki örnekte, mavi daireler düğümleri, oklar ise kenarları gösterir. Kenarların yönü, iki düğüm arasındaki bağımlılıkları tanımlar. 

Görsel: Yazar 

Gelin, karmaşık bir Graf veri kümesini öğrenelim: Jazz Musicians Network. 198 düğüm ve 2742 kenar içerir. Aşağıdaki topluluk grafiği çiziminde, düğümlerin farklı renkleri çeşitli Caz müzisyen topluluklarını ve onları birbirine bağlayan kenarları temsil eder. Tek bir müzisyenin topluluk içinde ve dışında ilişkiler kurduğu bir iş birliği ağı vardır. 

 Topluluk Grafiği Çizimi: Jazz Musicians Network

Graf yapıları, ilişkiler ve etkileşimler içeren karmaşık problemlerle başa çıkmada son derece etkilidir. Desen tanıma, sosyal ağ analizi, tavsiye sistemleri ve anlamsal analizde kullanılırlar. Graf tabanlı çözümler geliştirmek, karmaşık ve birbirine bağlı veri kümeleri hakkında zengin içgörüler sunan bambaşka bir alandır.

NetworkX ile Graflar

Bu bölümde, NetworkX kullanarak bir graf oluşturmayı öğreneceğiz. 

Aşağıdaki kod, Daniel Holmberg'in Python'da Graf Sinir Ağları üzerine yazdığı blog yazısından esinlenmiştir.

1. networkx’in DiGraph nesnesi “H”yi oluşturun
2. Farklı etiketler, renkler ve boyutlar içeren düğümler ekleyin
3. İki düğüm arasında ilişki kurmak için kenarlar ekleyin. Örneğin, “(0,1)” 0'ın 1'e yönsel bağımlılığı olduğu anlamına gelir. “(1,0)” ekleyerek çift yönlü ilişkiler oluşturacağız
4. Renkleri ve boyutları liste olarak çıkarın
5. Grafı networkx’in draw fonksiyonuyla çizin

import networkx as nx
H = nx.DiGraph()

#adding nodes
H.add_nodes_from([
  (0, {"color": "blue", "size": 250}),

  (1, {"color": "yellow", "size": 400}),

  (2, {"color": "orange", "size": 150}),

  (3, {"color": "red", "size": 600})


])

#adding edges
H.add_edges_from([
  (0, 1),

  (1, 2),

  (1, 0),

  (1, 3),

  (2, 3),

  (3,0)


])

node_colors = nx.get_node_attributes(H, "color").values()
colors = list(node_colors)
node_sizes = nx.get_node_attributes(H, "size").values()
sizes = list(node_sizes)

#Plotting Graph
nx.draw(H, with_labels=True, node_color=colors, node_size=sizes)

Bir sonraki adımda, to_undirected() fonksiyonunu kullanarak veri yapısını yönlü bir graftan yönsüz bir grafa dönüştüreceğiz. 

#converting to undirected graph
G = H.to_undirected()
nx.draw(G, with_labels=True, node_color=colors, node_size=sizes)

Bir Grafı Analiz Etmek Neden Zordur?

Graf tabanlı veri yapılarının bazı dezavantajları vardır ve veri bilimcilerin, graf tabanlı çözümler geliştirmeden önce bunları anlaması gerekir.

1. Graf öklit dışı uzayda bulunur. 2B veya 3B uzayda yer almaz; bu da veriyi yorumlamayı zorlaştırır. Yapıyı 2B uzayda görselleştirmek için çeşitli boyut indirgeme araçları kullanmanız gerekir.
2. Graflar dinamiktir; sabit bir formları yoktur. Görsel olarak farklı iki graf olabilir; ancak benzer bitişiklik matrisi temsillerine sahip olabilirler. Bu da geleneksel istatistiksel araçlarla veriyi analiz etmeyi güçleştirir. 
3. Büyük boyut ve boyutsallık, grafın insan tarafından yorumlanmasını zorlaştırır. Birden çok düğüm ve binlerce kenara sahip yoğun bir yapı, anlamayı ve içgörü çıkarmayı zorlaştırır. 

Graf Sinir Ağı (GNN) Nedir?

Graf Sinir Ağları, graf veri yapısıyla çalışabilen özel sinir ağı türleridir. Evrişimsel Sinir Ağlarından (CNN) ve graf gömmelerinden güçlü şekilde etkilenmişlerdir. GNN'ler, düğüm, kenar ve graf tabanlı görevlerin tahmininde kullanılır. 

• CNN'ler görüntü sınıflandırmada kullanılır. Benzer şekilde, GNN'ler graf yapısına (piksel ızgarası) uygulanarak bir sınıf tahmini yapar. 
• Yinelemeli Sinir Ağları metin sınıflandırmada kullanılır. Benzer şekilde, GNN'ler her kelimenin bir cümlede düğüm olduğu graf yapıları üzerinde uygulanır.  

GNN'ler, grafın keyfi boyutu ve karmaşık yapısı nedeniyle Evrişimsel Sinir Ağlarının optimal sonuçlar elde edemediği durumlarda ortaya çıkmıştır. 

Görsel: Purvanshi Mehta

Girdi grafı bir dizi sinir ağından geçirilir. Girdi graf yapısı, düğümler, kenarlar ve genel bağlam bilgisini korumamızı sağlayan graf gömmesine dönüştürülür. 

Ardından A ve C düğümlerinin özellik vektörü sinir ağı katmanından geçirilir. Bu özellikleri birleştirir ve bir sonraki katmana aktarır - neptune.ai.

Daha fazla bilgi için Derin Öğrenme öğreticimizi okuyun veya Python ile Derin Öğrenmeye Giriş kursumuzu alın. 

Graf Sinir Ağlarının Türleri

Çeşitli sinir ağı türleri vardır ve çoğunun Evrişimsel Sinir Ağlarının bir varyasyonu bulunur. Bu bölümde, en popüler GNN'leri öğreneceğiz. 

• Graf Evrişimsel Ağlar (GCN), geleneksel CNN'lere benzer. Komşu düğümleri inceleyerek özellikleri öğrenir. GNN'ler düğüm vektörlerini toplar, sonucu yoğun katmana iletir ve aktivasyon fonksiyonu kullanarak doğrusal olmayanlık uygular. Kısaca, Graf evrişimi, doğrusal katman ve doğrusal olmayan aktivasyondan oluşur. İki ana GCN türü vardır: Uzamsal Evrişimsel Ağlar ve Spektral Evrişimsel Ağlar.
• Graf Otomatik Kodlayıcı Ağları, bir kodlayıcı kullanarak graf temsilini öğrenir ve bir kod çözücüyle girdi grafını yeniden oluşturmaya çalışır. Kodlayıcı ve kod çözücü, bir darboğaz katmanıyla birleştirilir. Sınıf dengesini iyi ele aldıkları için genellikle bağlantı tahmininde kullanılırlar. 
• Yinelemeli Graf Sinir Ağları (RGNN) en iyi yayılım desenini öğrenir ve tek bir düğümün birden fazla ilişkiye sahip olduğu çok ilişkili grafları işleyebilir. Bu tür graf sinir ağı, düzgünlüğü artırmak ve aşırı parametreleştirmeyi ortadan kaldırmak için düzenleyiciler kullanır. RGNN'ler daha az hesaplama gücüyle daha iyi sonuçlar üretir. Metin üretimi, makine çevirisi, konuşma tanıma, görsel açıklama üretimi, video etiketleme ve metin özetlemede kullanılırlar.
• Kapılı Graf Sinir Ağları (GGNN), uzun vadeli bağımlılıkları olan görevlerde RGNN'lerden daha iyidir. Kapılı Graf Sinir Ağları, uzun vadeli bağımlılıklara düğüm, kenar ve zaman kapıları ekleyerek Yinelemeli Graf Sinir Ağlarını iyileştirir. Kapılı Yinelemeli Birimler (GRU) gibi, kapılar farklı durumlarda bilgiyi hatırlamak ve unutmak için kullanılır. 

Yinelemeli Sinir Ağları (RNN) hakkında daha fazla bilgi edinmek istiyorsanız DataCamp’in kursuna göz atın. Çeşitli RNN model mimarilerini, Keras çerçevelerini ve RNN uygulamalarını tanıtacaktır. 

Graf Sinir Ağı Görevlerinin Türleri

Aşağıda, bazı GNN görevlerini örneklerle özetledik:

• Graf Sınıflandırma: grafları çeşitli kategorilere ayırmak için kullanırız. Uygulamaları arasında sosyal ağ analizi ve metin sınıflandırma yer alır. 
• Düğüm Sınıflandırma: bu görev, graf içinde eksik düğüm etiketlerini tahmin etmek için komşu düğüm etiketlerini kullanır. 
• Bağlantı Tahmini: eksik bitişiklik matrisine sahip bir grafta, bir düğüm çifti arasındaki bağlantıyı tahmin eder. Genellikle sosyal ağlarda kullanılır. 
• Topluluk Algılama: kenar yapısına göre düğümleri çeşitli kümelere ayırır. Kenar ağırlıklarından, mesafeden ve graf nesnelerinden benzer şekilde öğrenir. 
• Graf Gömme: grafları, düğümler, kenarlar ve yapı hakkındaki ilgili bilgileri koruyarak vektörlere eşler.
• Graf Üretimi: örnek graf dağılımından öğrenerek yeni ancak benzer bir graf yapısı üretir. 

Görsel: Yazar

Graf Sinir Ağlarının Dezavantajları

GNN kullanmanın birkaç dezavantajı vardır. Bunları anlamak, GNN'leri ne zaman kullanacağımızı ve makine öğrenimi modellerimizin performansını nasıl optimize edeceğimizi belirlememize yardımcı olur. 

1. Çoğu sinir ağı daha derine inerek daha iyi performans elde edebilirken, GNN'ler sığ ağlardır ve çoğunlukla üç katmandan oluşur. Bu da büyük veri kümelerinde son teknoloji performansa ulaşmamızı sınırlar.
2. Graf yapıları sürekli değişir; bu da üzerinde bir model eğitmeyi zorlaştırır. 
3. Modeli üretime alma aşaması, bu ağlar hesaplama açısından maliyetli olduğundan ölçeklenebilirlik sorunları ile karşılaşır. Büyük ve karmaşık bir graf yapınız varsa, GNN'leri üretimde ölçeklendirmek zor olacaktır. 

Graf Evrişimsel Ağ (GCN) Nedir?

GNN'lerin çoğunluğu Graf Evrişimsel Ağlardır; düğüm sınıflandırma öğreticisine geçmeden önce bunları öğrenmek önemlidir.  

GCN'deki evrişim, evrişimsel sinir ağlarındaki evrişimle aynıdır. Verinin özelliklerinden öğrenmek için nöronları ağırlıklarla (filtrelerle) çarpar. 

Tüm görüntü üzerinde kayan pencereler gibi davranarak komşu hücrelerden özellikler öğrenir. Filtre, görüntü tanıma sistemlerinde çeşitli yüz özelliklerini öğrenmek için ağırlık paylaşımı kullanır - Towards Data Science. 

Şimdi aynı işlevselliği, modelin komşu düğümlerden özellikler öğrendiği Graf Evrişimsel Ağlara aktarın. GCN ile CNN arasındaki temel fark, GCN'nin düğüm ve kenar sırasının değişebildiği öklit dışı veri yapıları üzerinde çalışacak şekilde geliştirilmiş olmasıdır. 

CNN vs GCN | Görsel Kaynağı

Temel CNN'ler hakkında daha fazla bilgi edinmek için TensorFlow ile Evrişimsel Sinir Ağları (CNN) öğreticisini takip edin. 

İki tür GCN vardır: 

• Uzamsal Graf Evrişimsel Ağlar, uzamsal uzayda konumlanan graflardan öğrenmek için uzamsal özellikleri kullanır.  
• Spektral Graf Evrişimsel Ağlar, bilgi yayılımını düğümler boyunca gerçekleştirmek için graf Laplasyen matrisinin öz-ayrışımını kullanır. Bu ağlar, sinyaller ve sistemlerde dalga yayılımından esinlenmiştir. 

GNN'ler Nasıl Çalışır? Pytorch ile Bir Graf Sinir Ağı Kurma

Bir düğüm sınıflandırma modeli için Spektral Graf Evrişimini oluşturup eğiteceğiz. Kod kaynağı, ilk graf tabanlı makine öğrenimi modelinizi deneyimlemeniz ve çalıştırmanız için bu DataLab çalışma kitabında mevcuttur. 

Kod örnekleri, Pytorch geometric dokümantasyonundan esinlenmiştir. 

Başlarken

pytorch_geometric, Pytorch üzerine inşa edildiği için onu kuracağız. 

!pip install -q torch

Daha sonra torch sürümünü kullanarak torch-scatter ve torch-sparse paketlerini kuracağız. Ardından, pytorch_geometric'in en son sürümünü GitHub'dan kuracağız. 

%%capture
import os
import torch
os.environ['TORCH'] = torch.__version__
os.environ['PYTHONWARNINGS'] = "ignore"
!pip install torch-scatter -f https://data.pyg.org/whl/torch-${TORCH}.html
!pip install torch-sparse -f https://data.pyg.org/whl/torch-${TORCH}.html
!pip install git+https://github.com/pyg-team/pytorch_geometric.git

Planetoid Cora Veri Kümesi

Planetoid, Cora, CiteSeer ve PubMed'den alıntı ağı veri kümeleridir. Düğümler, 1433 boyutlu kelime torbası özellik vektörlerine sahip belgelerdir; kenarlar ise araştırma makaleleri arasındaki atıf bağlantılarıdır. 7 sınıf vardır ve modeli eksik etiketleri tahmin edecek şekilde eğiteceğiz. 

Planetoid Cora veri kümesini içe alacağız ve kelime torbası girdi özelliklerini satır normalizasyonu yapacağız. Sonrasında veri kümesini ve ilk graf nesnesini inceleyeceğiz. 

from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures

dataset = Planetoid(root='data/Planetoid', name='Cora', transform=NormalizeFeatures())

print(f'Dataset: {dataset}:')
print('======================')
print(f'Number of graphs: {len(dataset)}')
print(f'Number of features: {dataset.num_features}')
print(f'Number of classes: {dataset.num_classes}')

data = dataset[0]  # Get the first graph object.
print(data)

Cora veri kümesi 2708 düğüm, 10.556 kenar, 1433 özellik ve 7 sınıfa sahiptir. İlk nesne 2708 eğitim, doğrulama ve test maskesine sahiptir. Bu maskeleri modeli eğitmek ve değerlendirmek için kullanacağız. 

Dataset: Cora():
======================
Number of graphs: 1
Number of features: 1433
Number of classes: 7
Data(x=[2708, 1433], edge_index=[2, 10556], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708])

GNN ile Düğüm Sınıflandırma

GCNConv katmanlarından ikisi, relu aktivasyonu ve 0,5 dropout oranı içeren bir GCN model yapısı oluşturacağız. Model 16 gizli kanaldan oluşmaktadır.  

GCN katmanı:

Yukarıdaki denklemde W(ℓ+1) eğitilebilir bir ağırlık matrisidir ve Cw,v her kenar için sabit bir normalleştirme katsayısını ifade eder.

from torch_geometric.nn import GCNConv
import torch.nn.functional as F

class GCN(torch.nn.Module):
    def __init__(self, hidden_channels):
        super().__init__()
        torch.manual_seed(1234567)
        self.conv1 = GCNConv(dataset.num_features, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, dataset.num_classes)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = x.relu()
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x

model = GCN(hidden_channels=16)
print(model)

>>> GCN(
    (conv1): GCNConv(1433, 16)
    (conv2): GCNConv(16, 7)
  )

Eğitilmemiş GCN Ağının Görselleştirilmesi

sklearn.manifold.TSNE ve matplotlib.pyplot kullanarak eğitilmemiş GCN ağlarının düğüm gömmelerini görselleştirelim. 7 boyutlu düğüm gömmesini 2B saçılım grafiğinde çizecektir.  

%matplotlib inline
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE

def visualize(h, color):
    z = TSNE(n_components=2).fit_transform(h.detach().cpu().numpy())

    plt.figure(figsize=(10,10))
    plt.xticks([])
    plt.yticks([])

    plt.scatter(z[:, 0], z[:, 1], s=70, c=color, cmap="Set2")
    plt.show()

Modeli değerlendirecek, ardından eğitilmemiş modele eğitim verisi ekleyerek çeşitli düğümleri ve kategorileri görselleştireceğiz. 

model.eval()

out = model(data.x, data.edge_index)
visualize(out, color=data.y)

GNN Eğitimi

Modelimizi Adam optimizasyonu ve Çapraz Entropi Kayıp fonksiyonunu kullanarak 100 Epoch boyunca eğiteceğiz. 

Eğitim (train) fonksiyonunda şunlar var:

1. Gradyanı temizleme
2. Tek bir ileri geçiş gerçekleştirme
3. Eğitim düğümlerini kullanarak kaybı hesaplama
4. Gradyanı hesaplayıp parametreleri güncelleme

Test (test) fonksiyonunda şunlar var:

1. Düğüm sınıfını tahmin etme
2. En yüksek olasılığa sahip sınıf etiketini çıkarma
3. Kaç değerin doğru tahmin edildiğini kontrol etme
4. Doğru tahminlerin toplamını toplam düğüm sayısına bölerek doğruluk oranını oluşturma. 

model = GCN(hidden_channels=16)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
criterion = torch.nn.CrossEntropyLoss()

def train():
      model.train()
      optimizer.zero_grad()
      out = model(data.x, data.edge_index)
      loss = criterion(out[data.train_mask], data.y[data.train_mask])
      loss.backward()
      optimizer.step()
      return loss

def test():
      model.eval()
      out = model(data.x, data.edge_index)
      pred = out.argmax(dim=1)
      test_correct = pred[data.test_mask] == data.y[data.test_mask]
      test_acc = int(test_correct.sum()) / int(data.test_mask.sum())
      return test_acc


for epoch in range(1, 101):
    loss = train()
    print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}')
GAT(
  (conv1): GATConv(1433, 8, heads=8)
  (conv2): GATConv(64, 7, heads=8)
)

.. .. .. ..
.. .. .. ..
Epoch: 098, Loss: 0.5989
Epoch: 099, Loss: 0.6021
Epoch: 100, Loss: 0.5799

Model Değerlendirmesi

Şimdi modeli görülmemiş bir veri kümesi üzerinde test fonksiyonunu kullanarak değerlendireceğiz ve gördüğünüz gibi %81,5 doğruluk gibi oldukça iyi bir sonuç elde ettik.  

test_acc = test()
print(f'Test Accuracy: {test_acc:.4f}')


>>> Test Accuracy: 0.8150

Şimdi sonuçları doğrulamak için eğitilmiş bir modelin çıktı gömmesini görselleştireceğiz.

model.eval()
out = model(data.x, data.edge_index)
visualize(out, color=data.y)

Gördüğümüz üzere, eğitilmiş model aynı kategori için daha iyi düğüm kümelenmesi üretmiştir.

GATConv Modelinin Eğitimi

İkinci olarak, GCNConv'u GATConv katmanlarıyla değiştireceğiz. Graf Dikkat Ağları, GCNConv'un dezavantajlarını gidermek ve son teknoloji sonuçlara ulaşmak için maskelenmiş öz-dikkat katmanları kullanır. 

Ayrıca diğer GNN katmanlarını da deneyebilir; daha iyi performans için optimizasyonlar, dropout oranları ve gizli kanal sayılarıyla oynayabilirsiniz. 

Aşağıdaki kodda, ilk katmanda 8 dikkat başlığı ve ikinci katmanda 1 başlık olacak şekilde GCNConv'u GATConv ile değiştirdik. 

Ayrıca şunları ayarlayacağız:

• dropout oranı 0,6
• gizli kanallar 8
• öğrenme oranı 0,005

test fonksiyonunu, belirli bir maske (doğrulama, test) için doğruluğu bulacak şekilde değiştirdik. Bu, model eğitimi sırasında doğrulama ve test skorlarını yazdırmamıza yardımcı olacaktır. Ayrıca doğrulama ve test sonuçlarını daha sonra bir çizgi grafikte göstermek üzere saklıyoruz. 

from torch_geometric.nn import GATConv

class GAT(torch.nn.Module):
    def __init__(self, hidden_channels, heads):
        super().__init__()
        torch.manual_seed(1234567)
        self.conv1 = GATConv(dataset.num_features, hidden_channels,heads)
        self.conv2 = GATConv(heads*hidden_channels, dataset.num_classes,heads)

    def forward(self, x, edge_index):
        x = F.dropout(x, p=0.6, training=self.training)
        x = self.conv1(x, edge_index)
        x = F.elu(x)
        x = F.dropout(x, p=0.6, training=self.training)
        x = self.conv2(x, edge_index)
        return x

model = GAT(hidden_channels=8, heads=8)
print(model)

optimizer = torch.optim.Adam(model.parameters(), lr=0.005, weight_decay=5e-4)
criterion = torch.nn.CrossEntropyLoss()

def train():
      model.train()
      optimizer.zero_grad()
      out = model(data.x, data.edge_index)
      loss = criterion(out[data.train_mask], data.y[data.train_mask])
      loss.backward()
      optimizer.step()
      return loss

def test(mask):
      model.eval()
      out = model(data.x, data.edge_index)
      pred = out.argmax(dim=1)
      correct = pred[mask] == data.y[mask]
      acc = int(correct.sum()) / int(mask.sum())
      return acc

val_acc_all = []
test_acc_all = []

for epoch in range(1, 101):
    loss = train()
    val_acc = test(data.val_mask)
    test_acc = test(data.test_mask)
    val_acc_all.append(val_acc)
    test_acc_all.append(test_acc)
    print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Val: {val_acc:.4f}, Test: {test_acc:.4f}')

.. .. .. ..
.. .. .. ..
Epoch: 098, Loss: 1.1283, Val: 0.7960, Test: 0.8030

Epoch: 099, Loss: 1.1352, Val: 0.7940, Test: 0.8050

Epoch: 100, Loss: 1.1053, Val: 0.7960, Test: 0.8040

Gözlemleyebileceğimiz üzere, modelimiz GCNConv'dan daha iyi performans göstermedi. Son teknoloji sonuçlara ulaşmak için hiperparametre optimizasyonu veya daha fazla Epoch gerekebilir. 

Model Değerlendirmesi

Değerlendirme kısmında, doğrulama ve test skorlarını matplotlib.pyplot'un çizgi grafiğiyle görselleştiriyoruz.  

import numpy as np

plt.figure(figsize=(12,8))
plt.plot(np.arange(1, len(val_acc_all) + 1), val_acc_all, label='Validation accuracy', c='blue')
plt.plot(np.arange(1, len(test_acc_all) + 1), test_acc_all, label='Testing accuracy', c='red')
plt.xlabel('Epochs')
plt.ylabel('Accurarcy')
plt.title('GATConv')
plt.legend(loc='lower right', fontsize='x-large')
plt.savefig('gat_loss.png')
plt.show()

60 Epoch sonrasında, doğrulama ve test doğruluğu 0,8 +/-0,02 gibi kararlı bir değere ulaşmıştır. 

Yine, GATConv modelinin düğüm kümelenmesini görselleştirelim.

model.eval()

out = model(data.x, data.edge_index)
visualize(out, color=data.y)

Görüldüğü gibi, GATConv katmanı aynı kategoriye ait düğümlerin kümelenmesinde benzer sonuçlar üretmiştir. 

Aşırı uyumu, ikinci bir doğrulama veri kümesi ekleyerek azaltabilir ve pytoch_geometric'teki çeşitli GCN katmanlarını deneyerek model performansını artırabilirsiniz. 

Öğreticinin kaynak kodu bu DataLab çalışma kitabında mevcuttur. Çalıştırabileceğiniz bir kopyasını oluşturun.

Özgeçmişinize Derin Öğrenme becerisini eklemek için Python'da Derin Öğrenme beceri yolunu alın. Derin öğrenme algoritmalarını, Keras, Pytorch ve Tensorflow çerçevesini tanıtacaktır.