Bir Bakışta Yapay Sinir Ağları 8: Hibrit Mimariler

Nöronal ağlar birçok AI ve Genai uygulamasının motorudur. Bu makale dizisi bireysel unsurlar hakkında bir fikir sunar. Sekizinci kısım hibrit mimarilere adanmıştır.

Gerçek dünyadaki veriler genellikle farklı yapısal boyutlara sahiptir. Örneğin, videolar her bir kare içinde uzay motifleri ve çerçevelerden zamansal motiflere sahiptir. Hibrit mimariler, tekrarlayan ve çok karmaşık verileri modellemek için saldırıya dayanarak cogial tabakaların güçlü yönlerini birleştirir. Bu bölüm iki yaygın şemayı göstermektedir: Meclis üyesi, ardından kendi kendini düzenleme (kendi kendine ayarlama) ile birlikte nüks ve şekerleme.

Video sınıflandırması için klasik bir hibrit model başlangıçta her görüntü için bir dizi katlama seviyesi kullanır ve bu nedenle boşluk yapısını yakalayan bir görüntü taşıyıcısı oluşturur. Bu görüntü vektörleri bu nedenle zamansal bağımlılıkları modelleyen tekrar eden bir ağa eklenir. Özellikle, formun bir tensörü olarak bir video yığınımız olduğunu varsayalım (batch_size,, seq_len,, channels,, height,, width) gösterilir. Önce tüm çerçeveleri dönüştürebilir ve bir 2D CNN üzerinden işleyebiliriz, ardından zamansal ekseni geri yükleyebilir ve bir LSTM (uzun vadeli kısa vadeli bellek) kullanabiliriz:

import torch  
import torch.nn as nn  

Klasse CNNLSTM(nn.Module):  
    def __init__(self, num_classes, cnn_out_dim=128, hidden_dim=64):  
        super(CNNLSTM, self).__init__()  
        # Ein einfaches CNN, das (C,H,W) auf cnn_out_dim abbildet  
        self.cnn = nn.Sequential(  
            nn.Conv2d(3, 32, kernel_size=3, padding=1),  
            nn.ReLU(),  
            nn.MaxPool2d(2),            # halbiert H,W  
            nn.Conv2d(32, 64, 3, padding=1),  
            nn.ReLU(),  
            nn.AdaptiveAvgPool2d((1,1)) # globales Merkmal  
        )  
        # Lineare Schicht zum Abflachen der CNN-Ausgabe  
        self.fc   = nn.Linear(64, cnn_out_dim)  
        # LSTM zur Modellierung der zeitlichen Abfolge von Frame-Merkmalen  
        self.lstm = nn.LSTM(input_size=cnn_out_dim,  
                            hidden_size=hidden_dim,  
                            num_layers=1,  
                            batch_first=True)  
        # Endgültiger Klassifikator, der die LSTM-Ausgabe den Klassenlogits zuordnet  
        self.classifier = nn.Linear(hidden_dim, num_classes)  

    def forward(self, videos):  
        # videos: (batch, seq_len, C, H, W)  
        b, t, c, h, w = videos.shape  
        # Batch und Zeit für CNN-Verarbeitung zusammenführen  
        frames = videos.view(b * t, c, h, w)  
        features = self.cnn(frames)         # (b*t, 64, 1, 1)  
        features = features.view(b * t, 64)  
        features = self.fc(features)        # (b*t, cnn_out_dim)  
        # Batch- und Zeitdimensionen wiederherstellen  
        features = features.view(b, t, -1)  # (b, t, cnn_out_dim)  
        # LSTM erwartet (Batch, seq_len, Merkmal)  
        lstm_out, _ = self.lstm(features)   # (b, t, hidden_dim)  
        # Verwenden Sie den endgültigen versteckten Zustand von LSTM für die Klassifizierung  
        final = lstm_out[:, -1, :]          # (b, hidden_dim)  
        logits = self.classifier(final)     # (b, num_classes)  
        return logits  

# Anwendungsbeispiel  
model = CNNLSTM(num_classes=10)  
dummy_videos = torch.randn(4, 16, 3, 64, 64)  # Stapel mit jeweils 4, 16 Frames  
outputs = model(dummy_videos)                  # (4, 10)  

