Bu, çok ölçekli nesne algılamasını geliştirmek için geliştirilen özellik çıkarma bloklarının tasarımıyla ilgili bir makaledir ve aynı zamanda gerçek dünyada uygulamalarda hızlı sonuçlandırma sağlar. Çapraz aşamalı kısmi bağlantılar (Cross-stage partial connections - CSP) Öncelikle Tekin et al. [ ] bu mimari yenilikleri tanıttı ve daha büyük konvülsiyonel nöral ağ arka planlarında aşırı dereceli bilgi sorunu ele aldı. ana hedefi, hesaplama maliyetini azaltırken aşırı dereceli etkileşimleri zenginleştirmektir. Çapraz aşamalı kısmi bağlantılar (CSP), her ağ aşamasının başlangıcından ve sonundaki özellik haritalarını birleştirerek gradient çeşitliliğini korur: temel tabaka özellik haritaları ikiye bölünür: biri yoğun bir blok ve geçiş tabakasını geçirirken, diğeri bu yoldan geçirir ve doğrudan bir sonraki aşamaya bağlanır. 1 CSP-DenseNet, DenseNet'in özellik yeniden kullanım avantajlarını korur ve kısmi bir geçiş katmanında hierarşik bir özellik birleştirme stratejisi aracılığıyla elde edilen gradient akışını keserek çifte gradient bilgileri azaltır. Taraflarına göre Bu yaklaşım, hesaplamayı %20 oranında azaltır ve ImageNet veritabanında eşdeğer ya da daha üstün bir doğruluk elde eder. Yazarların Deneyleri C3 Hakkında YOLOv4 ve YOLOv5 şişede özellik çıkarımı geliştirmek için Cross Stage Parcial (CSP) modülünü kullanır. YOLO modelleri Ultrasonik C3 blokunda, giriş özellik haritaları iki parçaya bölünür. Bir kısmı 1×1 konvolisyonu ile işlenir ve ardından Paralel şişe blokları, diğer kısmı ayrı bir 1×1 konvolisyonu geçirir ve tamamen şişe bloklarını geçirir. Bu iki dal, daha sonra kanal boyutu boyunca birbirine bağlanır ve çıkış üretmek için başka bir 1×1 konvolisyonu tarafından birleştirilir. n Input (x) │ ┌────────┴─────────┐ │ │ [1x1 Conv] [1x1 Conv] (cv1) (cv2) │ │ [Bottlenecks] │ (m: n blocks) │ │ │ └────────┬─────────┘ │ [Concat along C] │ [1x1 Conv → cv3] │ Output Ultrasonik ( ) : GitHub bağlantısı class C3(nn.Module): """CSP Bottleneck with 3 convolutions.""" def __init__(self, c1: int, c2: int, n: int = 1, shortcut: bool = True, g: int = 1, e: float = 0.5): """ Initialize the CSP Bottleneck with 3 convolutions. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. """ super().__init__() c_ = int(c2 * e) # hidden channels self.cv1 = Conv(c1, c_, 1, 1) self.cv2 = Conv(c1, c_, 1, 1) self.cv3 = Conv(2 * c_, c2, 1) self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=((1, 1), (3, 3)), e=1.0) for _ in range(n))) def forward(self, x: torch.Tensor) -> torch.Tensor: """Forward pass through the CSP bottleneck with 3 convolutions.""" return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1)) 2F bağlantıları ile Cross-Stage Parcial (C2F) C2f bloku CSPNet üzerine kuruluyor, daha da genişletiyor: tek bir birleşme yolunun yerine, her biri çıkış kanallarının yarısı olan iki paralel özellik birleşme bağlantısı sunuyor. ve [ ] ], hesaplama redundansını azaltmak ve özellik yeniden kullanımını iyileştirmek için giriş özellik haritasını bölmek için CSP ile aynı ilkeleri takip eder. 2 3 Bir C2f blokta, giriş tensörü iki yöne ayrılır: biri Bottleneck katmanlarını bir kısayol olarak atar, diğeri ise birkaç Bottleneck katmanından geçirir. Sadece nihai Bottleneck çıkışını kullanan orijinal CSP'nin aksine, C2f tüm orta Bottleneck çıkışlarını toplayıp bunları birbirine bağlar - özellik çeşitliliğini ve temsilini arttırır. Bu çift özellik birleştirme (2F) stratejisi aynı zamanda ağın oklüzyonla daha iyi başa çıkmasına yardımcı olur ve zorlu sahnelerde algıları daha sağlam hale getirir. Çevresel İlişkiler ( ) : GitHub bağlantısı class C2f(nn.Module): """Faster Implementation of CSP Bottleneck with 2 convolutions.""" def __init__(self, c1: int, c2: int, n: int = 1, shortcut: bool = False, g: int = 1, e: float = 0.5): """ Initialize a CSP bottleneck with 2 convolutions. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. """ super().__init__() self.c = int(c2 * e) # hidden channels self.cv1 = Conv(c1, 2 * self.c, 1, 1) self.cv2 = Conv((2 + n) * self.c, c2, 1) # optional act=FReLU(c2) self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n)) def forward(self, x: torch.Tensor) -> torch.Tensor: """Forward pass through C2f layer.""" y = list(self.cv1(x).chunk(2, 1)) y.extend(m(y[-1]) for m in self.m) return self.cv2(torch.cat(y, 1)) def forward_split(self, x: torch.Tensor) -> torch.Tensor: """Forward pass using split() instead of chunk().""" y = self.cv1(x).split((self.c, self.c), 1) y = [y[0], y[1]] y.extend(m(y[-1]) for m in self.m) return self.cv2(torch.cat(y, 1)) Kernel Boyutu 2 (C3k2) Blok ile Çapraz Durum Parsiyel Yavuz11 [ ] başında aşağıdaki C3K2 bloklarını kullanarak omurganının çeşitli aşamalarında özelliği çıkarmak için çok ölçekli özellikleri işlemek için kullanır - klasik CSP şişelenmesinin bir başka evrimi. C3K2 bloku özellik haritasını bölür ve birkaç hafif 3×3 konvolüsiyonla işler, sonuçları daha sonra birleştirir. 4 C3K bloku, C2f ile aynı temel yapıyı korur, ancak başlangıç konvolisyonundan sonra çıkışı bölmez. Bottleneck katmanları, son 1×1 konvolisyonu ile sona eren aralıklarla. C2f'den farklı olarak, C3K, modelin farklı nesne ölçeklerinde ince ayrıntıları daha iyi yakalamasına yardımcı olan özelleştirilebilir çekirdek boyutları ile esnekliği ekler. n Bu fikre dayanarak, C3K2, basit Bottlenecks'i birden fazla C3K blokla değiştirir. bir Conv blokla başlar, birkaç C3K blokunu sırada birleştirir, çıkışlarını orijinal girişle birleştirir ve başka bir Conv katmanı ile sona erer - CSP'nin bölünmüş birleştirme konseptini hızı, parametre verimliliği ve daha zengin çok ölçekli özellik çıkarımı için esnek çekirdeklerle birleştirir. Input: [Batch, c1, H, W] │ [cv1] (1x1 Conv) → splits channels into 2c │ ┌─────────────┐ │ │ Branch 1 Branch 2 (Bypass) (Bottleneck chain) │ │ ├─> C3k Block #1 │ ├─> C3k Block #2 │ ... (n times) │ └─────────────┬─────────────┐ Concatenate [Bypass, Split, C3k outputs] │ [cv2] (1x1 Conv) │ Output: [Batch, c2, H, W] Her C3K blok paralel Bottlenecks ile özelleştirilmiş çekirdekler kullanır, özellik çıkarma için daha fazla esneklik sağlar ve modelin karmaşık desenlere daha iyi adapte olmasını sağlar. C3k Input: [Batch, c, H, W] │ [cv1] (1x1 Conv, expand/split) │ ┌───────────────┐ │ │ ByPass Bottleneck blocks │ ┌─────────────┐ │ B1, B2, ...Bn (parallel) └─────────────┘ └───────────────┬───────┘ Concatenate │ [cv2] (1x1 Conv) │ C3k Output: [Batch, c, H, W] Çevresel İlişkiler ( ) : GitHub bağlantısı class C3k(C3): """C3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks.""" def __init__(self, c1: int, c2: int, n: int = 1, shortcut: bool = True, g: int = 1, e: float = 0.5, k: int = 3): """ Initialize C3k module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. k (int): Kernel size. """ super().__init__(c1, c2, n, shortcut, g, e) c_ = int(c2 * e) # hidden channels # self.m = nn.Sequential(*(RepBottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n))) self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n))) class C3k2(C2f): """Faster Implementation of CSP Bottleneck with 2 convolutions.""" def __init__( self, c1: int, c2: int, n: int = 1, c3k: bool = False, e: float = 0.5, g: int = 1, shortcut: bool = True ): """ Initialize C3k2 module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of blocks. c3k (bool): Whether to use C3k blocks. e (float): Expansion ratio. g (int): Groups for convolutions. shortcut (bool): Whether to use shortcut connections. """ super().__init__(c1, c2, n, shortcut, g, e) self.m = nn.ModuleList( C3k(self.c, self.c, 2, shortcut, g) if c3k else Bottleneck(self.c, self.c, shortcut, g) for _ in range(n) ) Sonuç Kısacası, modern YOLO mimarlıkları, C3, C2f, C3k ve C3k2 gibi blokları ekleyerek gelişmeye devam ediyor - hepsi Cross-Stage Parcial (CSP) bağlantılarının temel fikri etrafında inşa edilmiştir. Block Outer Structure Inner Structure Kernel flexibility C3 Parallel Bottlenecks Bottlenecks Fixed kernels C2f Serial Bottlenecks Bottlenecks Fixed kernels C3k Parallel Bottlenecks Bottlenecks Custom kernels C3k2 Serial C3k blocks Each C3k has parallel Bottlenecks Custom kernels C3 Hakkında Paralel şişeler şişeler Düzenli Kernel c2f Seri şişeler şişeler Düzenli Kernel c3k Paralel şişeler şişeler Özelleştirilmiş Kernel C3K2 Hakkında C3K Blokları Her C3k'in paralel Bottlenecks vardır Özelleştirilmiş Kernel Bu mimari geliştirmeler, YOLO modellerinin yüksek tespit doğruluğunu korumasına yardımcı olurken, gerçek zamanlı dağıtım için yeterince hızlı ve hafif kalır - çeşitli uygulamalar için kritik bir avantaj. sol tarafı https://arxiv.org/pdf/1911.11929 https://arxiv.org/pdf/2207.02696 https://arxiv.org/pdf/2408.15857 https://arxiv.org/html/2410.17725v1#S3
