Ito ay isang artikulo tungkol sa disenyo ng feature extraction blocks na binuo upang mapabuti ang multi-scale object detection habang nagtatagumpay ang mabilis na inference sa real-world application. Ang mga bahagi ng cross-stage connection (CSP) Ang mga sumusunod na mga sumusunod na mga sumusunod ( Nag-introduce ang architectural innovation na ito at tinutukoy ang problema ng redundant gradient na impormasyon sa mas mataas na convolutional neural network backbones. Ang kanyang pangunahing layer ay upang matatagpuan ang gradient interactions habang masama ang computing gastos. Cross-stage partial connections (CSP) preserves gradient diversity sa pamamagitan ng paghahambing feature maps mula sa simula at katapusan ng bawat network stage: ang mga feature maps ng base layer ay binubuo sa dalawang bahagi: ang isa ay pumunta sa pamamagitan ng isang tiyak na block at transition layer, habang ang isa ay umuwi ang path na ito at nag-connect sa susunod na layer. Ang architecture na ito ay dinisenyo upang tumutulong sa maraming mga problema, kabilang pagbutihin 1 Ang CSP-DenseNet ay nagbibigay ng mga benepisyo ng reuse ng DenseNet sa pamamagitan ng pag-aalis ng duplicate gradient na impormasyon sa pamamagitan ng pag-aalis ng gradient flow, na nakuha sa pamamagitan ng isang hierarchical feature fusion strategy sa isang partikular na layer ng transition. Ayon sa The , ang paraan na ito ay humihinto ng pag-calculation ng 20% habang makakuha ng katumbas na o kahit na mas mataas na katumbas sa ImageNet dataset. Mga eksperimento ng mga awtor C3 ang YOLOv4 at YOLOv5 gumagamit ang Cross Stage Partial (CSP) module upang mapabuti ang feature extraction sa bottleneck. ang mga modelo. ang ultrasound Sa C3 block, ang mga input feature maps ay ibahagi sa dalawang bahagi. Ang isang bahagi ay proseso sa pamamagitan ng isang 1×1 convolution na tinatawag na Parallel bottleneck blocks, habang ang iba pang bahagi ay pumapasok sa pamamagitan ng isang separatong 1×1 convolution at umpisa ang bottlenecks na ganap. Ang dalawa na mga kabuuan na ito ay pagkatapos ay naka-concatenated along the channel dimension at pinagsama sa pamamagitan ng isang iba pang 1×1 convolution upang lumikha ng output. n Input (x) │ ┌────────┴─────────┐ │ │ [1x1 Conv] [1x1 Conv] (cv1) (cv2) │ │ [Bottlenecks] │ (m: n blocks) │ │ │ └────────┬─────────┘ │ [Concat along C] │ [1x1 Conv → cv3] │ Output Mga pahinang tumuturo sa pamamagitan ng ultrasound ( ) ang : GitHub ang link 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 Partial na may 2F mga koneksyon (C2F) Ang C2f block ay binubuo sa CSPNet, nagtatapos ito sa itaas: sa halip ng isang single fusion path, itinuturing ito ng dalawang parallel feature fusion connections, ang bawat isa ay may halos ang bilang ng mga output channels. Ang [ ] ], sumusunod ang parehong mga prinsipyo na CSP sa pamamagitan ng pag-split ang input feature map upang mabawasan ang computational redundancy at mapabuti ang reuse ng feature. 2 3 Sa isang block ng C2f, ang input tensor ay binubuo sa dalawang path: ang isa ay umalis ang mga layer ng Bottleneck bilang isang shortcut, habang ang isa ay pumapasok sa pamamagitan ng maraming mga layer ng Bottleneck. Iba't ibang ang orihinal na CSP, na gumagamit lamang ang katapusan Bottleneck output, ang C2f ay kumonekta ang lahat ng intermediate Bottleneck outputs at i-concatenate ang mga ito - pagbutihin ang function diversity at representation. Mga pahinang tumuturo sa ( ) ang : GitHub ang link 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 na may kernel size 2 (C3k2) block ang napili ng mga taga-hanga: Ang C3K2 block ay gumagamit ng mga sumusunod na C3K2 blocks sa pangulo para sa feature extraction sa iba't ibang bahagi ng kanyang backbone upang proseso multi-scale features — isang iba't ibang evolution ng classic CSP bottleneck. Ang C3K2 blocks split ang feature map at processes ito na may ilang lightweight 3×3 convolutions, sumali ang mga resulta pagkatapos. 4 Ang C3K block ay humahantong sa parehong pangunahing strukturong tulad ng C2f ngunit hindi ibahagi ang output pagkatapos ng unang convolution. Bottleneck layers na may intermediate concatenations, na nagsisimula sa isang final 1×1 convolution. Hindi tulad ng C2f, ang C3K ay nagbibigay ng flexibility na may customizable size ng kernel, na tumutulong sa modelo na mas mabuti ang mga detalye sa iba't ibang mga skala ng object. n Upang bumuo sa ideya na ito, ang C3K2 ay bumubuo ng simpleng Bottlenecks na may higit sa isang C3K blocks. Ito ay nagsisimula sa isang Conv block, mag-stack ng ilang C3K blocks sa sekuensiya, i-concatenate ang kanilang outputs sa orihinal na input, at nagsisimula sa isang iba pang Conv layer - lumikha ng CSP's split-fusion concept sa mga flexible kernels upang i-balance ang speed, parameter efficiency, at mas mataas na multi-scale feature extraction. 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] Ang bawat C3K block ay gumagamit ng parallel Bottlenecks na may custom kernels, na nagbibigay ng higit pa ng flexibility para sa feature extraction at nagbibigay-daan ang modelo upang ma-adapt ang mas mabuti sa mga kompleksong pattern. 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] Mga pahinang tumuturo sa ( ) ang : GitHub ang link 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) ) Konklusyon Sa katunayan, ang mga modernong YOLO architectures ay patuloy sa pag-unlad sa pamamagitan ng pagdaragdag ng mga block tulad ng C3, C2f, C3k, at C3k2 - ang lahat ay binuo sa paligid ng pangunahing ideya ng Cross-Stage Partial (CSP) koneksyon. 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 ang Mga Bottlenecks Mga bottlenecks Mga Kernel ang2f Mga Bottlenecks Mga bottlenecks Mga Kernel ang 3k Mga Bottlenecks Mga bottlenecks Paglalarawan ng Kernel C3K2 ang Mga block ng C3K Lahat ng C3k ay may parallel Bottlenecks Paglalarawan ng Kernel Ang mga architectural refinements ay kumplikado sa mga modelo ng YOLO upang matatagpuan ang mataas na accuracy ng pag-detection habang magkakaroon ng mabilis at madaling sapat na para sa real-time deployment - isang kritikal na halaga para sa iba't ibang mga application ang links 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
