Chuyển đến nội dung

Cấu hình YAML của mô hình

Tệp cấu hình YAML của mô hình đóng vai trò là bản thiết kế kiến trúc cho Ultralytics Mạng nơ-ron nhân tạo. Nó xác định cách các lớp kết nối, các tham số mà mỗi mô-đun sử dụng và cách toàn bộ mạng mở rộng trên các kích thước mô hình khác nhau.

Cấu trúc cấu hình

Các tệp YAML của mô hình được tổ chức thành ba phần chính hoạt động cùng nhau để xác định kiến trúc.

Phần tham số

Phần tham số chỉ rõ các đặc điểm toàn cục và hành vi mở rộng của mô hình:

# Parameters
nc: 80 # number of classes
scales: # compound scaling constants [depth, width, max_channels]
    n: [0.50, 0.25, 1024] # nano: shallow layers, narrow channels
    s: [0.50, 0.50, 1024] # small: shallow depth, standard width
    m: [0.50, 1.00, 512] # medium: moderate depth, full width
    l: [1.00, 1.00, 512] # large: full depth and width
    x: [1.00, 1.50, 512] # extra-large: maximum performance
kpt_shape: [17, 3] # pose models only
  • nc thiết lập số lượng lớp mà mô hình dự đoán.
  • scales xác định các hệ số tỷ lệ hợp chất điều chỉnh độ sâu, chiều rộng và kênh tối đa của mô hình để tạo ra các biến thể kích thước khác nhau (từ nano đến cực lớn).
  • kpt_shape áp dụng cho các mô hình tư thế. Nó có thể là [N, 2] cho (x, y) các điểm chính hoặc [N, 3] cho (x, y, visibility).

Giảm sự dư thừa với scales

Hàm scales Tham số cho phép bạn tạo nhiều kích thước mô hình từ một tệp YAML cơ sở duy nhất. Ví dụ, khi bạn tải yolo11n.yaml, Ultralytics đọc cơ sở yolo11.yaml và áp dụng n các yếu tố tỷ lệ (depth=0.50, width=0.25) để xây dựng biến thể nano.

nc và kpt_shape phụ thuộc vào tập dữ liệu

Nếu tập dữ liệu của bạn chỉ định một nc hoặc kpt_shape, Ultralytics sẽ tự động ghi đè cấu hình mô hình khi chạy để phù hợp với tập dữ liệu YAML.

Kiến trúc xương sống và đầu

Kiến trúc mô hình bao gồm các phần xương sống (trích xuất tính năng) và phần đầu (nhiệm vụ cụ thể):

backbone:
    # [from, repeats, module, args]
    - [-1, 1, Conv, [64, 3, 2]] # 0: Initial convolution
    - [-1, 1, Conv, [128, 3, 2]] # 1: Downsample
    - [-1, 3, C2f, [128, True]] # 2: Feature processing

head:
    - [-1, 1, nn.Upsample, [None, 2, nearest]] # 6: Upsample
    - [[-1, 2], 1, Concat, [1]] # 7: Skip connection
    - [-1, 3, C2f, [256]] # 8: Process features
    - [[8], 1, Detect, [nc]] # 9: Detection layer

Định dạng thông số kỹ thuật lớp

Mỗi lớp đều tuân theo một mô hình nhất quán: [from, repeats, module, args]

Thành phần Mục đích Ví dụ
từ Kết nối đầu vào -1 (trước), 6 (lớp 6), [4, 6, 8] (nhiều đầu vào)
lặp lại Số lần lặp lại 1 (đơn), 3 (lặp lại 3 lần)
mô-đun Loại mô-đun Conv, C2f, TorchVision, Detect
các đối số Đối số mô-đun [64, 3, 2] (kênh, hạt nhân, bước tiến)

Các mẫu kết nối

Hàm from trường tạo ra các mẫu luồng dữ liệu linh hoạt trên toàn bộ mạng của bạn:

- [-1, 1, Conv, [64, 3, 2]]    # Takes input from previous layer

- [[-1, 6], 1, Concat, [1]]    # Combines current layer with layer 6

- [[4, 6, 8], 1, Detect, [nc]] # Detection head using 3 feature scales

Lập chỉ mục lớp