Bu kodda, orta uyarlanabilir havuzlama, özelliklerin her haritasını tek bir sayıdaki azaltır ve alan kartını uzunluk 64 vektörüne dönüştürür. Doğrusal seviye, bu taşıyıcıyı her bir kare için 128 boyutlu bir özellikte yansıtır. Tensörü dönüştürmek a (batch, seq_len, feature_dim) Modellerin zamanla nasıl geliştiğini kaydeden bir LSTM'de çerçevenin özelliklerini besleriz. Sonunda LSTM'nin en son baskısını alıyoruz ve sınıf puanları oluşturmak için size doğrusal bir sınıflandırıcı aracılığıyla rehberlik ediyoruz.

Alternatif bir hibrit yaklaşım, tekrar eden ağın bir dikkat mekanizması ile yerini alır. İşlev kartlarının bir CNN (evrişimsel sinir ağı) ile çıkarılmasından sonra, uzun vadeli bağımlılıkları modellemek için jeton gibi herhangi bir mekansal yeri (veya her bir çerçeveyi) tedavi etmek ve araç kullanmak mümkündür. Öz -farkındalık çekirdeği, Q, K ve V'nin sorguları, anahtarları ve değer taşıyıcılarının bir ifadesini hesaplayan tırmanma ürününün formülüdür:

Dikkat (q, k, v) = softmax ((q · kᵀ) / √d_k) · v

Burada d_k anahtarın boyutudur ve softmax vektörleri her sorgu için birine dönüşen dikkat ağırlıkları oluşturur. Pytorch'ta aşağıdaki gibi tek bir daha fazla kafa istasyonu uygulamak mümkündür:

import torch.nn.functional as F  

class CNNAttention(nn.Module):  
    def __init__(self, cnn_out_dim=128, num_heads=4):  
        super().__init__()  
        # CNN-Merkmalsextraktor (ähnlich wie zuvor)  
        self.cnn = nn.Sequential(  
            nn.Conv2d(3, 64, 3, padding=1),  
            nn.ReLU(),  
            nn.MaxPool2d(2),  
            nn.Conv2d(64, cnn_out_dim, 3, padding=1),  
            nn.ReLU()  
        )  
        # Multi-Head-Aufmerksamkeitsschicht  
        self.attn = nn.MultiheadAttention(embed_dim=cnn_out_dim,  
                                          num_heads=num_heads,  
                                          batch_first=True)  
        # Klassifikator  
        self.classifier = nn.Linear(cnn_out_dim, 10)  

    def forward(self, images):  
        # Bilder: (Batch, C, H, W)  
        features = self.cnn(images)       # (b, cnn_out_dim, H', W')  
        b, d, h, w = features.shape  
        # Räumliche Dimensionen in Sequenz abflachen  
        seq = features.view(b, d, h*w).permute(0, 2, 1)  
        # Selbstaufmerksamkeit über räumliche Token  
        attn_out, _ = self.attn(seq, seq, seq)  # (b, h*w, d)  
        # Über Tokens hinweg durch Mittelwertbildung bündeln  
        pooled = attn_out.mean(dim=1)            # (b, d)  
        logits = self.classifier(pooled)         # (b, 10)  
        return logits  

# Anwendungsbeispiel  
model = CNNAttention()  
dummy_images = torch.randn(4, 3, 32, 32)  
outputs = model(dummy_images)  # (4,10)  

Bu hibrit tasarım, karakteristik vektörlerden yapılmış uzamsal bir ızgara oluşturmak için katlanır katmanları kullanır. Izgarayı H ’′ W ′ uzunluğunda bir diziye düzleştirme, her yeri bir jeton gibi ele alıyoruz. Modül nn.MultiheadAttention Sorgu, anahtarlar ve değer projeksiyonlarının farklı cümlelerini hesaplayın, bunları zincirledi ve orijinal boyuta yansıtın, böylece model uzay bölgeleri arasında çeşitli ilişkiler kaydedebilir. Tüm jetonlardaki medya oluşumu size sınıflandırıcının kullanabileceği küresel bir temsil sunar.

Hibrit mimariler, konumları, sırayı ve küresel bağlamı tek bir modelde kullanmanıza olanak tanır. Videoları anlamaktan görüntü etiketine ve ötesine kadar değişen uygulamalarda kullanılırlar.

Serinin bir sonraki kısmı nöronal ağların geleceğini inceliyor ve hangi eğilimlerin, yeni nesil modellerin formunu gösteriyor.

(RME)