Ky është një artikull për dizajnin e blloqeve të nxjerrjes së karakteristikave të zhvilluara për të përmirësuar zbulimin e objekteve në shkallë të shumëfishtë duke ruajtur inferencën e shpejtë në aplikacionet e botës reale. Lidhjet e ndërfaqeve të pjesshme (CSP) Në radhë të parë, Xhensila et al. [ ] prezantoi këtë risi arkitektonike dhe trajtoi problemin e informacionit të gradientit të tepërt në backbones më të mëdhenj të rrjetit nervor konvolucional. Qëllimi i tij kryesor është pasurimi i ndërveprimeve të gradientit ndërsa zvogëlon koston e llogaritjes. Lidhjet e pjesshme të ndërmjetme (CSP) ruajnë diversitetin e gradientit duke kombinuar hartat e karakteristikave nga fillimi dhe fundi i çdo faze të rrjetit: hartat e karakteristikave të shtresës bazë ndahen në dy pjesë: njëra kalon nëpër një bllok të dendur dhe shtresë tranzicioni, ndërsa tjetra e kalon këtë rrugë dhe lidhet drejtpërdrejt me fazën e ardhshme. Kjo arkitekturë është projektuar për të adresuar 1 CSP-DenseNet ruan përfitimet e ri-përdorimit të karakteristikave të DenseNet ndërsa redukton informacionin e gradientit të dyfishtë duke prerë rrjedhën e gradientit, e arritur përmes një strategjie hierarkike të bashkimit të karakteristikave në një shtresë të pjesshme të tranzicionit. Sipas të , kjo qasje zvogëlon llogaritjen me 20% duke arritur saktësi të barabartë ose edhe superior në dataset ImageNet. Eksperimentet e autorëve C3 të YOLOv4 dhe YOLOv5 përdorin modulin Cross Stage Partial (CSP) për të përmirësuar nxjerrjen e karakteristikave në shishe. Modelet e YOLO Ultratinguj Në bllokun C3, hartat e karakteristikave të hyrjes ndahen në dy pjesë. Një pjesë përpunohet nga një konvolucion 1×1 i ndjekur nga blloqe paralele shishe, ndërsa pjesa tjetër kalon nëpër një konvulsion të veçantë 1×1 dhe kalon shishe tërësisht. Këto dy degë janë pastaj të lidhura përgjatë dimensionit të kanalit dhe të bashkuar nga një tjetër konvulsion 1×1 për të prodhuar prodhimin. n Input (x) │ ┌────────┴─────────┐ │ │ [1x1 Conv] [1x1 Conv] (cv1) (cv2) │ │ [Bottlenecks] │ (m: n blocks) │ │ │ └────────┬─────────┘ │ [Concat along C] │ [1x1 Conv → cv3] │ Output Përdorimi i ultratingujve ( ) në : Lidhje 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)) Cross-Stage Pjesë me lidhjet 2F (C2F) Blloku C2f ndërton në CSPNet, duke e zgjeruar atë më tej: në vend të një rruge të vetme të shkrirjes, ai paraqet dy lidhje paralele të shkrirjes së karakteristikave, secila me gjysmën e numrit të kanaleve të prodhimit. të [ ], ndjek të njëjtat parime si CSP duke ndarë hartën e karakteristikave të hyrjes për të zvogëluar redundancën kompjuterike dhe për të përmirësuar ripërdorimin e karakteristikave. 2 3 Në një bllok C2f, tensori i hyrjes ndahet në dy rrugë: njëri kalon shtresat Bottleneck si një shkurtesë, ndërsa tjetri kalon nëpër shtresat e shumëfishta Bottleneck. Ndryshe nga CSP origjinal, i cili përdor vetëm daljen përfundimtare Bottleneck, C2f mbledh të gjitha daljet e ndërmjetme Bottleneck dhe i bashkon ato – duke rritur diversitetin e karakteristikave dhe përfaqësimin. Kjo strategji e dyfishtë e bashkimit të karakteristikave (2F) gjithashtu ndihmon rrjetin të trajtojë më mirë oklusion, duke bërë zbulimet më të fuqishme në skenat sfiduese. Shërbimi i Përgjithshëm i Përgjithshëm ( ) në : Lidhje 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)) Cross Stage Parcial me madhësinë e bërthamës 2 (C3k2) Shkëndija 11 [ ] përdor blloqet e mëposhtme C3K2 në kokë për nxjerrjen e karakteristikave në faza të ndryshme të shtyllës kurrizore për të përpunuar karakteristika në shkallë të shumëfishtë - një tjetër evolucion i shisheve klasike CSP. Blloku C3K2 ndan hartën e karakteristikave dhe e përpunon atë me konvoluta të shumëfishta të lehta 3×3, duke bashkuar rezultatet më pas. 4 Blloku C3K mban të njëjtën strukturë bazë si C2f, por nuk e ndan prodhimin pas konvolucionit fillestar. Shtresat Bottleneck me ndërthurje të ndërmjetme, duke përfunduar me një konvolucion përfundimtar 1×1. Ndryshe nga C2f, C3K shton fleksibilitet me madhësi të personalizueshme të bërthamës, duke ndihmuar modelin të kapë më mirë detajet e hollësishme në shkallë të ndryshme të objektit. n Duke u bazuar në këtë ide, C3K2 zëvendëson Bottlenecks të thjeshtë me disa blloqe C3K. Ajo fillon me një bllok Conv, grumbullon disa blloqe C3K në një sekuencë, bashkon prodhimin e tyre me hyrjen origjinale dhe përfundon me një shtresë tjetër Conv - duke përzier konceptin e ndarjes së bashkimit të CSP me bërthama fleksibël për të balancuar shpejtësinë, efikasitetin e parametrave dhe nxjerrjen më të pasur të karakteristikave në shumë shkallë. 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] Çdo bllok C3K përdor Bottlenecks paralele me bërthama të personalizuara, duke siguruar më shumë fleksibilitet për nxjerrjen e karakteristikave dhe duke lejuar modelin për t'u përshtatur më mirë në modelet komplekse. 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] Shërbimi i Përgjithshëm i Përgjithshëm ( ) në : Lidhje 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) ) Konkludimi Me pak fjalë, arkitekturat moderne YOLO vazhdojnë të evoluojnë duke shtuar blloqe si C3, C2f, C3k dhe C3k2 - të gjitha të ndërtuara rreth idesë thelbësore të lidhjeve të ndërfaqeve të pjesshme (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 të Shishe paralele shishe Kernele të fiksuara C2F Seria e shisheve shishe Kernele të fiksuara Q3K Shishe paralele shishe Kernelët Custom Q3K2 Seria e blloqeve C3K Çdo C3k ka Bottlenecks paralele Kernelët Custom Këto përmirësime arkitektonike së bashku ndihmojnë modelet YOLO të ruajnë saktësi të lartë të zbulimit ndërsa mbeten të shpejta dhe të lehta të mjaftueshme për vendosjen në kohë reale - një avantazh kritik për aplikime të ndryshme. E majta 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