Các lớp được lập chỉ mục bắt đầu từ 0. Chỉ số âm tham chiếu đến các lớp trước đó (-1 = lớp trước đó), trong khi các chỉ số dương tham chiếu các lớp cụ thể theo vị trí của chúng.

Lặp lại mô-đun

Hàm repeats tham số tạo ra các phần mạng sâu hơn:

- [-1, 3, C2f, [128, True]] # Creates 3 consecutive C2f blocks
- [-1, 1, Conv, [64, 3, 2]] # Single convolution layer

Số lần lặp lại thực tế sẽ được nhân với hệ số tỷ lệ độ sâu từ cấu hình kích thước mô hình của bạn.

Các mô-đun có sẵn

Các mô-đun được sắp xếp theo chức năng và được định nghĩa trong thư mục mô-đun Ultralytics . Các bảng sau đây hiển thị các mô-đun thường dùng theo danh mục, cùng nhiều mô-đun khác có sẵn trong mã nguồn:

Các thao tác cơ bản

Mô-đun Mục đích Nguồn Các đối số
Conv Convolution + BatchNorm + Kích hoạt conv.py [out_ch, kernel, stride, pad, groups]
nn.Upsample Lấy mẫu không gian PyTorch [size, scale_factor, mode]
nn.Identity Hoạt động chuyển tiếp PyTorch []

Khối tổng hợp

Mô-đun Mục đích Nguồn Các đối số
C2f Nút thắt CSP với 2 phép tích chập block.py [out_ch, shortcut, expansion]
SPPF Ghép nhóm kim tự tháp không gian (nhanh) block.py [out_ch, kernel_size]
Concat Ghép nối theo kênh conv.py [dimension]

Các mô-đun chuyên biệt

Mô-đun Mục đích Nguồn Các đối số
TorchVision Tải bất kỳ mô hình torchvision nào block.py [out_ch, model_name, weights, unwrap, truncate, split]
Index Trích xuất cụ thể tensor từ danh sách block.py [out_ch, index]
Detect YOLO đầu phát hiện head.py [nc, anchors, ch]

Danh sách mô-đun đầy đủ

Đây là một tập hợp con các mô-đun khả dụng. Để biết danh sách đầy đủ các mô-đun và tham số của chúng, hãy khám phá thư mục mô-đun .

Tính năng nâng cao

Tích hợp TorchVision

Mô-đun TorchVision cho phép tích hợp liền mạch bất kỳ mô hình TorchVision nào thành xương sống:

from ultralytics import YOLO

# Model with ConvNeXt backbone
model = YOLO("convnext_backbone.yaml")
results = model.train(data="coco8.yaml", epochs=100)

backbone:
  - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, False]]
head:
  - [-1, 1, Classify, [nc]]

Phân tích tham số:

  • 768: Kênh đầu ra dự kiến
  • convnext_tiny: Kiến trúc mô hình (các mẫu có sẵn)
  • DEFAULT: Sử dụng tạ đã được tập luyện trước
  • True: Xóa đầu phân loại
  • 2: Cắt bớt 2 lớp cuối cùng
  • False: Trả về đơn tensor (không liệt kê)

Các tính năng đa tỷ lệ

Đặt tham số cuối cùng thành True để có được bản đồ đặc điểm trung gian cho việc phát hiện đa thang đo.

Mô-đun chỉ mục để lựa chọn tính năng

Khi sử dụng các mô hình xuất ra nhiều bản đồ đặc điểm, mô-đun Index sẽ chọn các đầu ra cụ thể:

backbone:
    - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, True]] # Multi-output
head:
    - [0, 1, Index, [192, 4]] # Select 4th feature map (192 channels)
    - [0, 1, Index, [384, 6]] # Select 6th feature map (384 channels)
    - [0, 1, Index, [768, 8]] # Select 8th feature map (768 channels)
    - [[1, 2, 3], 1, Detect, [nc]] # Multi-scale detection

Hệ thống phân giải mô-đun

Hiểu cách Ultralytics việc định vị và nhập các mô-đun là rất quan trọng để tùy chỉnh:

Quy trình tra cứu mô-đun

Ultralytics sử dụng hệ thống ba tầng trong parse_model:

