මෙම ලිපිය බොහෝ ප්රමාණයේ ඔත්තු හඳුනාගැනීම වැඩි දියුණු කිරීම සඳහා නිර්මාණය කරන ලදී.This is an article about the design of feature extraction blocks developed to improve multi-scale object detection whileining fast inference in real-world applications. CSP (Cross-stage partial connections) යනු පළමුව, වොන්ජින් සහ එල්. [ මෙම ව්යාපාරික නවකතාවය හඳුන්වා දී ඇති අතර, විශාල පරිවර්තනයක neuronal network backbones වල redundant gradient information ප්රශ්නය විසඳා ඇත. Its main objective is to enrich gradient interactions while reducing computational cost. Cross-stage partial connections (CSP) preserves gradient diversity by combining feature maps from both the beginning and the end of each network stage: the base layer's feature maps are split into two parts: one passes through a dense block and transition layer, while the other bypasses this path and connects directly to the next stage.This architecture is designed to address multiple issues, including enhancing the learning capability of the CNN, removing computational bottlenecks, and lowering memory costs. 1 CSP-DenseNet DenseNet ප්රතිලාභ ප්රතිලාභ සකස් කර ඇත, පර්යේෂණ ප්රතිලාභ ප්රතිලාභ ක්රියාත්මක කිරීම සඳහා ප්රතිලාභ ක්රියාත්මක කිරීම සඳහා ප්රතිලාභ ප්රතිලාභ ක්රියාත්මක කිරීම සඳහා ප්රතිලාභ ප්රතිලාභ ක්රියාත්මක කිරීම සඳහා ප්රතිලාභ ප්රතිලාභ ක්රියාත්මක කිරීමෙන් ප්රතිලාභ ප්රතිලාභ තොරතුරු අඩු කිරීම. අනුව The , මෙම ප්රවේශය පරිගණක 20% කින් අඩු කරයි, ImageNet දත්ත සමුදාය මත සමාන හෝ වඩාත් උසස් නිවැරදිතාවයක් සාර්ථක කිරීම. ලේඛකයාගේ අත්හදා බැලීම් C3 YOLOv4 සහ YOLOv5 බෝතලයේ ප්රතිලාභය වැඩි දියුණු කිරීම සඳහා Cross Stage Partial (CSP) මොඩියුලය භාවිතා කරයි.The C3 block is a practical implementation of this CSP architecture in YOLO ආකෘති ultrasound C3 බ්ලැක් එකේදී, input feature maps දෙකකට බෙදෙනවා.One part is processed by a 1×1 convolution followed by බෝතල් බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති බිත්ති n Input (x) │ ┌────────┴─────────┐ │ │ [1x1 Conv] [1x1 Conv] (cv1) (cv2) │ │ [Bottlenecks] │ (m: n blocks) │ │ │ └────────┬─────────┘ │ [Concat along C] │ [1x1 Conv → cv3] │ Output ස්වයංක් රීය භාවිතය ( ) : GitHub සබැඳි 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 සම්බන්ධතාවයන් සහිත cross-stage partial (C2F) C2f බ්ලැක් එක CSPNet මත ගොඩනැගීම, එය තවදුරටත් පුළුල් කිරීම: එක් එක් සංයෝග මාර්ගය වෙනුවට, එය ප්රතිඵල චැනල් සංඛ්යාව භාගයක් සමග සෑම සංකේත සංයෝග සම්බන්ධතා දෙකක් ඇතුළත් කරයි. [ ] [ [ ] CSP වැනි මූලධර්මය අනුගමනය කරන අතර, පරිගණක ප්රමාණය අඩු කිරීම සහ feature reuse වැඩි දියුණු කිරීම සඳහා input feature map බෙදා හැරීම මගින් CSP අනුගමනය කරන ලදී. 2 3 C2f බ්ලැක් එකකදී, ඇතුලත් ටෙන්සර් දෙකකට බෙදාහැරෙනවා: එකක් Bottleneck පරාක්තයක් ලෙස Bottleneck පරාක්තය හරහා ගමන් කරයි, අනෙකුත් Bottleneck පරාක්තයක් හරහා ගමන් කරයි. අවසාන Bottleneck පරාක්තය පමණක් භාවිතා කරන මුල් CSP වෙනුවට, C2f සියලුම මධ් යම Bottleneck පරාක්තය එකතු කරයි සහ ඒවා සංකීර්ණ කරයි - විශේෂාංග සංසන්දනය සහ ප්රදර්ශනය වැඩි කරයි. ශ් රීලනිප ප් රතිපත්ති ( ) : GitHub සබැඳි 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)) කේන්ලල් ප්රමාණය 2 (C3k2) බ්ලැක් සමග Cross Stage Partial ජුනි 11 [ C3K2 බ්ලැක්ස් හි පහත දැක්වෙන C3K2 බ්ලැක්ස් භාවිතා කරන්නේ එහි පිටුපස විවිධ පියවරවල ප්රභෝගිකත්වය සඳහා multi-scale ප්රභෝගිකයන් ක්රියාත්මක කිරීම සඳහා - කාර්යක්ෂම CSP බෝතලයේ තවත් සංවර්ධනය.The C3K2 බ්ලැක්ස් ප්රභෝගිකතාව ප්රභෝගිකතාව ප්රභෝගිකතාවය බෙදයි සහ එය කිහිපයක් පහසු 3x3 convolutions සමඟ ක්රියාත්මක කරයි, පසුව ප්රතිඵල එකතු කිරීම.This වැඩි දියුණු වන අතර සම්පූර්ණ CSP බෝතලයේ බෝතලයට වඩා සංකීර්ණ වන අතර, පුහුණු කළ හැකි ප්රමාණයන් සංඛ්යාව අඩු කරයි. 4 C3K බ්ලැක් එක C2f සමාන මූලික ව්යුහය තබා ඇත, නමුත් ආරම්භක සංශෝධනයෙන් පසු ප්රතිදානය බෙදා හැරන්නේ නැත. Bottleneck මට්ටම් මධ්යම සබඳතා සමග, අවසාන 1×1 සබඳතා සමග අවසන්. C2f වෙනුවට, C3K පරිශීලනය කළ හැකි කේන්ලල් ප්රමාණයන් සමඟ මෘදුකාංග ප්රමාණයන් එකතු කරයි, ආකෘතිය වඩාත් හොඳින් විවිධ ඔත්තු මට්ටම් මත දෘශ්ය විස්තර ගබඩා කිරීමට උපකාර කරයි. n මෙම අදහස මත පදනම්ව, C3K2 සරල Bottlenecks කිහිපයක් C3K බ්ලැක්ස් සමඟ මාරු කරයි.එය Conv බ්ලැක්ස් සමඟ ආරම්භ වන අතර, කිහිපයක් C3K බ්ලැක්ස් සංරචකයක්, මුල් ආදායම සමඟ ඔවුන්ගේ ප්රතිඵල සංකේත කරයි, සහ තවත් Conv පරාසයක් සමඟ අවසන් කරයි - වේගය, ප්රමාණශීලීත්වය සහ වඩාත් පොහොසත් බහු-විශාල විශේෂාංග අමුද්රව්ය සංසන්දනය කිරීම සඳහා මෘදුකාංගයන් සමඟ CSP හි බෙදාහැරෙන සංසන්දනය සංකේත කිරීම. 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] සෑම C3K බ්ලැක් එකකටම පෞද්ගලික කොන්ලර් සහිත සෘජු බෝට්ලන්ක් භාවිතා කරයි, විශේෂාංග ආකෘතිය සඳහා වඩාත් මෘදුකාංගයක් ලබා දෙන අතර, ආකෘතිය සංකීර්ණ ආකෘති වලට වඩා හොඳින් අනුකූල වීමට ඉඩ සලසයි. 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] ශ් රීලනිප ප් රතිපත්ති ( ) : GitHub සබැඳි 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) ) ප් රතිඵල කෙටියෙන් කිවහොත්, නවීන YOLO ආකෘති C3, C2f, C3k, සහ C3k2 වැනි බ්ලැක්ස් එකතු කිරීමෙන් වර්ධනය වෙමින් පවතී - සියලුම ප්රධාන අදහසක් වටා ගොඩනැගිල්ලේ Cross-Stage Partial (CSP) සම්බන්ධතා. 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 Parallel බෝතල් බෝතල් නිශ්චිත kernels C2F බෝතල් බෝතල් බෝතල් නිශ්චිත kernels C3K Parallel බෝතල් බෝතල් Custom කොන්ලර් C3K2 Serial C3K බ්ලැක්ස් සෑම C3k එකකටම සංකීර්ණ Bottlenecks ඇත. Custom කොන්ලර් මෙම ආකෘති මෘදුකාංග සාර්ථකත්වය YOLO ආකෘති උසස් නිරීක්ෂණය නිවැරදිතාවය තබා ගැනීමට උපකාරී වන අතර, සැබෑ කාලීන ස්ථාපනය කිරීම සඳහා වේගවත් හා පහසු ප්රමාණයක් - විවිධ යෙදුම් සඳහා ප්රධාන වාසි වම් 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
