Mixture of Depths (MoD)

Derin öğrenme mimarilerinde, özellikle uzun diziler veya yüksek çözünürlüklü girdiler işlenirken hesaplama verimliliği son derece önemlidir. Yeni bir yaklaşım, ağın hangi girdi bölümlerinin tam işleme gerektirdiğine ve hangilerinin belirli katmanları güvenle atlayabileceğine karar vermesine izin vererek hesaplama kaynaklarını dinamik olarak 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.

Link to this sectionKavramı Anlamak#

Mixture of Depths (MoD), temel olarak modelin çeşitli katmanlardaki belirli tokenlar için hesaplamayı dinamik olarak atlamayı öğrendiği Transformer mimarilerine uygulanan bir mimari tekniktir. Geleneksel transformerlar, ister kritik bir bilgi parçası ister dolgu içeriği olsun, her tokenı her katmandan geçirir. Buna karşılık bir MoD modeli, tokenları değerlendirmek ve onlara bir puan atamak için bir yönlendirici mekanizma kullanır. Yalnızca önceden tanımlanmış bir kapasite sınırına kadar en yüksek puanı alan tokenlar, dikkat mekanizmaları veya yoğun ileri beslemeli katmanlar gibi ağır hesaplama bloklarından geçirilir. Kalan tokenlar, kalıntı bağlantılar aracılığıyla bloğu atlayarak, farklı tokenların değişen işleme derinliği seviyeleri yaşadığı bir "derinlik karışımı" oluşturur.

Yakın zamandaki DeepMind araştırmaları tarafından popüler hale getirilen ve arXiv deposunda kapsamlı bir şekilde belgelenen bu yöntem, hem eğitim hem de çıkarım sırasında gereken toplam kayan noktalı işlem (FLOP) sayısını önemli ölçüde azaltır.

Link to this sectionMixture of Experts (MoE) ile Farklılaşma#

Bu kavramı bir Mixture of Experts (MoE) ile karıştırmak kolaydır. Her ikisi de yönlendirme mekanizmaları kullansa da, farklı sorunları çözerler:

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

Link to this sectionGerçek Dünya Uygulamaları#

Hesaplama bütçesini dinamik olarak yönetebilme yeteneği, bu tekniği bilgisayarlı görü ve doğal dil işleme alanlarının genelinde son derece değerli kılar.

1. Context Optimization in Language Models: Modern Large Language Models (LLMs) from organizations like OpenAI and Anthropic process massive context windows. By employing dynamic depth routing, these models can skip structural or repetitive filler words, reserving deep computation for complex reasoning steps and factual extraction.

2. High-Resolution Vision AI: In advanced vision systems like the Ultralytics YOLO26 model, processing large images for object detection and image segmentation requires immense memory. Depth routing allows the network to bypass feature extraction on uniform backgrounds (like empty skies or blank walls), focusing computational power on intricate foreground objects. This is crucial for deploying models to resource-constrained edge AI hardware optimized by CUDA optimization libraries.

Link to this sectionUygulama Örneği#

Aşağıda, temel bir yönlendirme mekanizmasının derinlik yönlendirme davranışını simüle ederek girdi tokenlarının bir kısmı için hesaplamayı nasıl atlayabileceğini gösteren kavramsal bir PyTorch kod parçacığı bulunmaktadı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)

By leveraging frameworks like the PyTorch framework or TensorFlow, developers can integrate these custom model optimization blocks. Furthermore, tools like the Ultralytics Platform help teams manage the training data required to accurately train these routers, alongside integrating seamlessly with enterprise ecosystems like Google Cloud AI.