# Core resolution logic
m = getattr(torch.nn, m[3:]) if "nn." in m else getattr(torchvision.ops, m[4:]) if "ops." in m else globals()[m]
  1. PyTorch các mô-đun: Tên bắt đầu bằng 'nn.' → torch.nn không gian tên
  2. Hoạt động của TorchVision: Tên bắt đầu bằng 'ops.' → torchvision.ops không gian tên
  3. Mô-đun Ultralytics : Tất cả các tên khác → không gian tên toàn cục thông qua lệnh nhập

Chuỗi nhập mô-đun

Các mô-đun tiêu chuẩn có sẵn thông qua việc nhập khẩu tasks.py:

from ultralytics.nn.modules import (  # noqa: F401, E501
    SPPF,
    C2f,
    Conv,
    Detect,
    # ... many more modules
    Index,
    TorchVision,
)

Tích hợp mô-đun tùy chỉnh

Sửa đổi mã nguồn

Sửa đổi mã nguồn là cách linh hoạt nhất để tích hợp các mô-đun tùy chỉnh của bạn, nhưng nó có thể khá phức tạp. Để định nghĩa và sử dụng một mô-đun tùy chỉnh, hãy làm theo các bước sau:

  1. Xác định mô-đun của bạn trong ultralytics/nn/modules/block.py:

    class CustomBlock(nn.Module):
    def __init__(self, c1, c2):
        super().__init__()
        self.layers = nn.Sequential(nn.Conv2d(c1, c2, 3, 1, 1), nn.BatchNorm2d(c2), nn.ReLU())

    def forward(self, x):
        return self.layers(x)

  2. Hiển thị mô-đun của bạn ở cấp độ gói trong ultralytics/nn/modules/__init__.py:

    from .block import CustomBlock  # noqa makes CustomBlock available as ultralytics.nn.modules.CustomBlock

  3. Thêm vào mục nhập trong ultralytics/nn/tasks.py:

    from ultralytics.nn.modules import CustomBlock  # noqa

  4. Xử lý các đối số đặc biệt (nếu cần) bên trong parse_model() trong ultralytics/nn/tasks.py:

    elif m is CustomBlock:
    c1, c2 = ch[f], args[0]  # input channels, output channels
    args = [c1, c2, *args[1:]]

  5. Sử dụng mô-đun trong mô hình YAML của bạn:

    # custom_model.yaml
nc: 1
backbone:
    - [-1, 1, CustomBlock, [64]]
head:
    - [-1, 1, Classify, [nc]]

  6. Kiểm tra FLOP để đảm bảo lệnh chuyển tiếp hoạt động:

    from ultralytics import YOLO

model = YOLO("custom_model.yaml", task="classify")
model.info()  # should print non-zero FLOPs if working

Cấu hình Ví dụ

Mô hình phát hiện cơ bản

# Simple YOLO detection model
nc: 80
scales:
    n: [0.33, 0.25, 1024]

backbone:
    - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
    - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
    - [-1, 3, C2f, [128, True]] # 2
    - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
    - [-1, 6, C2f, [256, True]] # 4
    - [-1, 1, SPPF, [256, 5]] # 5

head:
    - [-1, 1, Conv, [256, 3, 1]] # 6
    - [[6], 1, Detect, [nc]] # 7

Mô hình xương sống TorchVision

# ConvNeXt backbone with YOLO head
nc: 80

backbone:
    - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, True]]

head:
    - [0, 1, Index, [192, 4]] # P3 features
    - [0, 1, Index, [384, 6]] # P4 features
    - [0, 1, Index, [768, 8]] # P5 features
    - [[1, 2, 3], 1, Detect, [nc]] # Multi-scale detection

Mô hình phân loại

# Simple classification model
nc: 1000

backbone:
    - [-1, 1, Conv, [64, 7, 2, 3]]
    - [-1, 1, nn.MaxPool2d, [3, 2, 1]]
    - [-1, 4, C2f, [64, True]]
    - [-1, 1, Conv, [128, 3, 2]]
    - [-1, 8, C2f, [128, True]]
    - [-1, 1, nn.AdaptiveAvgPool2d, [1]]

head:
    - [-1, 1, Classify, [nc]]

Thực hành tốt nhất

Mẹo thiết kế kiến trúc

