Ultralytics YOLO27:
Get Started

Callback#

Framework Ultralytics hỗ trợ callback, đóng vai trò là các điểm truy cập ở những giai đoạn quan trọng trong các chế độ train, val, export và predict. Mỗi callback nhận một đối tượng Trainer, Validator hoặc Predictor, tùy theo loại thao tác. Tất cả thuộc tính của các đối tượng này được trình bày chi tiết trong các trang tham khảo BaseTrainer, BaseValidator và BasePredictor.



Xem: Cách sử dụng callback của Ultralytics | Callback dự đoán, huấn luyện, xác thực và xuất model | Ultralytics YOLO26 🚀

Ví dụ#

Trả về thông tin bổ sung cùng với kết quả dự đoán#

Trong ví dụ này, chúng tôi minh họa cách trả về frame gốc cùng với từng đối tượng kết quả:

from ultralytics import YOLO

def on_predict_batch_end(predictor):
    """Combine prediction results with corresponding frames."""
    _, image, _ = predictor.batch

    # Đảm bảo image là một danh sách
    image = image if isinstance(image, list) else [image]

    # Kết hợp kết quả dự đoán với các frame tương ứng
    predictor.results = zip(predictor.results, image)

# Tạo một instance YOLO model
model = YOLO("yolo26n.pt")

# Thêm callback tùy chỉnh vào model
model.add_callback("on_predict_batch_end", on_predict_batch_end)

# Lặp qua các kết quả và frame
for result, frame in model.predict():  # hoặc model.track()
    pass

Đăng ký PyTorch Forward Hook trước khi huấn luyện#

model.train() tạo model huấn luyện từ cấu hình model và nạp các trọng số đã tải vào model đó. Các hook PyTorch được đăng ký trực tiếp trên model.model trước lời gọi này là trạng thái runtime, vì vậy model huấn luyện được tạo lại sẽ không kế thừa chúng. Hãy đăng ký hook huấn luyện trong on_pretrain_routine_end, sau khi hoàn tất thiết lập model:

from ultralytics import YOLO
from ultralytics.utils.torch_utils import unwrap_model

def preprocess_input(module, inputs):
    """Center each input channel before the first model layer."""
    images = inputs[0]
    return (images - images.mean(dim=(-2, -1), keepdim=True),)

def register_forward_pre_hook(trainer):
    """Attach preprocessing to the active training model."""
    train_model = unwrap_model(trainer.model)
    train_model.model[0].register_forward_pre_hook(preprocess_input)

model = YOLO("yolo26n.pt")
model.add_callback("on_pretrain_routine_end", register_forward_pre_hook)
model.train(data="coco8.yaml", epochs=1)

unwrap_model() xử lý cả hoạt động huấn luyện trên một thiết bị lẫn hoạt động huấn luyện DistributedDataParallel. Không gắn hook được định nghĩa cục bộ vào trainer.ema.ema, vì checkpoint huấn luyện tuần tự hóa model EMA và một tiến trình khác có thể không nhập được callback khi tải checkpoint. Nếu cần chạy cùng một bước tiền xử lý trong quá trình validation khi huấn luyện, hãy triển khai bước đó dưới dạng thành phần model có thể import thay vì hook runtime. Cơ chế khôi phục NaN tạo lại EMA từ model huấn luyện, do đó hook đăng ký theo cách này sẽ được sao chép vào EMA và các checkpoint đã lưu sau khi khôi phục; hãy định nghĩa hàm hook trong một module có thể import nếu cần tải checkpoint trong một tiến trình khác.

model.val() độc lập sao chép model đã tải cho mỗi lần gọi. Prediction tạo và lưu cache một bản sao trong lần gọi đầu tiên, vì vậy hãy đăng ký hook trên model.model trước lần gọi model.predict() hoặc model.track() đầu tiên; các hook được thêm sau đó sẽ không được áp dụng cho predictor đã lưu cache. Đăng ký lại hook runtime sau khi tải checkpoint trong một tiến trình mới.

Truy cập các metric của model bằng callback on_model_save#

Ví dụ này minh họa cách lấy thông tin chi tiết về quá trình huấn luyện, chẳng hạn như điểm best_fitness, total_loss và các metric khác, sau khi checkpoint được lưu bằng callback on_model_save.

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo26n.pt")

def print_checkpoint_metrics(trainer):
    """Print trainer metrics and loss details after each checkpoint is saved."""
    print(
        f"Model details\n"
        f"Best fitness: {trainer.best_fitness}, "
        f"Loss names: {trainer.loss_names}, "  # List of loss names
        f"Metrics: {trainer.metrics}, "
        f"Total loss: {trainer.tloss}"  # Total loss value
    )

if __name__ == "__main__":
    # Add on_model_save callback.
    model.add_callback("on_model_save", print_checkpoint_metrics)

    # Run model training on custom dataset.
    results = model.train(data="coco8.yaml", epochs=3)

Tất cả callback#

