Đây là một bài viết về thiết kế các khối khai thác tính năng được phát triển để cải thiện phát hiện đối tượng đa quy mô trong khi duy trì kết luận nhanh trong các ứng dụng thực tế. Cross-stage partial connections (CSP) kết nối Đầu tiên, Nguyễn Thị Hùng et al. [ ] giới thiệu sự đổi mới kiến trúc này và giải quyết vấn đề thông tin gradient dư thừa trong các xương sống mạng thần kinh xoắn ốc lớn hơn. Mục tiêu chính của nó là làm phong phú thêm các tương tác gradient trong khi giảm chi phí tính toán. Kết nối một phần chéo (CSP) bảo tồn sự đa dạng gradient bằng cách kết hợp các bản đồ tính năng từ cả đầu và cuối mỗi giai đoạn mạng: các bản đồ tính năng của lớp cơ bản được chia thành hai phần: một đi qua một khối dày đặc và lớp chuyển tiếp, trong khi thứ hai bỏ qua con đường này và kết nối trực tiếp đến giai đoạn tiếp theo. Kiến trúc này được thiết kế để giải quyết nhiều vấn đề, bao gồm nâng cao khả năng học tập của CNN, loại bỏ các chướng ngại vật tính toán và giảm chi phí bộ nhớ. 1 CSP-DenseNet giữ lại lợi ích tái sử dụng tính năng của DenseNet trong khi giảm thông tin độ dốc trùng lặp bằng cách cắt dòng độ dốc, đạt được thông qua một chiến lược sáp nhập tính năng phân cấp trong một lớp chuyển tiếp một phần. Theo các , phương pháp này làm giảm tính toán 20% trong khi đạt được độ chính xác tương đương hoặc thậm chí cao hơn trên tập dữ liệu ImageNet. Thí nghiệm của tác giả C3 YOLOv4 và YOLOv5 sử dụng mô-đun Cross Stage Partial (CSP) để cải thiện việc khai thác tính năng trong chai chai. Mô hình YOLO Ultrasonics Trong khối C3, các bản đồ tính năng đầu vào được chia thành hai phần. Một phần được xử lý bởi một convolution 1×1 tiếp theo là: các khối chai chai song song, trong khi phần còn lại đi qua một convolution 1×1 riêng biệt và bỏ qua các chai chai hoàn toàn. Hai chi nhánh này sau đó được kết hợp dọc theo kích thước kênh và được hợp nhất bởi một convolution 1×1 khác để tạo ra đầu ra. n Input (x) │ ┌────────┴─────────┐ │ │ [1x1 Conv] [1x1 Conv] (cv1) (cv2) │ │ [Bottlenecks] │ (m: n blocks) │ │ │ └────────┬─────────┘ │ [Concat along C] │ [1x1 Conv → cv3] │ Output Tác dụng của siêu âm ( ) : GitHub liên kết 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 với kết nối 2F (C2F) Block C2f xây dựng trên CSPNet, mở rộng nó thêm: thay vì một con đường sáp nhập duy nhất, nó giới thiệu hai kết nối sáp nhập tính năng song song, mỗi với một nửa số lượng kênh đầu ra. [ ] [ ] ], tuân theo các nguyên tắc tương tự như CSP bằng cách chia bản đồ tính năng đầu vào để giảm sự dư thừa tính toán và cải thiện việc tái sử dụng tính năng. 2 3 Trong một khối C2f, tensor đầu vào được chia thành hai con đường: một vượt qua các lớp Bottleneck như là một phím tắt, trong khi các lớp khác đi qua nhiều lớp Bottleneck. Không giống như CSP ban đầu, mà chỉ sử dụng đầu ra Bottleneck cuối cùng, C2f thu thập tất cả các đầu ra Bottleneck trung gian và kết hợp chúng - tăng sự đa dạng tính năng và đại diện. Chiến lược sáp nhập tính năng kép (2F) này cũng giúp mạng xử lý sự tắc nghẽn tốt hơn, làm cho các phát hiện mạnh mẽ hơn trong các cảnh khó khăn. Phân tích chất lượng ( ) : GitHub liên kết 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 với Block Kernel Size 2 (C3k2) Lời bài hát: Yolo11 [ ] sử dụng các khối C3K2 sau đây trong đầu để khai thác tính năng ở các giai đoạn khác nhau của xương sống của nó để xử lý các tính năng đa quy mô - một sự tiến hóa khác của chai chai CSP cổ điển. khối C3K2 chia bản đồ tính năng và xử lý nó với nhiều convolutions nhẹ 3×3, sau đó hợp nhất kết quả. điều này cải thiện lưu lượng thông tin trong khi vẫn nhỏ gọn hơn chai chai CSP hoàn chỉnh, giảm số lượng các thông số có thể được đào tạo. 4 Các khối C3K giữ lại cấu trúc cơ bản giống như C2f nhưng không chia đầu ra sau khi convolution ban đầu. Các lớp Bottleneck với các kết nối trung gian, kết thúc với một kết nối cuối cùng 1×1. Không giống như C2f, C3K thêm tính linh hoạt với kích thước lõi tùy chỉnh, giúp mô hình nắm bắt chi tiết tốt hơn ở các quy mô đối tượng khác nhau. n Dựa trên ý tưởng này, C3K2 thay thế Bottlenecks đơn giản bằng nhiều khối C3K. Nó bắt đầu với một khối Conv, xếp chồng nhiều khối C3K theo thứ tự, kết hợp các đầu ra của chúng với đầu vào ban đầu và kết thúc với một lớp Conv khác - pha trộn khái niệm phân chia hợp nhất của CSP với các lõi linh hoạt để cân bằng tốc độ, hiệu quả tham số và khai thác tính năng đa quy mô phong phú hơn. 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] Mỗi khối C3K sử dụng các Bottlenecks song song với các lõi tùy chỉnh, cung cấp sự linh hoạt hơn cho việc khai thác tính năng và cho phép mô hình thích ứng tốt hơn với các mô hình phức tạp. 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] Phân tích chất lượng ( ) : GitHub liên kết 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) ) Kết luận Tóm lại, các kiến trúc YOLO hiện đại tiếp tục phát triển bằng cách thêm các khối như C3, C2f, C3k và C3k2 – tất cả đều được xây dựng xung quanh ý tưởng cốt lõi của kết nối 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 Bottlenecks song song chai chai Kernel cố định C2F Bottlenecks loạt chai chai Kernel cố định C3k Bottlenecks song song chai chai Custom Kernel C3K2 Serial C3K Blocks Mỗi C3k có Bottlenecks song song Custom Kernel Những cải tiến kiến trúc này giúp các mô hình YOLO duy trì độ chính xác phát hiện cao trong khi vẫn đủ nhanh và nhẹ để triển khai theo thời gian thực - một lợi thế quan trọng cho các ứng dụng khác nhau. trái 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
