ultralytics 8.3.196 torch.compile acceleration for 30% faster training (#21975)
Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com> Co-authored-by: UltralyticsAssistant <web@ultralytics.com> Co-authored-by: Y-T-G <32206511+Y-T-G@users.noreply.github.com>
This commit is contained in:
parent
b337a105aa
commit
aeeb3ecaeb
@ -21,3 +21,4 @@
|
||||
| `name` | `str` | `None` | Name of the prediction run. Used for creating a subdirectory within the project folder, where prediction outputs are stored if `save` is enabled. |
|
||||
| `stream` | `bool` | `False` | Enables memory-efficient processing for long videos or numerous images by returning a generator of Results objects instead of loading all frames into memory at once. |
|
||||
| `verbose` | `bool` | `True` | Controls whether to display detailed inference logs in the terminal, providing real-time feedback on the prediction process. |
|
||||
| `compile` | `bool` | `False` | Enables PyTorch 2.x `torch.compile` graph compilation to optimize model execution. Applies to supported devices (CUDA/CPU/MPS). Uses `backend='inductor'`, `mode='max-autotune'`. Falls back to eager mode with a warning if unsupported. |
|
||||
|
||||
@ -48,3 +48,4 @@
|
||||
| `dropout` | `float` | `0.0` | Dropout rate for regularization in classification tasks, preventing overfitting by randomly omitting units during training. |
|
||||
| `val` | `bool` | `True` | Enables validation during training, allowing for periodic evaluation of model performance on a separate dataset. |
|
||||
| `plots` | `bool` | `False` | Generates and saves plots of training and validation metrics, as well as prediction examples, providing visual insights into model performance and learning progression. |
|
||||
| `compile` | `bool` | `False` | Enables PyTorch 2.x `torch.compile` graph compilation to optimize model execution. Applies to supported devices (CUDA/CPU/MPS). Uses `backend='inductor'`, `mode='max-autotune'`. Falls back to eager mode with a warning if unsupported. |
|
||||
|
||||
@ -24,3 +24,4 @@
|
||||
| `agnostic_nms` | `bool` | `False` | Enables class-agnostic [Non-Maximum Suppression](https://www.ultralytics.com/glossary/non-maximum-suppression-nms), which merges overlapping boxes regardless of their predicted class. Useful for instance-focused applications. |
|
||||
| `single_cls` | `bool` | `False` | Treats all classes as a single class during validation. Useful for evaluating model performance on binary detection tasks or when class distinctions aren't important. |
|
||||
| `visualize` | `bool` | `False` | Visualizes the ground truths, true positives, false positives and false negatives for each image. Useful for debugging and model interpretation. |
|
||||
| `compile` | `bool` | `False` | Enables PyTorch 2.x `torch.compile` graph compilation to optimize model execution. Applies to supported devices (CUDA/CPU/MPS). Uses `backend='inductor'`, `mode='max-autotune'`. Falls back to eager mode with a warning if unsupported. |
|
||||
|
||||
@ -107,7 +107,7 @@ keywords: Ultralytics, torch utils, model optimization, device selection, infere
|
||||
|
||||
<br><br><hr><br>
|
||||
|
||||
## ::: ultralytics.utils.torch_utils.de_parallel
|
||||
## ::: ultralytics.utils.torch_utils.unwrap_model
|
||||
|
||||
<br><br><hr><br>
|
||||
|
||||
@ -137,4 +137,12 @@ keywords: Ultralytics, torch utils, model optimization, device selection, infere
|
||||
|
||||
## ::: ultralytics.utils.torch_utils.profile_ops
|
||||
|
||||
<br><br><hr><br>
|
||||
|
||||
## ::: ultralytics.utils.torch_utils.disable_dynamo
|
||||
|
||||
<br><br><hr><br>
|
||||
|
||||
## ::: ultralytics.utils.torch_utils.attempt_compile
|
||||
|
||||
<br><br>
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
|
||||
|
||||
__version__ = "8.3.195"
|
||||
__version__ = "8.3.196"
|
||||
|
||||
import os
|
||||
|
||||
|
||||
@ -237,6 +237,7 @@ CFG_BOOL_KEYS = frozenset(
|
||||
"nms",
|
||||
"profile",
|
||||
"multi_scale",
|
||||
"compile",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@ -37,6 +37,7 @@ fraction: 1.0 # (float) dataset fraction to train on (default is 1.0, all images
|
||||
profile: False # (bool) profile ONNX and TensorRT speeds during training for loggers
|
||||
freeze: # (int | list, optional) freeze first n layers, or freeze list of layer indices during training
|
||||
multi_scale: False # (bool) Whether to use multiscale during training
|
||||
compile: False # (bool) Run torch.compile() on the model before train/val/predict
|
||||
# Segmentation
|
||||
overlap_mask: True # (bool) merge object masks into a single image mask during training (segment train only)
|
||||
mask_ratio: 4 # (int) mask downsample ratio (segment train only)
|
||||
|
||||
@ -2202,7 +2202,7 @@ class Format:
|
||||
)
|
||||
labels["masks"] = masks
|
||||
labels["img"] = self._format_img(img)
|
||||
labels["cls"] = torch.from_numpy(cls) if nl else torch.zeros(nl)
|
||||
labels["cls"] = torch.from_numpy(cls) if nl else torch.zeros(nl, 1)
|
||||
labels["bboxes"] = torch.from_numpy(instances.bboxes) if nl else torch.zeros((nl, 4))
|
||||
if self.return_keypoint:
|
||||
labels["keypoints"] = (
|
||||
|
||||
@ -217,7 +217,7 @@ def build_dataloader(dataset, batch: int, workers: int, shuffle: bool = True, ra
|
||||
collate_fn=getattr(dataset, "collate_fn", None),
|
||||
worker_init_fn=seed_worker,
|
||||
generator=generator,
|
||||
drop_last=drop_last,
|
||||
drop_last=drop_last and len(dataset) % batch != 0,
|
||||
)
|
||||
|
||||
|
||||
|
||||
@ -51,7 +51,7 @@ from ultralytics.nn.autobackend import AutoBackend
|
||||
from ultralytics.utils import DEFAULT_CFG, LOGGER, MACOS, WINDOWS, callbacks, colorstr, ops
|
||||
from ultralytics.utils.checks import check_imgsz, check_imshow
|
||||
from ultralytics.utils.files import increment_path
|
||||
from ultralytics.utils.torch_utils import select_device, smart_inference_mode
|
||||
from ultralytics.utils.torch_utils import attempt_compile, select_device, smart_inference_mode
|
||||
|
||||
STREAM_WARNING = """
|
||||
inference results will accumulate in RAM unless `stream=True` is passed, causing potential out-of-memory
|
||||
@ -409,6 +409,8 @@ class BasePredictor:
|
||||
if hasattr(self.model, "imgsz") and not getattr(self.model, "dynamic", False):
|
||||
self.args.imgsz = self.model.imgsz # reuse imgsz from export metadata
|
||||
self.model.eval()
|
||||
if self.args.compile:
|
||||
self.model = attempt_compile(self.model, device=self.device)
|
||||
|
||||
def write_results(self, i: int, p: Path, im: torch.Tensor, s: list[str]) -> str:
|
||||
"""
|
||||
|
||||
@ -46,6 +46,7 @@ from ultralytics.utils.torch_utils import (
|
||||
TORCH_2_4,
|
||||
EarlyStopping,
|
||||
ModelEMA,
|
||||
attempt_compile,
|
||||
autocast,
|
||||
convert_optimizer_state_dict_to_fp16,
|
||||
init_seeds,
|
||||
@ -54,6 +55,7 @@ from ultralytics.utils.torch_utils import (
|
||||
strip_optimizer,
|
||||
torch_distributed_zero_first,
|
||||
unset_deterministic,
|
||||
unwrap_model,
|
||||
)
|
||||
|
||||
|
||||
@ -256,6 +258,14 @@ class BaseTrainer:
|
||||
self.model = self.model.to(self.device)
|
||||
self.set_model_attributes()
|
||||
|
||||
# Initialize loss criterion before compilation for torch.compile compatibility
|
||||
if hasattr(self.model, "init_criterion"):
|
||||
self.model.criterion = self.model.init_criterion()
|
||||
|
||||
# Compile model
|
||||
if self.args.compile:
|
||||
self.model = attempt_compile(self.model, device=self.device)
|
||||
|
||||
# Freeze layers
|
||||
freeze_list = (
|
||||
self.args.freeze
|
||||
@ -404,6 +414,7 @@ class BaseTrainer:
|
||||
# Forward
|
||||
with autocast(self.amp):
|
||||
batch = self.preprocess_batch(batch)
|
||||
metadata = {k: batch.pop(k, None) for k in ["im_file", "ori_shape", "resized_shape"]}
|
||||
loss, self.loss_items = self.model(batch)
|
||||
self.loss = loss.sum()
|
||||
if RANK != -1:
|
||||
@ -445,6 +456,7 @@ class BaseTrainer:
|
||||
)
|
||||
self.run_callbacks("on_batch_end")
|
||||
if self.args.plots and ni in self.plot_idx:
|
||||
batch = {**batch, **metadata}
|
||||
self.plot_training_samples(batch, ni)
|
||||
|
||||
self.run_callbacks("on_train_batch_end")
|
||||
@ -565,7 +577,7 @@ class BaseTrainer:
|
||||
"epoch": self.epoch,
|
||||
"best_fitness": self.best_fitness,
|
||||
"model": None, # resume and final checkpoints derive from EMA
|
||||
"ema": deepcopy(self.ema.ema).half(),
|
||||
"ema": deepcopy(unwrap_model(self.ema.ema)).half(),
|
||||
"updates": self.ema.updates,
|
||||
"optimizer": convert_optimizer_state_dict_to_fp16(deepcopy(self.optimizer.state_dict())),
|
||||
"train_args": vars(self.args), # save as dict
|
||||
@ -592,8 +604,6 @@ class BaseTrainer:
|
||||
self.best.write_bytes(serialized_ckpt) # save best.pt
|
||||
if (self.save_period > 0) and (self.epoch % self.save_period == 0):
|
||||
(self.wdir / f"epoch{self.epoch}.pt").write_bytes(serialized_ckpt) # save epoch, i.e. 'epoch3.pt'
|
||||
# if self.args.close_mosaic and self.epoch == (self.epochs - self.args.close_mosaic - 1):
|
||||
# (self.wdir / "last_mosaic.pt").write_bytes(serialized_ckpt) # save mosaic checkpoint
|
||||
|
||||
def get_dataset(self):
|
||||
"""
|
||||
@ -667,7 +677,7 @@ class BaseTrainer:
|
||||
|
||||
def validate(self):
|
||||
"""
|
||||
Run validation on test set using self.validator.
|
||||
Run validation on val set using self.validator.
|
||||
|
||||
Returns:
|
||||
metrics (dict): Dictionary of validation metrics.
|
||||
@ -755,6 +765,7 @@ class BaseTrainer:
|
||||
strip_optimizer(f, updates={k: ckpt[k]} if k in ckpt else None)
|
||||
LOGGER.info(f"\nValidating {f}...")
|
||||
self.validator.args.plots = self.args.plots
|
||||
self.validator.args.compile = False # disable final val compile as too slow
|
||||
self.metrics = self.validator(model=f)
|
||||
self.metrics.pop("fitness", None)
|
||||
self.run_callbacks("on_fit_epoch_end")
|
||||
|
||||
@ -36,7 +36,7 @@ from ultralytics.nn.autobackend import AutoBackend
|
||||
from ultralytics.utils import LOGGER, TQDM, callbacks, colorstr, emojis
|
||||
from ultralytics.utils.checks import check_imgsz
|
||||
from ultralytics.utils.ops import Profile
|
||||
from ultralytics.utils.torch_utils import de_parallel, select_device, smart_inference_mode
|
||||
from ultralytics.utils.torch_utils import attempt_compile, select_device, smart_inference_mode, unwrap_model
|
||||
|
||||
|
||||
class BaseValidator:
|
||||
@ -148,6 +148,8 @@ class BaseValidator:
|
||||
# Force FP16 val during training
|
||||
self.args.half = self.device.type != "cpu" and trainer.amp
|
||||
model = trainer.ema.ema or trainer.model
|
||||
if trainer.args.compile and hasattr(model, "_orig_mod"):
|
||||
model = model._orig_mod # validate non-compiled original model to avoid issues
|
||||
model = model.half() if self.args.half else model.float()
|
||||
self.loss = torch.zeros_like(trainer.loss_items, device=trainer.device)
|
||||
self.args.plots &= trainer.stopper.possible_stop or (trainer.epoch == trainer.epochs - 1)
|
||||
@ -186,6 +188,8 @@ class BaseValidator:
|
||||
self.dataloader = self.dataloader or self.get_dataloader(self.data.get(self.args.split), self.args.batch)
|
||||
|
||||
model.eval()
|
||||
if self.args.compile:
|
||||
model = attempt_compile(model, device=self.device)
|
||||
model.warmup(imgsz=(1 if pt else self.args.batch, self.data["channels"], imgsz, imgsz)) # warmup
|
||||
|
||||
self.run_callbacks("on_val_start")
|
||||
@ -196,7 +200,7 @@ class BaseValidator:
|
||||
Profile(device=self.device),
|
||||
)
|
||||
bar = TQDM(self.dataloader, desc=self.get_desc(), total=len(self.dataloader))
|
||||
self.init_metrics(de_parallel(model))
|
||||
self.init_metrics(unwrap_model(model))
|
||||
self.jdict = [] # empty before each val
|
||||
for batch_i, batch in enumerate(bar):
|
||||
self.run_callbacks("on_val_batch_start")
|
||||
|
||||
@ -55,20 +55,10 @@ class ClassificationTrainer(BaseTrainer):
|
||||
"""
|
||||
Initialize a ClassificationTrainer object.
|
||||
|
||||
This constructor sets up a trainer for image classification tasks, configuring the task type and default
|
||||
image size if not specified.
|
||||
|
||||
Args:
|
||||
cfg (dict[str, Any], optional): Default configuration dictionary containing training parameters.
|
||||
overrides (dict[str, Any], optional): Dictionary of parameter overrides for the default configuration.
|
||||
_callbacks (list[Any], optional): List of callback functions to be executed during training.
|
||||
|
||||
Examples:
|
||||
Create a trainer with custom configuration
|
||||
>>> from ultralytics.models.yolo.classify import ClassificationTrainer
|
||||
>>> args = dict(model="yolo11n-cls.pt", data="imagenet10", epochs=3)
|
||||
>>> trainer = ClassificationTrainer(overrides=args)
|
||||
>>> trainer.train()
|
||||
"""
|
||||
if overrides is None:
|
||||
overrides = {}
|
||||
@ -155,7 +145,7 @@ class ClassificationTrainer(BaseTrainer):
|
||||
with torch_distributed_zero_first(rank): # init dataset *.cache only once if DDP
|
||||
dataset = self.build_dataset(dataset_path, mode)
|
||||
|
||||
loader = build_dataloader(dataset, batch_size, self.args.workers, rank=rank)
|
||||
loader = build_dataloader(dataset, batch_size, self.args.workers, rank=rank, drop_last=self.args.compile)
|
||||
# Attach inference transforms
|
||||
if mode != "train":
|
||||
if is_parallel(self.model):
|
||||
|
||||
@ -15,10 +15,10 @@ from ultralytics.data import build_dataloader, build_yolo_dataset
|
||||
from ultralytics.engine.trainer import BaseTrainer
|
||||
from ultralytics.models import yolo
|
||||
from ultralytics.nn.tasks import DetectionModel
|
||||
from ultralytics.utils import LOGGER, RANK
|
||||
from ultralytics.utils import DEFAULT_CFG, LOGGER, RANK
|
||||
from ultralytics.utils.patches import override_configs
|
||||
from ultralytics.utils.plotting import plot_images, plot_labels, plot_results
|
||||
from ultralytics.utils.torch_utils import de_parallel, torch_distributed_zero_first
|
||||
from ultralytics.utils.torch_utils import torch_distributed_zero_first, unwrap_model
|
||||
|
||||
|
||||
class DetectionTrainer(BaseTrainer):
|
||||
@ -54,6 +54,18 @@ class DetectionTrainer(BaseTrainer):
|
||||
>>> trainer.train()
|
||||
"""
|
||||
|
||||
def __init__(self, cfg=DEFAULT_CFG, overrides: dict[str, Any] | None = None, _callbacks=None):
|
||||
"""
|
||||
Initialize a DetectionTrainer object for training YOLO object detection model training.
|
||||
|
||||
Args:
|
||||
cfg (dict, optional): Default configuration dictionary containing training parameters.
|
||||
overrides (dict, optional): Dictionary of parameter overrides for the default configuration.
|
||||
_callbacks (list, optional): List of callback functions to be executed during training.
|
||||
"""
|
||||
super().__init__(cfg, overrides, _callbacks)
|
||||
self.dynamic_tensors = ["batch_idx", "cls", "bboxes"]
|
||||
|
||||
def build_dataset(self, img_path: str, mode: str = "train", batch: int | None = None):
|
||||
"""
|
||||
Build YOLO Dataset for training or validation.
|
||||
@ -66,7 +78,7 @@ class DetectionTrainer(BaseTrainer):
|
||||
Returns:
|
||||
(Dataset): YOLO dataset object configured for the specified mode.
|
||||
"""
|
||||
gs = max(int(de_parallel(self.model).stride.max() if self.model else 0), 32)
|
||||
gs = max(int(unwrap_model(self.model).stride.max() if self.model else 0), 32)
|
||||
return build_yolo_dataset(self.args, img_path, batch, self.data, mode=mode, rect=mode == "val", stride=gs)
|
||||
|
||||
def get_dataloader(self, dataset_path: str, batch_size: int = 16, rank: int = 0, mode: str = "train"):
|
||||
@ -89,8 +101,14 @@ class DetectionTrainer(BaseTrainer):
|
||||
if getattr(dataset, "rect", False) and shuffle:
|
||||
LOGGER.warning("'rect=True' is incompatible with DataLoader shuffle, setting shuffle=False")
|
||||
shuffle = False
|
||||
workers = self.args.workers if mode == "train" else self.args.workers * 2
|
||||
return build_dataloader(dataset, batch_size, workers, shuffle, rank) # return dataloader
|
||||
return build_dataloader(
|
||||
dataset,
|
||||
batch=batch_size,
|
||||
workers=self.args.workers if mode == "train" else self.args.workers * 2,
|
||||
shuffle=shuffle,
|
||||
rank=rank,
|
||||
drop_last=self.args.compile and mode == "train",
|
||||
)
|
||||
|
||||
def preprocess_batch(self, batch: dict) -> dict:
|
||||
"""
|
||||
@ -120,6 +138,10 @@ class DetectionTrainer(BaseTrainer):
|
||||
] # new shape (stretched to gs-multiple)
|
||||
imgs = nn.functional.interpolate(imgs, size=ns, mode="bilinear", align_corners=False)
|
||||
batch["img"] = imgs
|
||||
|
||||
if self.args.compile:
|
||||
for k in self.dynamic_tensors:
|
||||
torch._dynamo.maybe_mark_dynamic(batch[k], 0)
|
||||
return batch
|
||||
|
||||
def set_model_attributes(self):
|
||||
|
||||
@ -299,7 +299,9 @@ class DetectionValidator(BaseValidator):
|
||||
(torch.utils.data.DataLoader): Dataloader for validation.
|
||||
"""
|
||||
dataset = self.build_dataset(dataset_path, batch=batch_size, mode="val")
|
||||
return build_dataloader(dataset, batch_size, self.args.workers, shuffle=False, rank=-1) # return dataloader
|
||||
return build_dataloader(
|
||||
dataset, batch_size, self.args.workers, shuffle=False, rank=-1, drop_last=self.args.compile
|
||||
)
|
||||
|
||||
def plot_val_samples(self, batch: dict[str, Any], ni: int) -> None:
|
||||
"""
|
||||
|
||||
@ -37,21 +37,12 @@ class OBBTrainer(yolo.detect.DetectionTrainer):
|
||||
"""
|
||||
Initialize an OBBTrainer object for training Oriented Bounding Box (OBB) models.
|
||||
|
||||
This trainer extends the DetectionTrainer class to specialize in training models that detect oriented
|
||||
bounding boxes. It automatically sets the task to 'obb' in the configuration.
|
||||
|
||||
Args:
|
||||
cfg (dict, optional): Configuration dictionary for the trainer. Contains training parameters and
|
||||
model configuration.
|
||||
overrides (dict, optional): Dictionary of parameter overrides for the configuration. Any values here
|
||||
will take precedence over those in cfg.
|
||||
_callbacks (list[Any], optional): List of callback functions to be invoked during training.
|
||||
|
||||
Examples:
|
||||
>>> from ultralytics.models.yolo.obb import OBBTrainer
|
||||
>>> args = dict(model="yolo11n-obb.pt", data="dota8.yaml", epochs=3)
|
||||
>>> trainer = OBBTrainer(overrides=args)
|
||||
>>> trainer.train()
|
||||
"""
|
||||
if overrides is None:
|
||||
overrides = {}
|
||||
|
||||
@ -44,9 +44,6 @@ class PoseTrainer(yolo.detect.DetectionTrainer):
|
||||
"""
|
||||
Initialize a PoseTrainer object for training YOLO pose estimation models.
|
||||
|
||||
This initializes a trainer specialized for pose estimation tasks, setting the task to 'pose' and
|
||||
handling specific configurations needed for keypoint detection models.
|
||||
|
||||
Args:
|
||||
cfg (dict, optional): Default configuration dictionary containing training parameters.
|
||||
overrides (dict, optional): Dictionary of parameter overrides for the default configuration.
|
||||
@ -55,17 +52,12 @@ class PoseTrainer(yolo.detect.DetectionTrainer):
|
||||
Notes:
|
||||
This trainer will automatically set the task to 'pose' regardless of what is provided in overrides.
|
||||
A warning is issued when using Apple MPS device due to known bugs with pose models.
|
||||
|
||||
Examples:
|
||||
>>> from ultralytics.models.yolo.pose import PoseTrainer
|
||||
>>> args = dict(model="yolo11n-pose.pt", data="coco8-pose.yaml", epochs=3)
|
||||
>>> trainer = PoseTrainer(overrides=args)
|
||||
>>> trainer.train()
|
||||
"""
|
||||
if overrides is None:
|
||||
overrides = {}
|
||||
overrides["task"] = "pose"
|
||||
super().__init__(cfg, overrides, _callbacks)
|
||||
self.dynamic_tensors = ["batch_idx", "cls", "bboxes", "keypoints"]
|
||||
|
||||
if isinstance(self.args.device, str) and self.args.device.lower() == "mps":
|
||||
LOGGER.warning(
|
||||
|
||||
@ -32,24 +32,16 @@ class SegmentationTrainer(yolo.detect.DetectionTrainer):
|
||||
"""
|
||||
Initialize a SegmentationTrainer object.
|
||||
|
||||
This initializes a trainer for segmentation tasks, extending the detection trainer with segmentation-specific
|
||||
functionality. It sets the task to 'segment' and prepares the trainer for training segmentation models.
|
||||
|
||||
Args:
|
||||
cfg (dict): Configuration dictionary with default training settings.
|
||||
overrides (dict, optional): Dictionary of parameter overrides for the default configuration.
|
||||
_callbacks (list, optional): List of callback functions to be executed during training.
|
||||
|
||||
Examples:
|
||||
>>> from ultralytics.models.yolo.segment import SegmentationTrainer
|
||||
>>> args = dict(model="yolo11n-seg.pt", data="coco8-seg.yaml", epochs=3)
|
||||
>>> trainer = SegmentationTrainer(overrides=args)
|
||||
>>> trainer.train()
|
||||
"""
|
||||
if overrides is None:
|
||||
overrides = {}
|
||||
overrides["task"] = "segment"
|
||||
super().__init__(cfg, overrides, _callbacks)
|
||||
self.dynamic_tensors = ["batch_idx", "cls", "bboxes", "masks"]
|
||||
|
||||
def get_model(self, cfg: dict | str | None = None, weights: str | Path | None = None, verbose: bool = True):
|
||||
"""
|
||||
|
||||
@ -12,7 +12,7 @@ from ultralytics.data import build_yolo_dataset
|
||||
from ultralytics.models.yolo.detect import DetectionTrainer
|
||||
from ultralytics.nn.tasks import WorldModel
|
||||
from ultralytics.utils import DEFAULT_CFG, LOGGER, RANK
|
||||
from ultralytics.utils.torch_utils import de_parallel
|
||||
from ultralytics.utils.torch_utils import unwrap_model
|
||||
|
||||
|
||||
def on_pretrain_routine_end(trainer) -> None:
|
||||
@ -20,7 +20,7 @@ def on_pretrain_routine_end(trainer) -> None:
|
||||
if RANK in {-1, 0}:
|
||||
# Set class names for evaluation
|
||||
names = [name.split("/", 1)[0] for name in list(trainer.test_loader.dataset.data["names"].values())]
|
||||
de_parallel(trainer.ema.ema).set_classes(names, cache_clip_model=False)
|
||||
unwrap_model(trainer.ema.ema).set_classes(names, cache_clip_model=False)
|
||||
|
||||
|
||||
class WorldTrainer(DetectionTrainer):
|
||||
@ -105,7 +105,7 @@ class WorldTrainer(DetectionTrainer):
|
||||
Returns:
|
||||
(Any): YOLO dataset configured for training or validation.
|
||||
"""
|
||||
gs = max(int(de_parallel(self.model).stride.max() if self.model else 0), 32)
|
||||
gs = max(int(unwrap_model(self.model).stride.max() if self.model else 0), 32)
|
||||
dataset = build_yolo_dataset(
|
||||
self.args, img_path, batch, self.data, mode=mode, rect=mode == "val", stride=gs, multi_modal=mode == "train"
|
||||
)
|
||||
@ -160,7 +160,7 @@ class WorldTrainer(DetectionTrainer):
|
||||
return txt_map
|
||||
LOGGER.info(f"Caching text embeddings to '{cache_path}'")
|
||||
assert self.model is not None
|
||||
txt_feats = de_parallel(self.model).get_text_pe(texts, batch, cache_clip_model=False)
|
||||
txt_feats = unwrap_model(self.model).get_text_pe(texts, batch, cache_clip_model=False)
|
||||
txt_map = dict(zip(texts, txt_feats.squeeze(0)))
|
||||
torch.save(txt_map, cache_path)
|
||||
return txt_map
|
||||
|
||||
@ -6,7 +6,7 @@ from ultralytics.data import YOLOConcatDataset, build_grounding, build_yolo_data
|
||||
from ultralytics.data.utils import check_det_dataset
|
||||
from ultralytics.models.yolo.world import WorldTrainer
|
||||
from ultralytics.utils import DATASETS_DIR, DEFAULT_CFG, LOGGER
|
||||
from ultralytics.utils.torch_utils import de_parallel
|
||||
from ultralytics.utils.torch_utils import unwrap_model
|
||||
|
||||
|
||||
class WorldTrainerFromScratch(WorldTrainer):
|
||||
@ -101,7 +101,7 @@ class WorldTrainerFromScratch(WorldTrainer):
|
||||
Returns:
|
||||
(YOLOConcatDataset | Dataset): The constructed dataset for training or validation.
|
||||
"""
|
||||
gs = max(int(de_parallel(self.model).stride.max() if self.model else 0), 32)
|
||||
gs = max(int(unwrap_model(self.model).stride.max() if self.model else 0), 32)
|
||||
if mode != "train":
|
||||
return build_yolo_dataset(self.args, img_path, batch, self.data, mode=mode, rect=False, stride=gs)
|
||||
datasets = [
|
||||
|
||||
@ -13,7 +13,7 @@ from ultralytics.data.augment import LoadVisualPrompt
|
||||
from ultralytics.models.yolo.detect import DetectionTrainer, DetectionValidator
|
||||
from ultralytics.nn.tasks import YOLOEModel
|
||||
from ultralytics.utils import DEFAULT_CFG, LOGGER, RANK
|
||||
from ultralytics.utils.torch_utils import de_parallel
|
||||
from ultralytics.utils.torch_utils import unwrap_model
|
||||
|
||||
from ..world.train_world import WorldTrainerFromScratch
|
||||
from .val import YOLOEDetectValidator
|
||||
@ -39,9 +39,6 @@ class YOLOETrainer(DetectionTrainer):
|
||||
"""
|
||||
Initialize the YOLOE Trainer with specified configurations.
|
||||
|
||||
This method sets up the YOLOE trainer with the provided configuration and overrides, initializing
|
||||
the training environment, model, and callbacks for YOLOE object detection training.
|
||||
|
||||
Args:
|
||||
cfg (dict): Configuration dictionary with default training settings from DEFAULT_CFG.
|
||||
overrides (dict, optional): Dictionary of parameter overrides for the default configuration.
|
||||
@ -102,7 +99,7 @@ class YOLOETrainer(DetectionTrainer):
|
||||
Returns:
|
||||
(Dataset): YOLO dataset configured for training or validation.
|
||||
"""
|
||||
gs = max(int(de_parallel(self.model).stride.max() if self.model else 0), 32)
|
||||
gs = max(int(unwrap_model(self.model).stride.max() if self.model else 0), 32)
|
||||
return build_yolo_dataset(
|
||||
self.args, img_path, batch, self.data, mode=mode, rect=mode == "val", stride=gs, multi_modal=mode == "train"
|
||||
)
|
||||
@ -223,7 +220,7 @@ class YOLOETrainerFromScratch(YOLOETrainer, WorldTrainerFromScratch):
|
||||
return txt_map
|
||||
LOGGER.info(f"Caching text embeddings to '{cache_path}'")
|
||||
assert self.model is not None
|
||||
txt_feats = de_parallel(self.model).get_text_pe(texts, batch, without_reprta=True, cache_clip_model=False)
|
||||
txt_feats = unwrap_model(self.model).get_text_pe(texts, batch, without_reprta=True, cache_clip_model=False)
|
||||
txt_map = dict(zip(texts, txt_feats.squeeze(0)))
|
||||
torch.save(txt_map, cache_path)
|
||||
return txt_map
|
||||
|
||||
@ -13,7 +13,7 @@ from torch.nn.init import constant_, xavier_uniform_
|
||||
|
||||
from ultralytics.utils import NOT_MACOS14
|
||||
from ultralytics.utils.tal import TORCH_1_10, dist2bbox, dist2rbox, make_anchors
|
||||
from ultralytics.utils.torch_utils import fuse_conv_and_bn, smart_inference_mode
|
||||
from ultralytics.utils.torch_utils import disable_dynamo, fuse_conv_and_bn, smart_inference_mode
|
||||
|
||||
from .block import DFL, SAVPE, BNContrastiveHead, ContrastiveHead, Proto, Residual, SwiGLUFFN
|
||||
from .conv import Conv, DWConv
|
||||
@ -149,6 +149,7 @@ class Detect(nn.Module):
|
||||
y = self.postprocess(y.permute(0, 2, 1), self.max_det, self.nc)
|
||||
return y if self.export else (y, {"one2many": x, "one2one": one2one})
|
||||
|
||||
@disable_dynamo
|
||||
def _inference(self, x: list[torch.Tensor]) -> torch.Tensor:
|
||||
"""
|
||||
Decode predicted bounding boxes and class probabilities based on multiple-level feature maps.
|
||||
|
||||
@ -334,7 +334,8 @@ class BaseModel(torch.nn.Module):
|
||||
if getattr(self, "criterion", None) is None:
|
||||
self.criterion = self.init_criterion()
|
||||
|
||||
preds = self.forward(batch["img"]) if preds is None else preds
|
||||
if preds is None:
|
||||
preds = self.forward(batch["img"])
|
||||
return self.criterion(preds, batch)
|
||||
|
||||
def init_criterion(self):
|
||||
@ -775,7 +776,8 @@ class RTDETRDetectionModel(DetectionModel):
|
||||
"gt_groups": gt_groups,
|
||||
}
|
||||
|
||||
preds = self.predict(img, batch=targets) if preds is None else preds
|
||||
if preds is None:
|
||||
preds = self.predict(img, batch=targets)
|
||||
dec_bboxes, dec_scores, enc_bboxes, enc_scores, dn_meta = preds if self.training else preds[1]
|
||||
if dn_meta is None:
|
||||
dn_bboxes, dn_scores = None, None
|
||||
|
||||
@ -70,14 +70,14 @@ def _log_tensorboard_graph(trainer) -> None:
|
||||
# Try simple method first (YOLO)
|
||||
try:
|
||||
trainer.model.eval() # place in .eval() mode to avoid BatchNorm statistics changes
|
||||
WRITER.add_graph(torch.jit.trace(torch_utils.de_parallel(trainer.model), im, strict=False), [])
|
||||
WRITER.add_graph(torch.jit.trace(torch_utils.unwrap_model(trainer.model), im, strict=False), [])
|
||||
LOGGER.info(f"{PREFIX}model graph visualization added ✅")
|
||||
return
|
||||
|
||||
except Exception:
|
||||
# Fallback to TorchScript export steps (RTDETR)
|
||||
try:
|
||||
model = deepcopy(torch_utils.de_parallel(trainer.model))
|
||||
model = deepcopy(torch_utils.unwrap_model(trainer.model))
|
||||
model.eval()
|
||||
model = model.fuse(verbose=False)
|
||||
for m in model.modules():
|
||||
|
||||
@ -11,7 +11,7 @@ import torch.nn.functional as F
|
||||
from ultralytics.utils.metrics import OKS_SIGMA
|
||||
from ultralytics.utils.ops import crop_mask, xywh2xyxy, xyxy2xywh
|
||||
from ultralytics.utils.tal import RotatedTaskAlignedAssigner, TaskAlignedAssigner, dist2bbox, dist2rbox, make_anchors
|
||||
from ultralytics.utils.torch_utils import autocast
|
||||
from ultralytics.utils.torch_utils import autocast, disable_dynamo
|
||||
|
||||
from .metrics import bbox_iou, probiou
|
||||
from .tal import bbox2dist
|
||||
@ -215,6 +215,7 @@ class v8DetectionLoss:
|
||||
self.assigner = TaskAlignedAssigner(topk=tal_topk, num_classes=self.nc, alpha=0.5, beta=6.0)
|
||||
self.bbox_loss = BboxLoss(m.reg_max).to(device)
|
||||
self.proj = torch.arange(m.reg_max, dtype=torch.float, device=device)
|
||||
disable_dynamo(self.__class__) # exclude from compile
|
||||
|
||||
def preprocess(self, targets: torch.Tensor, batch_size: int, scale_tensor: torch.Tensor) -> torch.Tensor:
|
||||
"""Preprocess targets by converting to tensor format and scaling coordinates."""
|
||||
@ -287,9 +288,14 @@ class v8DetectionLoss:
|
||||
|
||||
# Bbox loss
|
||||
if fg_mask.sum():
|
||||
target_bboxes /= stride_tensor
|
||||
loss[0], loss[2] = self.bbox_loss(
|
||||
pred_distri, pred_bboxes, anchor_points, target_bboxes, target_scores, target_scores_sum, fg_mask
|
||||
pred_distri,
|
||||
pred_bboxes,
|
||||
anchor_points,
|
||||
target_bboxes / stride_tensor,
|
||||
target_scores,
|
||||
target_scores_sum,
|
||||
fg_mask,
|
||||
)
|
||||
|
||||
loss[0] *= self.hyp.box # box gain
|
||||
@ -388,7 +394,7 @@ class v8SegmentationLoss(v8DetectionLoss):
|
||||
loss[2] *= self.hyp.cls # cls gain
|
||||
loss[3] *= self.hyp.dfl # dfl gain
|
||||
|
||||
return loss * batch_size, loss.detach() # loss(box, cls, dfl)
|
||||
return loss * batch_size, loss.detach() # loss(box, seg, cls, dfl)
|
||||
|
||||
@staticmethod
|
||||
def single_mask_loss(
|
||||
|
||||
@ -429,7 +429,7 @@ def get_flops(model, imgsz=640):
|
||||
return 0.0 # if not installed return 0.0 GFLOPs
|
||||
|
||||
try:
|
||||
model = de_parallel(model)
|
||||
model = unwrap_model(model)
|
||||
p = next(model.parameters())
|
||||
if not isinstance(imgsz, list):
|
||||
imgsz = [imgsz, imgsz] # expand if int/float
|
||||
@ -460,7 +460,7 @@ def get_flops_with_torch_profiler(model, imgsz=640):
|
||||
"""
|
||||
if not TORCH_2_0: # torch profiler implemented in torch>=2.0
|
||||
return 0.0
|
||||
model = de_parallel(model)
|
||||
model = unwrap_model(model)
|
||||
p = next(model.parameters())
|
||||
if not isinstance(imgsz, list):
|
||||
imgsz = [imgsz, imgsz] # expand if int/float
|
||||
@ -577,17 +577,24 @@ def is_parallel(model):
|
||||
return isinstance(model, (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel))
|
||||
|
||||
|
||||
def de_parallel(model):
|
||||
def unwrap_model(m: nn.Module) -> nn.Module:
|
||||
"""
|
||||
De-parallelize a model: return single-GPU model if model is of type DP or DDP.
|
||||
Unwrap compiled and parallel models to get the base model.
|
||||
|
||||
Args:
|
||||
model (nn.Module): Model to de-parallelize.
|
||||
m (nn.Module): A model that may be wrapped by torch.compile (._orig_mod) or parallel wrappers such as
|
||||
DataParallel/DistributedDataParallel (.module).
|
||||
|
||||
Returns:
|
||||
(nn.Module): De-parallelized model.
|
||||
m (nn.Module): The unwrapped base model without compile or parallel wrappers.
|
||||
"""
|
||||
return model.module if is_parallel(model) else model
|
||||
while True:
|
||||
if hasattr(m, "_orig_mod") and isinstance(m._orig_mod, nn.Module):
|
||||
m = m._orig_mod
|
||||
elif hasattr(m, "module") and isinstance(m.module, nn.Module):
|
||||
m = m.module
|
||||
else:
|
||||
return m
|
||||
|
||||
|
||||
def one_cycle(y1=0.0, y2=1.0, steps=100):
|
||||
@ -669,7 +676,7 @@ class ModelEMA:
|
||||
tau (int, optional): EMA decay time constant.
|
||||
updates (int, optional): Initial number of updates.
|
||||
"""
|
||||
self.ema = deepcopy(de_parallel(model)).eval() # FP32 EMA
|
||||
self.ema = deepcopy(unwrap_model(model)).eval() # FP32 EMA
|
||||
self.updates = updates # number of EMA updates
|
||||
self.decay = lambda x: decay * (1 - math.exp(-x / tau)) # decay exponential ramp (to help early epochs)
|
||||
for p in self.ema.parameters():
|
||||
@ -687,7 +694,7 @@ class ModelEMA:
|
||||
self.updates += 1
|
||||
d = self.decay(self.updates)
|
||||
|
||||
msd = de_parallel(model).state_dict() # model state_dict
|
||||
msd = unwrap_model(model).state_dict() # model state_dict
|
||||
for k, v in self.ema.state_dict().items():
|
||||
if v.dtype.is_floating_point: # true for FP16 and FP32
|
||||
v *= d
|
||||
@ -997,3 +1004,98 @@ class FXModel(nn.Module):
|
||||
x = m(x) # run
|
||||
y.append(x) # save output
|
||||
return x
|
||||
|
||||
|
||||
def disable_dynamo(func: Any) -> Any:
|
||||
"""
|
||||
Disable torch.compile/dynamo for a callable when available.
|
||||
|
||||
Args:
|
||||
func (Any): Callable object to wrap. Could be a function, method, or class.
|
||||
|
||||
Returns:
|
||||
func (Any): Same callable, wrapped by torch._dynamo.disable when available, otherwise unchanged.
|
||||
|
||||
Examples:
|
||||
>>> @disable_dynamo
|
||||
... def fn(x):
|
||||
... return x + 1
|
||||
>>> # Works even if torch._dynamo is not available
|
||||
>>> _ = fn(1)
|
||||
"""
|
||||
if hasattr(torch, "_dynamo"):
|
||||
return torch._dynamo.disable(func)
|
||||
return func
|
||||
|
||||
|
||||
def attempt_compile(
|
||||
model: torch.nn.Module,
|
||||
device: torch.device,
|
||||
imgsz: int = 640,
|
||||
use_autocast: bool = False,
|
||||
warmup: bool = False,
|
||||
prefix: str = colorstr("compile:"),
|
||||
) -> torch.nn.Module:
|
||||
"""
|
||||
Compile a model with torch.compile and optionally warm up the graph to reduce first-iteration latency.
|
||||
|
||||
This utility attempts to compile the provided model using the inductor backend with dynamic shapes enabled and an
|
||||
autotuning mode. If compilation is unavailable or fails, the original model is returned unchanged. An optional
|
||||
warmup performs a single forward pass on a dummy input to prime the compiled graph and measure compile/warmup time.
|
||||
|
||||
Args:
|
||||
model (torch.nn.Module): Model to compile.
|
||||
device (torch.device): Inference device used for warmup and autocast decisions.
|
||||
imgsz (int, optional): Square input size to create a dummy tensor with shape (1, 3, imgsz, imgsz) for warmup.
|
||||
use_autocast (bool, optional): Whether to run warmup under autocast on CUDA or MPS devices.
|
||||
warmup (bool, optional): Whether to execute a single dummy forward pass to warm up the compiled model.
|
||||
prefix (str, optional): Message prefix for logger output.
|
||||
|
||||
Returns:
|
||||
model (torch.nn.Module): Compiled model if compilation succeeds, otherwise the original unmodified model.
|
||||
|
||||
Notes:
|
||||
- If the current PyTorch build does not provide torch.compile, the function returns the input model immediately.
|
||||
- Warmup runs under torch.inference_mode and may use torch.autocast for CUDA/MPS to align compute precision.
|
||||
- CUDA devices are synchronized after warmup to account for asynchronous kernel execution.
|
||||
|
||||
Examples:
|
||||
>>> device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
|
||||
>>> # Try to compile and warm up a model with a 640x640 input
|
||||
>>> model = attempt_compile(model, device=device, imgsz=640, use_autocast=True, warmup=True)
|
||||
"""
|
||||
if not hasattr(torch, "compile"):
|
||||
return model
|
||||
|
||||
LOGGER.info(f"{prefix} starting torch.compile...")
|
||||
t0 = time.perf_counter()
|
||||
try:
|
||||
model = torch.compile(model, mode="max-autotune", backend="inductor")
|
||||
except Exception as e:
|
||||
LOGGER.warning(f"{prefix} torch.compile failed, continuing uncompiled: {e}")
|
||||
return model
|
||||
t_compile = time.perf_counter() - t0
|
||||
|
||||
t_warm = 0.0
|
||||
if warmup:
|
||||
# Use a single dummy tensor to build the graph shape state and reduce first-iteration latency
|
||||
dummy = torch.zeros(1, 3, imgsz, imgsz, device=device)
|
||||
if use_autocast and device.type == "cuda":
|
||||
dummy = dummy.half()
|
||||
t1 = time.perf_counter()
|
||||
with torch.inference_mode():
|
||||
if use_autocast and device.type in {"cuda", "mps"}:
|
||||
with torch.autocast(device.type):
|
||||
_ = model(dummy)
|
||||
else:
|
||||
_ = model(dummy)
|
||||
if device.type == "cuda":
|
||||
torch.cuda.synchronize(device)
|
||||
t_warm = time.perf_counter() - t1
|
||||
|
||||
total = t_compile + t_warm
|
||||
if warmup:
|
||||
LOGGER.info(f"{prefix} complete in {total:.1f}s (compile {t_compile:.1f}s + warmup {t_warm:.1f}s)")
|
||||
else:
|
||||
LOGGER.info(f"{prefix} compile complete in {t_compile:.1f}s (no warmup)")
|
||||
return model
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user