Dưới đây là tất cả callback được hỗ trợ. Để biết thêm chi tiết, hãy tham khảo mã nguồn của callback.

Callback của Trainer#

CallbackMô tả
on_pretrain_routine_startĐược kích hoạt khi bắt đầu quy trình tiền huấn luyện, trước khi tải dữ liệu và thiết lập model.
on_pretrain_routine_endĐược kích hoạt khi kết thúc quy trình tiền huấn luyện, sau khi hoàn tất tải dữ liệu và thiết lập model.
on_train_startĐược kích hoạt khi bắt đầu huấn luyện, trước khi epoch đầu tiên bắt đầu.
on_train_epoch_startĐược kích hoạt khi bắt đầu mỗi epoch huấn luyện, trước khi bắt đầu lặp qua các batch.
on_train_batch_startĐược kích hoạt khi bắt đầu mỗi batch huấn luyện, trước lượt forward.
optimizer_stepĐược kích hoạt trong bước optimizer. Dành cho các tích hợp tùy chỉnh; vòng lặp huấn luyện mặc định không gọi callback này.
on_before_zero_gradĐược kích hoạt trước khi đặt gradient về 0. Dành cho các tích hợp tùy chỉnh; vòng lặp huấn luyện mặc định không gọi callback này.
on_train_batch_endĐược kích hoạt khi kết thúc mỗi batch huấn luyện, sau lượt backward. Bước optimizer có thể được hoãn do tích lũy gradient.
on_train_epoch_endĐược kích hoạt khi kết thúc mỗi epoch huấn luyện, sau khi xử lý tất cả batch nhưng trước validation. Metric validation và fitness có thể chưa khả dụng.
on_model_saveĐược kích hoạt khi lưu checkpoint của model, sau validation.
on_fit_epoch_endĐược kích hoạt khi kết thúc mỗi epoch fit (train + val), sau validation và mọi thao tác lưu checkpoint. Metric validation khả dụng, và fitness khả dụng cho lời gọi huấn luyện theo từng epoch. Callback này cũng được gọi trong quá trình đánh giá model tốt nhất cuối cùng, khi không lưu checkpoint và fitness có thể không hiện diện.
on_train_endĐược kích hoạt khi quy trình huấn luyện kết thúc, sau khi đánh giá cuối cùng model tốt nhất.
on_params_updateĐược kích hoạt khi các tham số của model được cập nhật. Dành cho các tích hợp tùy chỉnh; vòng lặp huấn luyện mặc định không gọi callback này.
teardownĐược kích hoạt khi quy trình huấn luyện đang được dọn dẹp.

Callback của Validator#

CallbackMô tả
on_val_startĐược kích hoạt khi bắt đầu validation.
on_val_batch_startĐược kích hoạt khi bắt đầu mỗi batch validation.
on_val_batch_endĐược kích hoạt khi kết thúc mỗi batch validation.
on_val_endĐược kích hoạt khi validation kết thúc.

Callback của Predictor#

CallbackMô tả
on_predict_startĐược kích hoạt khi quy trình prediction bắt đầu.
on_predict_batch_startĐược kích hoạt khi bắt đầu mỗi batch prediction.
on_predict_postprocess_endĐược kích hoạt khi kết thúc quá trình hậu xử lý prediction.
on_predict_batch_endĐược kích hoạt khi kết thúc mỗi batch prediction.
on_predict_endĐược kích hoạt khi quy trình prediction kết thúc.

Callback của Exporter#

