Mixture of Depths (MoD)

Derin öğrenme mimarilerinde, özellikle uzun diziler veya yüksek çözünürlüklü girdiler işlenirken hesaplama verimliliği büyük önem taşır. Yeni bir yaklaşım, ağın girdinin hangi bölümlerinin tamamen işlenmesi gerektiğine ve hangilerinin belirli katmanları güvenle atlayabileceğine karar vermesine olanak tanıyarak hesaplama kaynaklarını dinamik biçimde tahsis eder. Bu dinamik yönlendirme stratejisi, modelin tahmin gücünden veya doğruluğundan ödün vermeden genel hesaplama karmaşıklığını azaltır.

Kavramı Anlamak#

Derinlik Karışımı (MoD), öncelikle Transformer mimarilerine uygulanan ve modelin çeşitli katmanlarda belirli belirteçler için hesaplamayı dinamik olarak atlamayı öğrendiği bir mimari tekniktir. Geleneksel Transformer modelleri, kritik bir bilgi parçası veya dolgu içeriği olmasına bakmaksızın her belirteci her katmandan geçirir. Buna karşılık bir MoD modeli, belirteçleri değerlendirmek ve onlara bir puan vermek için bir yönlendirici mekanizması kullanır. Yalnızca en yüksek puanlı belirteçler (önceden tanımlanmış kapasite sınırına kadar), dikkat mekanizmaları veya yoğun ileri beslemeli katmanlar gibi ağır hesaplama bloklarından geçirilir. Kalan belirteçler, artık bağlantılar aracılığıyla bloğu atlar ve farklı belirteçlerin farklı işlem derinlikleriyle karşılaştığı bir "derinlik karışımı" oluşturur.

Yakın tarihli DeepMind araştırmaları tarafından yaygınlaştırılan ve arXiv deposunda kapsamlı biçimde belgelenen bu yöntem, hem eğitim hem de çıkarım sırasında gereken toplam kayan nokta işlemlerini (FLOPs) büyük ölçüde azaltır.

Uzman Karışımından (MoE) Farkı#

Bu kavramı bir Uzman Karışımı (MoE) ile karıştırmak kolaydır. Her ikisi de yönlendirme mekanizmaları kullansa da farklı sorunları çözer:

• MoE, belirteçleri bir katman içindeki farklı alt ağlara (uzmanlara) yönlendirir. Hesaplama derinliği tüm belirteçler için aynı kalır, ancak modelin parametre sayısı artar.
• MoD, belirteçleri ya hesaplama bloğuna ya da bir atlama bağlantısına yönlendirir. Parametre sayısı kesin olarak sabit kalır, ancak daha az önemli belirteçler için hesaplama derinliği azalır ve çıkarım gecikmesi doğrudan iyileştirilir.

Gerçek Dünya Uygulamaları#

Hesaplama bütçesini dinamik olarak belirleyebilme özelliği, bu tekniği birçok bilgisayarlı görü ve doğal dil işleme alanında son derece değerli kılar.

1. Dil Modellerinde Bağlam Optimizasyonu: OpenAI ve Anthropic gibi kuruluşların geliştirdiği modern Büyük Dil Modelleri (LLMs), devasa bağlam pencerelerini işler. Dinamik derinlik yönlendirmesinden yararlanan bu modeller, yapısal veya tekrarlanan dolgu sözcüklerini atlayarak derin hesaplamayı karmaşık akıl yürütme adımlarına ve olgusal bilgi çıkarımına ayırabilir.

2. Yüksek Çözünürlüklü Görü Yapay Zekâsı: Ultralytics YOLO26 modeli gibi gelişmiş görü sistemlerinde, nesne algılama ve görüntü segmentasyonu için büyük görüntülerin işlenmesi muazzam miktarda bellek gerektirir. Derinlik yönlendirmesi, ağın tekdüze arka planlarda (boş gökyüzü veya sade duvarlar gibi) özellik çıkarımını atlamasına ve hesaplama gücünü karmaşık ön plan nesnelerine odaklamasına olanak tanır. Bu, CUDA optimizasyonu kitaplıklarıyla optimize edilen, kaynakları kısıtlı uç yapay zekâ donanımlarına model dağıtımı için kritik öneme sahiptir.

Uygulama Örneği#

Aşağıda, temel bir yönlendirme mekanizmasının girdi belirteçlerinin bir bölümü için hesaplamayı nasıl atlayabileceğini ve derinlik yönlendirme davranışını nasıl taklit edebileceğini gösteren kavramsal bir PyTorch kod parçacığı yer alır.

import torch
import torch.nn as nn


class MixtureOfDepthsBlock(nn.Module):
    def __init__(self, d_model, capacity_factor=0.5):
        super().__init__()
        self.capacity_factor = capacity_factor
        self.router = nn.Linear(d_model, 1)
        self.heavy_compute = nn.Sequential(nn.Linear(d_model, d_model * 4), nn.GELU(), nn.Linear(d_model * 4, d_model))

    def forward(self, x):
        # x shape: (batch_size, seq_len, d_model)
        seq_len = x.size(1)
        capacity = int(seq_len * self.capacity_factor)

        # 1. Compute routing scores
        scores = self.router(x).squeeze(-1)  # Shape: (batch_size, seq_len)

        # 2. Identify top-k tokens to process
        topk_indices = torch.topk(scores, capacity, dim=1).indices

        # 3. Create an output tensor mirroring the input (residual baseline)
        output = x.clone()

        # 4. Apply heavy computation only to the selected tokens
        for b in range(x.size(0)):
            selected_tokens = x[b, topk_indices[b]]
            processed_tokens = self.heavy_compute(selected_tokens)
            output[b, topk_indices[b]] += processed_tokens

        return output


# Example usage
dummy_input = torch.randn(2, 64, 128)  # Batch=2, Seq=64, Dim=128
mod_block = MixtureOfDepthsBlock(d_model=128, capacity_factor=0.5)
output = mod_block(dummy_input)
print(f"Output shape: {output.shape}")  # Expect (2, 64, 128)

PyTorch framework'ü veya TensorFlow gibi çerçevelerden yararlanan geliştiriciler, bu özel model optimizasyonu bloklarını entegre edebilir. Ayrıca Ultralytics Platformu, ekiplerin bu yönlendiricileri doğru biçimde eğitmek için gereken eğitim verilerini yönetmesine ve Google Cloud AI gibi kurumsal ekosistemlerle sorunsuz biçimde entegrasyon sağlamasına yardımcı olur.