Ovo je članak o dizajnu blokova ekstrakcije značajki koji su razvijeni kako bi poboljšali detekciju objekata u višestrukim razmjerima uz održavanje brzog zaključivanja u stvarnim aplikacijama. Preko faze parcijalne veze (CSP) Prvo, Vučić et al. ] uveo je ovu arhitektonsku inovaciju i rešio problem redundantnih gradientnih informacija u većim konvolucionim neuronskim mrežnim kralježnicama. Njegov glavni cilj je obogaćivanje gradientnih interakcija dok se smanjuju računarski troškovi. Cross-stage partial connections (CSP) čuva gradientnu raznolikost kombiniranjem kartica značajki od početka i kraja svake mrežne faze: kartice značajki osnovnog sloja su podijeljene na dva dijela: jedan prolazi kroz gusti blok i tranzicijski sloj, dok drugi zaobilazi ovaj put i povezuje se direktno na sledeću fazu. Ova arhitektura je dizajnirana za rješavanje višestrukih pitanja, uključujući poboljšanje sposobnosti učenja CNN-a, uklanjanje računalnih 1 CSP-DenseNet zadržava prednosti ponovne upotrebe funkcija DenseNet-a, dok smanjuje duplicirane informacije o gradientu rezanjem toka gradijenata, što se postiže kroz hijerarhijsku strategiju spajanja funkcija u parcijalnom sloju tranzicije. Prema tome, prema , ovaj pristup smanjuje izračun za 20% dok postiže ekvivalentnu ili čak superiornu točnost na ImageNet skupu podataka. Eksperimenti autora Uslovi c3 YOLOv4 i YOLOv5 koriste modul Cross Stage Partial (CSP) za poboljšanje ekstrakcije funkcija u bočnici. YOLO modeli Ultrasonografija U C3 bloku, karte ulaznih funkcija su podeljene na dva dela. Jedan deo se obrađuje 1×1 konvulacijom nakon čega slijedi: paralelne blokove bočice, dok drugi deo prolazi kroz zasebnu 1×1 konvulaciju i preskoči bočice u potpunosti. Te dvije grane su zatim spojene duž dimenzije kanala i spajane od strane druge 1×1 konvulacije da proizvede izlaz. n Input (x) │ ┌────────┴─────────┐ │ │ [1x1 Conv] [1x1 Conv] (cv1) (cv2) │ │ [Bottlenecks] │ (m: n blocks) │ │ │ └────────┬─────────┘ │ [Concat along C] │ [1x1 Conv → cv3] │ Output uvođenje ultrazvuka ( Posebno : GitHub poveznica 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)) Cross-stage parcijalni sa 2F veze (C2F) Blok C2f se gradi na CSPNet-u, šireći ga dalje: umesto jednog putovanja za spajanje, uvodi dvije paralelne funkcije za spajanje, od kojih svaka ima polovicu broja izlaznih kanala. Naši [...] ], slijedi iste principe kao i CSP razdvajanjem karte ulaznih značajki kako bi se smanjila izračunska redundancija i poboljšala ponovna upotreba značajki. 2 3 U bloku C2f, ulazni tenzor je podijeljen na dva puta: jedan zaobiđe slojeve Bottleneck kao prekratku, dok drugi prolazi kroz više slojeva Bottleneck. Za razliku od originalnog CSP-a, koji koristi samo konačni Bottleneck izlaz, C2f sakuplja sve Bottleneck izlaze u sredini i zbližava ih – povećavajući raznolikost funkcija i reprezentaciju. Ova strategija dvostrukog spajanja funkcija (2F) takođe pomaže mreži da bolje rukuje okluzijom, čineći detekcije robusnijim u izazovnim scenama. Uslovi korišćenja ( Posebno : GitHub poveznica 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)) Cross Stage Partial sa blokom veličine jezgre 2 (C3k2) Uslovi korišćenja 11 [ ] koristi sledeće C3K2 bloke u glavi za ekstrakciju značajki u različitim fazama svoje kralježnice za obradu multi-skale značajke – još jedna evolucija klasičnog CSP bottleneck. C3K2 blok razdvaja značajku mapu i obrađuje ga sa više lagane 3×3 konvoluzije, spajanje rezultata nakon toga. 4 Blok C3K zadržava istu osnovnu strukturu kao i C2f, ali ne dijeli izlaz nakon početne konvulacije. Bottleneck slojevi sa intermedijarnim konkaviranjima, završavajući s konačnom 1×1 konvulacijom. Za razliku od C2f, C3K dodaje fleksibilnost sa prilagodljivim veličinama jezgre, pomažući modelu da bolje uhvati fine detalje na različitim oblicima objekata. n Na osnovu ove ideje, C3K2 zamjenjuje obične Bottlenecks sa više C3K blokova. Počinje s Conv blokom, skuplja nekoliko C3K blokova u redoslijedu, konkatinira njihove izlaze s izvornim ulazom i završava s drugim Conv slojem - miješanjem CSP-ovog koncepta podijeljenog spajanja s fleksibilnim jezgrama kako bi se uravnotežila brzina, efikasnost parametara i bogatija multi-skala ekstrakcija funkcija. 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] Svaki C3K blok koristi paralelne Bottlenecke sa prilagođenim jezgrovima, pružajući veću fleksibilnost za ekstrakciju značajki i omogućavajući modelu da se bolje prilagodi složenim obrascima. 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] Uslovi korišćenja ( Posebno : GitHub poveznica 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) ) Zaključak Ukratko, moderne YOLO arhitekture nastavljaju da se razvijaju dodavanjem blokova kao što su C3, C2f, C3k i C3k2 – sve je izgrađeno oko osnovne ideje o prekograničnim parcijalnim (CSP) vezama. 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 Uslovi c3 Paralelne boce Bočice Fiksni kerneli Uslovi 2f Serija boce Bočice Fiksni kerneli Uslovi 3K Paralelne boce Bočice Korišćenje kernela Uslovi korišćenje Serijski C3k blokovi Svaki C3k ima paralelne Bottlenecks Korišćenje kernela Ovi arhitektonski prefinjenosti zajednički pomažu YOLO modelima da održavaju visoku preciznost detekcije, dok ostaju dovoljno brzi i lagani za uvođenje u realnom vremenu – ključna prednost za različite aplikacije. levo 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