CallbackMô tả
on_export_startĐược kích hoạt khi bắt đầu quy trình export.
on_export_endĐược kích hoạt khi kết thúc quy trình export.

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

  • Callback của Ultralytics là các điểm truy cập chuyên biệt được kích hoạt trong những giai đoạn quan trọng của các hoạt động với model, chẳng hạn như huấn luyện, validation, export và prediction. Callback cho phép thêm chức năng tùy chỉnh tại các thời điểm cụ thể trong quy trình, nhờ đó có thể cải tiến và điều chỉnh workflow. Mỗi callback nhận một đối tượng Trainer, Validator hoặc Predictor, tùy theo loại thao tác. Để biết chi tiết về các thuộc tính của những đối tượng này, hãy tham khảo các trang tham khảo BaseTrainer, BaseValidator và BasePredictor.

    Để sử dụng callback, hãy định nghĩa một hàm và thêm hàm đó vào model bằng phương thức model.add_callback(). Sau đây là ví dụ về cách trả về thông tin bổ sung trong quá trình prediction:

    from ultralytics import YOLO
    
    def on_predict_batch_end(predictor):
        """Handle prediction batch end by combining results with corresponding frames; modifies predictor results."""
        _, image, _ = predictor.batch
        image = image if isinstance(image, list) else [image]
        predictor.results = zip(predictor.results, image)
    
    model = YOLO("yolo26n.pt")
    model.add_callback("on_predict_batch_end", on_predict_batch_end)
    for result, frame in model.predict():
        pass
  • Tùy chỉnh quy trình huấn luyện Ultralytics bằng cách chèn logic vào các giai đoạn cụ thể của quá trình huấn luyện. Ultralytics YOLO cung cấp nhiều callback huấn luyện, chẳng hạn như on_train_start, on_train_end và on_train_batch_end, cho phép bạn thêm metric, xử lý hoặc ghi log tùy chỉnh.

    Sau đây là cách ghi log learning rate của từng nhóm tham số optimizer vào cuối mỗi epoch huấn luyện:

    from ultralytics import YOLO
    
    def log_learning_rates(trainer):
        """Print the current learning rates after each training epoch."""
        print(f"Epoch {trainer.epoch + 1}: {trainer.lr}")
    
    model = YOLO("yolo26n.pt")
    model.add_callback("on_train_epoch_end", log_learning_rates)
    model.train(data="coco8.yaml", epochs=3)
    Mẹo

    Bạn không cần callback để đóng băng các thống kê BatchNorm khi sử dụng freeze: trainer tự động chuyển các layer BatchNorm thuộc những layer bị đóng băng sang chế độ eval khi bắt đầu mỗi epoch.

    Để biết thêm chi tiết về cách sử dụng callback huấn luyện hiệu quả, hãy xem Hướng dẫn huấn luyện.

  • Sử dụng callback trong quá trình validation với Ultralytics YOLO giúp cải thiện việc đánh giá model bằng cách cho phép xử lý tùy chỉnh, ghi log hoặc tính toán metric. Các callback như on_val_start, on_val_batch_end và on_val_end cung cấp điểm truy cập để chèn logic tùy chỉnh, đảm bảo quy trình validation chi tiết và toàn diện.

    Ví dụ: vẽ tất cả batch validation thay vì chỉ ba batch đầu tiên:

    import inspect
    
    from ultralytics import YOLO
    
    def plot_samples(validator):
        frame = inspect.currentframe().f_back.f_back
        v = frame.f_locals
        validator.plot_val_samples(v["batch"], v["batch_i"])
        validator.plot_predictions(v["batch"], v["preds"], v["batch_i"])
    
    model = YOLO("yolo26n.pt")
    model.add_callback("on_val_batch_end", plot_samples)
    model.val(data="coco.yaml")

    Để tìm hiểu thêm về cách tích hợp callback vào quy trình validation, hãy xem Hướng dẫn validation.

  • Để gắn callback tùy chỉnh cho chế độ prediction trong Ultralytics YOLO, hãy định nghĩa một hàm callback và đăng ký hàm đó với quy trình prediction. Các callback prediction thường dùng gồm on_predict_start, on_predict_batch_end và on_predict_end. Các callback này cho phép sửa đổi đầu ra prediction và tích hợp thêm chức năng, chẳng hạn như ghi log dữ liệu hoặc chuyển đổi kết quả.

    Sau đây là ví dụ về callback tùy chỉnh lưu các kết quả prediction dựa trên việc có hay không có một đối tượng thuộc lớp cụ thể:

    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    
    class_id = 2
    
    def save_on_object(predictor):
        r = predictor.results[0]
        if class_id in r.boxes.cls:
            predictor.args.save = True
        else:
            predictor.args.save = False
    
    model.add_callback("on_predict_postprocess_end", save_on_object)
    results_stream = model("pedestrians.mp4", stream=True, save=True)
    
    for result in results_stream:
        pass

    Để tìm hiểu cách sử dụng toàn diện hơn, hãy tham khảo Hướng dẫn prediction, bao gồm hướng dẫn chi tiết và các tùy chọn tùy chỉnh bổ sung.

  • Ultralytics YOLO hỗ trợ nhiều cách triển khai callback thiết thực để cải tiến và tùy chỉnh các giai đoạn khác nhau như huấn luyện, validation và prediction. Một số ví dụ thực tế gồm:

    • Ghi log metric tùy chỉnh: Ghi log thêm metric ở các giai đoạn khác nhau, chẳng hạn như cuối các epoch huấn luyện hoặc validation.
    • Tăng cường dữ liệu: Triển khai các phép biến đổi hoặc tăng cường dữ liệu tùy chỉnh trong quá trình prediction hoặc trong các batch huấn luyện.
    • Kết quả trung gian: Lưu các kết quả trung gian, chẳng hạn như prediction hoặc frame, để phân tích hoặc trực quan hóa thêm.

    Ví dụ: Kết hợp frame với kết quả prediction trong quá trình prediction bằng on_predict_batch_end:

    from ultralytics import YOLO
    
    def on_predict_batch_end(predictor):
        """Combine prediction results with frames."""
        _, image, _ = predictor.batch
        image = image if isinstance(image, list) else [image]
        predictor.results = zip(predictor.results, image)
    
    model = YOLO("yolo26n.pt")
    model.add_callback("on_predict_batch_end", on_predict_batch_end)
    for result, frame in model.predict():
        pass

    Khám phá mã nguồn callback để xem thêm tùy chọn và ví dụ.

Người đóng góp

Bình luận