Bắt đầu đơn giản : Bắt đầu với các kiến trúc đã được chứng minh trước khi tùy chỉnh. Sử dụng các kiến trúc hiện có YOLO cấu hình dưới dạng mẫu và sửa đổi dần dần thay vì xây dựng từ đầu.

Kiểm tra từng bước : Xác thực từng bước sửa đổi. Thêm từng mô-đun tùy chỉnh một và kiểm tra xem nó có hoạt động không trước khi tiến hành thay đổi tiếp theo.

Kênh giám sát: Đảm bảo kích thước kênh khớp với các lớp được kết nối. Các kênh đầu ra (c2) của một lớp phải khớp với các kênh đầu vào (c1) của lớp tiếp theo trong chuỗi.

Sử dụng Bỏ qua Kết nối: Tận dụng tính năng tái sử dụng với [[-1, N], 1, Concat, [1]] các mẫu. Những kết nối này hỗ trợ cho dòng chảy gradient và cho phép mô hình kết hợp các đặc điểm từ nhiều tỷ lệ khác nhau.

Tỷ lệ phù hợp: Chọn thang đo mô hình dựa trên các ràng buộc tính toán của bạn. Sử dụng nano (n) cho các thiết bị biên, nhỏ (s) để có hiệu suất cân bằng và quy mô lớn hơn (m, l, x) để có độ chính xác tối đa.

Cân nhắc về hiệu suất

Chiều sâu so với Chiều rộng : Mạng sâu nắm bắt các đặc điểm phân cấp phức tạp thông qua nhiều lớp chuyển đổi, trong khi mạng rộng xử lý nhiều thông tin song song hơn ở mỗi lớp. Cân bằng giữa hai yếu tố này dựa trên độ phức tạp của tác vụ.

Kết nối bỏ qua : Cải thiện luồng gradient trong quá trình huấn luyện và cho phép tái sử dụng tính năng trên toàn mạng. Chúng đặc biệt quan trọng trong các kiến trúc sâu hơn để ngăn chặn hiện tượng gradient biến mất.

Khối nút thắt cổ chai: Giảm chi phí tính toán trong khi vẫn duy trì tính biểu đạt của mô hình. Các mô-đun như C2f sử dụng ít tham số hơn so với phép tích chập tiêu chuẩn trong khi vẫn duy trì khả năng học tính năng.

Tính năng đa tỷ lệ : Cần thiết để phát hiện các đối tượng có kích thước khác nhau trên cùng một hình ảnh. Sử dụng các mẫu Mạng kim tự tháp tính năng (FPN) với nhiều đầu phát hiện ở các tỷ lệ khác nhau.

Xử lý sự cố

Các Vấn Đề Thường Gặp

Vấn đề Gây ra Giải pháp
KeyError: 'ModuleName' Mô-đun không được nhập Thêm vào tasks.py nhập khẩu
Kích thước kênh không khớp Không đúng args đặc điểm kỹ thuật Xác minh khả năng tương thích của kênh đầu vào/đầu ra
AttributeError: 'int' object has no attribute Loại đối số sai Kiểm tra tài liệu mô-đun để biết loại đối số chính xác
Mô hình không xây dựng được Không hợp lệ from thẩm quyền giải quyết Đảm bảo các lớp được tham chiếu tồn tại

Mẹo gỡ lỗi

Khi phát triển kiến trúc tùy chỉnh, việc gỡ lỗi có hệ thống sẽ giúp xác định sớm các vấn đề:

Sử dụng Identity Head để kiểm tra

Thay thế các đầu phức tạp bằng nn.Identity để cô lập các vấn đề xương sống:

nc: 1
backbone:
    - [-1, 1, CustomBlock, [64]]
head:
    - [-1, 1, nn.Identity, []] # Pass-through for debugging

Điều này cho phép kiểm tra trực tiếp đầu ra xương sống:

import torch

from ultralytics import YOLO

model = YOLO("debug_model.yaml")
output = model.model(torch.randn(1, 3, 640, 640))
print(f"Output shape: {output.shape}")  # Should match expected dimensions

Kiểm tra kiến trúc mô hình

