Geri Çağırma (Callback)

In the realm of software engineering and artificial intelligence (AI), a callback is a piece of executable code that is passed as an argument to other code, which is then expected to execute (call back) the argument at a given time. In the specific context of deep learning (DL) frameworks, callbacks are essential tools that allow developers to customize the behavior of the model training loop without modifying the core training code itself. They act as automated triggers that perform specific actions at various stages of the training process, such as the start or end of an epoch, a training batch, or the entire training session.

The Role of Callbacks in Machine Learning

Training a complex neural network can take hours or even days. Without callbacks, the training process is essentially a "black box" that runs until completion, often requiring manual supervision. Callbacks introduce observability and control, allowing the system to self-regulate based on real-time performance metrics.

When using high-level libraries like PyTorch or TensorFlow, callbacks provide a way to inject logic into the optimization algorithm. For instance, if a model is learning well, a callback might save the current state; if it stops learning, a callback might halt the process to save resources. This makes the machine learning (ML) workflow more efficient and robust.

Common Applications and Real-World Examples

Callbacks are versatile and can be used for a wide range of tasks during model monitoring and optimization.

• Early Stopping: One of the most common uses is early stopping. This callback monitors a specific metric, such as validation data loss. If the loss ceases to decrease for a set number of epochs, the callback halts training. This prevents overfitting, ensuring the model generalizes well to new data rather than memorizing the training data.
• Model Checkpointing: In long training runs, hardware failures can be catastrophic. A checkpointing callback saves the model weights at regular intervals (e.g., every epoch) or only when the model achieves a new "best" score on metrics like accuracy or mean average precision (mAP). This ensures you always have a saved version of the best-performing model.
• Learning Rate Scheduling: The learning rate controls how much the model changes in response to the estimated error each time the model weights are updated. A callback can dynamically adjust this rate, reducing it when learning plateaus to help the model converge on an optimal solution, a technique often referred to as learning rate decay.
• Logging and Visualization: Callbacks are frequently used to integrate with experiment tracking tools. They stream metrics to dashboards like TensorBoard or MLflow, allowing data scientists to visualize loss functions and performance graphs in real-time.

Implementing Callbacks with Ultralytics YOLO

The Ultralytics library supports a robust callback system, allowing users to hook into events during the training of models like YOLO26. This is particularly useful for users managing workflows on the Ultralytics Platform who need custom logging or control logic.

Below is a concise example of how to define and register a custom callback that prints a message at the end of every training epoch using the Python API:

from ultralytics import YOLO


# Define a custom callback function
def on_train_epoch_end(trainer):
    """Callback function to execute at the end of each training epoch."""
    print(f"Epoch {trainer.epoch + 1} complete. Current Fitness: {trainer.fitness}")


# Load the YOLO26 model (latest generation)
model = YOLO("yolo26n.pt")

# Register the custom callback to the model
model.add_callback("on_train_epoch_end", on_train_epoch_end)

# Train the model with the callback active
model.train(data="coco8.yaml", epochs=3)

Callbacks vs. Hooks

While related, it is helpful to distinguish callbacks from hooks. In frameworks like PyTorch, hooks are generally lower-level functions attached to specific tensor operations or neural network layers to inspect or modify gradients and outputs during the forward or backward pass. In contrast, callbacks are typically higher-level abstractions tied to the training loop events (start, end, batch processing) rather than the mathematical computation graph itself.

Daha Fazla Okuma ve Kaynak

For those looking to deepen their understanding of how to optimize training workflows, exploring hyperparameter tuning is a logical next step. Additionally, understanding the underlying computer vision (CV) tasks such as object detection and instance segmentation will provide context on why precise training control via callbacks is necessary. For enterprise-grade management of these processes, the Ultralytics Platform offers integrated solutions that automate many of these callback-driven behaviors.