Kiểm tra số lượng FLOP và in ra từng lớp cũng có thể giúp gỡ lỗi các sự cố với cấu hình mô hình tùy chỉnh của bạn. Số lượng FLOP phải khác 0 đối với một mô hình hợp lệ. Nếu bằng 0, có thể có vấn đề với bước chuyển tiếp. Chạy một bước chuyển tiếp đơn giản sẽ hiển thị chính xác lỗi đang gặp phải.

from ultralytics import YOLO

# Build model with verbose output to see layer details
model = YOLO("debug_model.yaml", verbose=True)

# Check model FLOPs. Failed forward pass causes 0 FLOPs.
model.info()

# Inspect individual layers
for i, layer in enumerate(model.model.model):
    print(f"Layer {i}: {layer}")

Xác thực từng bước

  1. Bắt đầu tối thiểu : Đầu tiên hãy thử nghiệm với kiến trúc đơn giản nhất có thể
  2. Thêm dần dần : Xây dựng độ phức tạp theo từng lớp
  3. Kiểm tra kích thước : Xác minh tính tương thích của kênh và kích thước không gian
  4. Xác thực tỷ lệ: Kiểm tra với các thang đo mô hình khác nhau (n, s, m)

Câu hỏi thường gặp

Làm thế nào để thay đổi số lượng lớp trong mô hình của tôi?

Đặt nc tham số ở đầu tệp YAML của bạn để khớp với số lớp trong tập dữ liệu của bạn.

nc: 5 # 5 classes

Tôi có thể sử dụng xương sống tùy chỉnh trong mô hình YAML của mình không?

Có. Bạn có thể sử dụng bất kỳ mô-đun được hỗ trợ nào, bao gồm cả xương sống TorchVision, hoặc xác định mô-đun tùy chỉnh của riêng bạn và nhập nó như mô tả trong Tích hợp mô-đun tùy chỉnh .

Làm thế nào để tôi có thể thay đổi kích thước mô hình của mình cho phù hợp với các kích cỡ khác nhau (nano, nhỏ, trung bình, v.v.)?

Sử dụng scales phần trong YAML của bạn để xác định các hệ số tỷ lệ cho độ sâu, chiều rộng và kênh tối đa. Mô hình sẽ tự động áp dụng các hệ số này khi bạn tải tệp YAML cơ sở với tỷ lệ được thêm vào tên tệp (ví dụ: yolo11n.yaml).

Cái gì làm [from, repeats, module, args] định dạng có nghĩa là gì?

Định dạng này chỉ định cách xây dựng từng lớp:

  • from: nguồn đầu vào
  • repeats: số lần lặp lại mô-đun
  • module: loại lớp
  • args: đối số cho mô-đun

Làm thế nào để khắc phục lỗi kênh không khớp?

Kiểm tra xem các kênh đầu ra của một lớp có khớp với các kênh đầu vào dự kiến của lớp tiếp theo không. Sử dụng print(model.model.model) để kiểm tra kiến trúc mô hình của bạn.

Tôi có thể tìm danh sách các mô-đun có sẵn và đối số của chúng ở đâu?

Kiểm tra mã nguồn trong ultralytics/nn/modules thư mục cho tất cả các mô-đun có sẵn và các đối số của chúng.

Làm thế nào để thêm mô-đun tùy chỉnh vào cấu hình YAML của tôi?

Xác định mô-đun của bạn trong mã nguồn, nhập mô-đun như được hiển thị trong Sửa đổi mã nguồn và tham chiếu theo tên trong tệp YAML của bạn.

Tôi có thể sử dụng trọng số được đào tạo trước với YAML tùy chỉnh không?

Có, bạn có thể sử dụng model.load("path/to/weights") để tải trọng số từ một điểm kiểm tra được đào tạo trước. Tuy nhiên, chỉ những trọng số cho các lớp khớp mới được tải thành công.

Làm thế nào để xác thực cấu hình mô hình của tôi?

Sử dụng model.info() để kiểm tra xem số FLOP có khác không. Một mô hình hợp lệ phải hiển thị số FLOP khác không. Nếu số FLOP bằng không, hãy làm theo các gợi ý trong Mẹo gỡ lỗi để tìm ra vấn đề.



📅 Đã tạo 0 ngày trước ✏️ Đã cập nhật 0 ngày trước
Y-T-G