ultralytics 8.3.100__py3-none-any.whl → 8.3.102__py3-none-any.whl

ultralytics/utils/callbacks/base.py

@@ -176,21 +176,38 @@ default_callbacks = {
 
 def get_default_callbacks():
     """
-    Return a copy of the default_callbacks dictionary with lists as default values.
+    Get the default callbacks for Ultralytics training, validation, prediction, and export processes.
 
     Returns:
-        (defaultdict): A defaultdict with keys from default_callbacks and empty lists as default values.
+        (dict): Dictionary of default callbacks for various training events. Each key in the dictionary represents an
+            event during the training process, and the corresponding value is a list of callback functions that are
+            executed when that event occurs.
+
+    Examples:
+        >>> callbacks = get_default_callbacks()
+        >>> print(list(callbacks.keys()))  # show all available callback events
+        ['on_pretrain_routine_start', 'on_pretrain_routine_end', ...]
     """
     return defaultdict(list, deepcopy(default_callbacks))
 
 
 def add_integration_callbacks(instance):
     """
-    Add integration callbacks from various sources to the instance's callbacks.
+    Add integration callbacks to the instance's callbacks dictionary.
+
+    This function loads and adds various integration callbacks to the provided instance. The specific callbacks added
+    depend on the type of instance provided. All instances receive HUB callbacks, while Trainer instances also receive
+    additional callbacks for various integrations like ClearML, Comet, DVC, MLflow, Neptune, Ray Tune, TensorBoard,
+    and Weights & Biases.
 
     Args:
-        instance (Trainer | Predictor | Validator | Exporter): An object with a 'callbacks' attribute that is a
-            dictionary of callback lists.
+        instance (Trainer | Predictor | Validator | Exporter): The object instance to which callbacks will be added.
+            The type of instance determines which callbacks are loaded.
+
+    Examples:
+        >>> from ultralytics.engine.trainer import BaseTrainer
+        >>> trainer = BaseTrainer()
+        >>> add_integration_callbacks(trainer)
     """
     # Load HUB callbacks
     from .hub import callbacks as hub_cb

ultralytics/utils/callbacks/comet.py

@@ -155,7 +155,32 @@ def _scale_bounding_box_to_original_image_shape(
 
 
 def _format_ground_truth_annotations_for_detection(img_idx, image_path, batch, class_name_map=None) -> Optional[dict]:
-    """Format ground truth annotations for detection."""
+    """
+    Format ground truth annotations for object detection.
+
+    This function processes ground truth annotations from a batch of images for object detection tasks. It extracts
+    bounding boxes, class labels, and other metadata for a specific image in the batch, and formats them for
+    visualization or evaluation.
+
+    Args:
+        img_idx (int): Index of the image in the batch to process.
+        image_path (str | Path): Path to the image file.
+        batch (dict): Batch dictionary containing detection data with keys:
+            - 'batch_idx': Tensor of batch indices
+            - 'bboxes': Tensor of bounding boxes in normalized xywh format
+            - 'cls': Tensor of class labels
+            - 'ori_shape': Original image shapes
+            - 'resized_shape': Resized image shapes
+            - 'ratio_pad': Ratio and padding information
+        class_name_map (dict | None, optional): Mapping from class indices to class names.
+
+    Returns:
+        (dict | None): Formatted ground truth annotations with the following structure:
+            - 'boxes': List of box coordinates [x, y, width, height]
+            - 'label': Label string with format "gt_{class_name}"
+            - 'score': Confidence score (always 1.0, scaled by _scale_confidence_score)
+            Returns None if no bounding boxes are found for the image.
+    """
     indices = batch["batch_idx"] == img_idx
     bboxes = batch["bboxes"][indices]
     if len(bboxes) == 0:
@@ -284,7 +309,22 @@ def _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch) -> None:
 
 
 def _log_images(experiment, image_paths, curr_step, annotations=None) -> None:
-    """Logs images to the experiment with optional annotations."""
+    """
+    Log images to the experiment with optional annotations.
+
+    This function logs images to a Comet ML experiment, optionally including annotation data for visualization
+    such as bounding boxes or segmentation masks.
+
+    Args:
+        experiment (comet_ml.Experiment): The Comet ML experiment to log images to.
+        image_paths (List[Path]): List of paths to images that will be logged.
+        curr_step (int): Current training step/iteration for tracking in the experiment timeline.
+        annotations (List[List[dict]], optional): Nested list of annotation dictionaries for each image. Each annotation
+            contains visualization data like bounding boxes, labels, and confidence scores.
+
+    Returns:
+        None
+    """
     if annotations:
         for image_path, annotation in zip(image_paths, annotations):
             experiment.log_image(image_path, name=image_path.stem, step=curr_step, annotations=annotation)
@@ -295,7 +335,23 @@ def _log_images(experiment, image_paths, curr_step, annotations=None) -> None:
 
 
 def _log_image_predictions(experiment, validator, curr_step) -> None:
-    """Logs predicted boxes for a single image during training."""
+    """
+    Log predicted boxes for a single image during training.
+
+    This function logs image predictions to a Comet ML experiment during model validation. It processes
+    validation data and formats both ground truth and prediction annotations for visualization in the Comet
+    dashboard. The function respects configured limits on the number of images to log.
+
+    Args:
+        experiment (comet_ml.Experiment): The Comet ML experiment to log to.
+        validator (BaseValidator): The validator instance containing validation data and predictions.
+        curr_step (int): The current training step for logging timeline.
+
+    Notes:
+        This function uses global state to track the number of logged predictions across calls.
+        It only logs predictions for supported tasks defined in COMET_SUPPORTED_TASKS.
+        The number of logged images is limited by the COMET_MAX_IMAGE_PREDICTIONS environment variable.
+    """
     global _comet_image_prediction_count
 
     task = validator.args.task
@@ -342,7 +398,22 @@ def _log_image_predictions(experiment, validator, curr_step) -> None:
 
 
 def _log_plots(experiment, trainer) -> None:
-    """Logs evaluation plots and label plots for the experiment."""
+    """
+    Log evaluation plots and label plots for the experiment.
+
+    This function logs various evaluation plots and confusion matrices to the experiment tracking system. It handles
+    different types of metrics (SegmentMetrics, PoseMetrics, DetMetrics, OBBMetrics) and logs the appropriate plots
+    for each type.
+
+    Args:
+        experiment (comet_ml.Experiment): The Comet ML experiment to log plots to.
+        trainer (ultralytics.engine.trainer.BaseTrainer): The trainer object containing validation metrics and save
+            directory information.
+
+    Examples:
+        >>> from ultralytics.utils.callbacks.comet import _log_plots
+        >>> _log_plots(experiment, trainer)
+    """
     plot_filenames = None
     if isinstance(trainer.validator.metrics, SegmentMetrics) and trainer.validator.metrics.task == "segment":
         plot_filenames = [
@@ -401,7 +472,24 @@ def on_train_epoch_end(trainer) -> None:
 
 
 def on_fit_epoch_end(trainer) -> None:
-    """Logs model assets at the end of each epoch."""
+    """
+    Log model assets at the end of each epoch during training.
+
+    This function is called at the end of each training epoch to log metrics, learning rates, and model information
+    to a Comet ML experiment. It also logs model assets, confusion matrices, and image predictions based on
+    configuration settings.
+
+    The function retrieves the current Comet ML experiment and logs various training metrics. If it's the first epoch,
+    it also logs model information. On specified save intervals, it logs the model, confusion matrix (if enabled),
+    and image predictions (if enabled).
+
+    Args:
+        trainer (BaseTrainer): The YOLO trainer object containing training state, metrics, and configuration.
+
+    Examples:
+        >>> # Inside a training loop
+        >>> on_fit_epoch_end(trainer)  # Log metrics and assets to Comet ML
+    """
     experiment = comet_ml.get_running_experiment()
     if not experiment:
         return

ultralytics/utils/callbacks/dvc.py

@@ -27,7 +27,21 @@ except (ImportError, AssertionError, TypeError):
 
 
 def _log_images(path: Path, prefix: str = "") -> None:
-    """Logs images at specified path with an optional prefix using DVCLive."""
+    """
+    Log images at specified path with an optional prefix using DVCLive.
+
+    This function logs images found at the given path to DVCLive, organizing them by batch to enable slider
+    functionality in the UI. It processes image filenames to extract batch information and restructures the path
+    accordingly.
+
+    Args:
+        path (Path): Path to the image file to be logged.
+        prefix (str): Optional prefix to add to the image name when logging.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> _log_images(Path("runs/train/exp/val_batch0_pred.jpg"), prefix="validation")
+    """
     if live:
         name = path.name
 
@@ -41,7 +55,13 @@ def _log_images(path: Path, prefix: str = "") -> None:
 
 
 def _log_plots(plots: dict, prefix: str = "") -> None:
-    """Logs plot images for training progress if they have not been previously processed."""
+    """
+    Log plot images for training progress if they have not been previously processed.
+
+    Args:
+        plots (dict): Dictionary containing plot information with timestamps.
+        prefix (str, optional): Optional prefix to add to the logged image paths.
+    """
     for name, params in plots.items():
         timestamp = params["timestamp"]
         if _processed_plots.get(name) != timestamp:
@@ -50,7 +70,19 @@ def _log_plots(plots: dict, prefix: str = "") -> None:
 
 
 def _log_confusion_matrix(validator) -> None:
-    """Logs the confusion matrix for the given validator using DVCLive."""
+    """
+    Log confusion matrix for a validator using DVCLive.
+
+    This function processes the confusion matrix from a validator object and logs it to DVCLive by converting
+    the matrix into lists of target and prediction labels.
+
+    Args:
+        validator (BaseValidator): The validator object containing the confusion matrix and class names.
+            Must have attributes: confusion_matrix.matrix, confusion_matrix.task, and names.
+
+    Returns:
+        None
+    """
     targets = []
     preds = []
     matrix = validator.confusion_matrix.matrix
@@ -94,7 +126,20 @@ def on_train_epoch_start(trainer) -> None:
 
 
 def on_fit_epoch_end(trainer) -> None:
-    """Logs training metrics and model info, and advances to next step on the end of each fit epoch."""
+    """
+    Log training metrics, model info, and advance to next step at the end of each fit epoch.
+
+    This function is called at the end of each fit epoch during training. It logs various metrics including
+    training loss items, validation metrics, and learning rates. On the first epoch, it also logs model
+    information. Additionally, it logs training and validation plots and advances the DVCLive step counter.
+
+    Args:
+        trainer (BaseTrainer): The trainer object containing training state, metrics, and plots.
+
+    Notes:
+        This function only performs logging operations when DVCLive logging is active and during a training epoch.
+        The global variable _training_epoch is used to track whether the current epoch is a training epoch.
+    """
     global _training_epoch
     if live and _training_epoch:
         all_metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics, **trainer.lr}
@@ -115,7 +160,21 @@ def on_fit_epoch_end(trainer) -> None:
 
 
 def on_train_end(trainer) -> None:
-    """Logs the best metrics, plots, and confusion matrix at the end of training if DVCLive is active."""
+    """
+    Log best metrics, plots, and confusion matrix at the end of training.
+
+    This function is called at the conclusion of the training process to log final metrics, visualizations, and
+    model artifacts if DVCLive logging is active. It captures the best model performance metrics, training plots,
+    validation plots, and confusion matrix for later analysis.
+
+    Args:
+        trainer (BaseTrainer): The trainer object containing training state, metrics, and validation results.
+
+    Examples:
+        >>> # Inside a custom training loop
+        >>> from ultralytics.utils.callbacks.dvc import on_train_end
+        >>> on_train_end(trainer)  # Log final metrics and artifacts
+    """
     if live:
         # At the end log the best metrics. It runs validator on the best model internally.
         all_metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics, **trainer.lr}

ultralytics/utils/callbacks/neptune.py

@@ -19,14 +19,37 @@ except (ImportError, AssertionError):
 
 
 def _log_scalars(scalars: dict, step: int = 0) -> None:
-    """Log scalars to the NeptuneAI experiment logger."""
+    """
+    Log scalars to the NeptuneAI experiment logger.
+
+    Args:
+        scalars (dict): Dictionary of scalar values to log to NeptuneAI.
+        step (int): The current step or iteration number for logging.
+
+    Examples:
+        >>> metrics = {"mAP": 0.85, "loss": 0.32}
+        >>> _log_scalars(metrics, step=100)
+    """
     if run:
         for k, v in scalars.items():
             run[k].append(value=v, step=step)
 
 
 def _log_images(imgs_dict: dict, group: str = "") -> None:
-    """Log images to the NeptuneAI experiment logger."""
+    """
+    Log images to the NeptuneAI experiment logger.
+
+    This function logs image data to Neptune.ai when a valid Neptune run is active. Images are organized
+    under the specified group name.
+
+    Args:
+        imgs_dict (dict): Dictionary of images to log, with keys as image names and values as image data.
+        group (str, optional): Group name to organize images under in the Neptune UI.
+
+    Examples:
+        >>> # Log validation images
+        >>> _log_images({"val_batch": img_tensor}, group="validation")
+    """
     if run:
         for k, v in imgs_dict.items():
             run[f"{group}/{k}"].upload(File(v))

ultralytics/utils/callbacks/tensorboard.py

@@ -24,14 +24,42 @@ except (ImportError, AssertionError, TypeError, AttributeError):
 
 
 def _log_scalars(scalars: dict, step: int = 0) -> None:
-    """Logs scalar values to TensorBoard."""
+    """
+    Log scalar values to TensorBoard.
+
+    Args:
+        scalars (dict): Dictionary of scalar values to log to TensorBoard. Keys are scalar names and values are the
+            corresponding scalar values.
+        step (int): Global step value to record with the scalar values. Used for x-axis in TensorBoard graphs.
+
+    Examples:
+        >>> # Log training metrics
+        >>> metrics = {"loss": 0.5, "accuracy": 0.95}
+        >>> _log_scalars(metrics, step=100)
+    """
     if WRITER:
         for k, v in scalars.items():
             WRITER.add_scalar(k, v, step)
 
 
 def _log_tensorboard_graph(trainer) -> None:
-    """Log model graph to TensorBoard."""
+    """
+    Log model graph to TensorBoard.
+
+    This function attempts to visualize the model architecture in TensorBoard by tracing the model with a dummy input
+    tensor. It first tries a simple method suitable for YOLO models, and if that fails, falls back to a more complex
+    approach for models like RTDETR that may require special handling.
+
+    Args:
+        trainer (BaseTrainer): The trainer object containing the model to visualize. Must have attributes:
+            - model: PyTorch model to visualize
+            - args: Configuration arguments with 'imgsz' attribute
+
+    Notes:
+        This function requires TensorBoard integration to be enabled and the global WRITER to be initialized.
+        It handles potential warnings from the PyTorch JIT tracer and attempts to gracefully handle different
+        model architectures.
+    """
     # Input image
     imgsz = trainer.args.imgsz
     imgsz = (imgsz, imgsz) if isinstance(imgsz, int) else imgsz

ultralytics/utils/callbacks/wb.py

@@ -99,7 +99,22 @@ def _plot_curve(
 
 
 def _log_plots(plots, step):
-    """Logs plots from the input dictionary if they haven't been logged already at the specified step."""
+    """
+    Log plots to WandB at a specific step if they haven't been logged already.
+
+    This function checks each plot in the input dictionary against previously processed plots and logs
+    new or updated plots to WandB at the specified step.
+
+    Args:
+        plots (dict): Dictionary of plots to log, where keys are plot names and values are dictionaries
+            containing plot metadata including timestamps.
+        step (int): The step/epoch at which to log the plots in the WandB run.
+
+    Notes:
+        - The function uses a shallow copy of the plots dictionary to prevent modification during iteration
+        - Plots are identified by their stem name (filename without extension)
+        - Each plot is logged as a WandB Image object
+    """
     for name, params in plots.copy().items():  # shallow copy to prevent plots dict changing during iteration
         timestamp = params["timestamp"]
         if _processed_plots.get(name) != timestamp:

ultralytics/utils/dist.py

@@ -26,7 +26,26 @@ def find_free_network_port() -> int:
 
 
 def generate_ddp_file(trainer):
-    """Generates a DDP file and returns its file name."""
+    """
+    Generate a DDP (Distributed Data Parallel) file for multi-GPU training.
+
+    This function creates a temporary Python file that enables distributed training across multiple GPUs.
+    The file contains the necessary configuration to initialize the trainer in a distributed environment.
+
+    Args:
+        trainer (object): The trainer object containing training configuration and arguments.
+                         Must have args attribute and be a class instance.
+
+    Returns:
+        (str): Path to the generated temporary DDP file.
+
+    Notes:
+        The generated file is saved in the USER_CONFIG_DIR/DDP directory and includes:
+        - Trainer class import
+        - Configuration overrides from the trainer arguments
+        - Model path configuration
+        - Training initialization code
+    """
     module, name = f"{trainer.__class__.__module__}.{trainer.__class__.__name__}".rsplit(".", 1)
 
     content = f"""
@@ -80,6 +99,20 @@ def generate_ddp_command(world_size, trainer):
 
 
 def ddp_cleanup(trainer, file):
-    """Delete temp file if created."""
+    """
+    Delete temporary file if created during distributed data parallel (DDP) training.
+
+    This function checks if the provided file contains the trainer's ID in its name, indicating it was created
+    as a temporary file for DDP training, and deletes it if so.
+
+    Args:
+        trainer (object): The trainer object used for distributed training.
+        file (str): Path to the file that might need to be deleted.
+
+    Examples:
+        >>> trainer = YOLOTrainer()
+        >>> file = "/tmp/ddp_temp_123456789.py"
+        >>> ddp_cleanup(trainer, file)
+    """
     if f"{id(trainer)}.py" in file:  # if temp_file suffix in file
         os.remove(file)

ultralytics/utils/errors.py

@@ -5,18 +5,39 @@ from ultralytics.utils import emojis
 
 class HUBModelError(Exception):
     """
-    Custom exception class for handling errors related to model fetching in Ultralytics YOLO.
+    Exception raised when a model cannot be found or retrieved from Ultralytics HUB.
 
-    This exception is raised when a requested model is not found or cannot be retrieved.
-    The message is also processed to include emojis for better user experience.
+    This custom exception is used specifically for handling errors related to model fetching in Ultralytics YOLO.
+    The error message is processed to include emojis for better user experience.
 
     Attributes:
         message (str): The error message displayed when the exception is raised.
 
-    Note:
-        The message is automatically processed through the 'emojis' function from the 'ultralytics.utils' package.
+    Methods:
+        __init__: Initialize the HUBModelError with a custom message.
+
+    Examples:
+        >>> try:
+        >>> # Code that might fail to find a model
+        >>>     raise HUBModelError("Custom model not found message")
+        >>> except HUBModelError as e:
+        >>>     print(e)  # Displays the emoji-enhanced error message
     """
 
     def __init__(self, message="Model not found. Please check model URL and try again."):
-        """Create an exception for when a model is not found."""
+        """
+        Initialize a HUBModelError exception.
+
+        This exception is raised when a requested model is not found or cannot be retrieved from Ultralytics HUB.
+        The message is processed to include emojis for better user experience.
+
+        Args:
+            message (str, optional): The error message to display when the exception is raised.
+
+        Examples:
+            >>> try:
+            ...     raise HUBModelError("Custom model error message")
+            ... except HUBModelError as e:
+            ...     print(e)
+        """
         super().__init__(emojis(message))

ultralytics/utils/patches.py

@@ -18,10 +18,14 @@ def imread(filename: str, flags: int = cv2.IMREAD_COLOR):
 
     Args:
         filename (str): Path to the file to read.
-        flags (int, optional): Flag that can take values of cv2.IMREAD_*.
+        flags (int): Flag that can take values of cv2.IMREAD_*. Controls how the image is read.
 
     Returns:
         (np.ndarray): The read image.
+
+    Examples:
+        >>> img = imread("path/to/image.jpg")
+        >>> img = imread("path/to/image.jpg", cv2.IMREAD_GRAYSCALE)
     """
     return cv2.imdecode(np.fromfile(filename, np.uint8), flags)
 
@@ -36,7 +40,14 @@ def imwrite(filename: str, img: np.ndarray, params=None):
         params (List[int], optional): Additional parameters for image encoding.
 
     Returns:
-        (bool): True if the file was written, False otherwise.
+        (bool): True if the file was written successfully, False otherwise.
+
+    Examples:
+        >>> import numpy as np
+        >>> img = np.zeros((100, 100, 3), dtype=np.uint8)  # Create a black image
+        >>> success = imwrite("output.jpg", img)  # Write image to file
+        >>> print(success)
+        True
     """
     try:
         cv2.imencode(Path(filename).suffix, img, params)[1].tofile(filename)
@@ -49,9 +60,19 @@ def imshow(winname: str, mat: np.ndarray):
     """
     Display an image in the specified window.
 
+    This function is a wrapper around OpenCV's imshow function that displays an image in a named window. It is
+    particularly useful for visualizing images during development and debugging.
+
     Args:
-        winname (str): Name of the window.
-        mat (np.ndarray): Image to be shown.
+        winname (str): Name of the window where the image will be displayed. If a window with this name already
+            exists, the image will be displayed in that window.
+        mat (np.ndarray): Image to be shown. Should be a valid numpy array representing an image.
+
+    Examples:
+        >>> import numpy as np
+        >>> img = np.zeros((300, 300, 3), dtype=np.uint8)  # Create a black image
+        >>> img[:100, :100] = [255, 0, 0]  # Add a blue square
+        >>> imshow("Example Window", img)  # Display the image
     """
     _imshow(winname.encode("unicode_escape").decode(), mat)
 
@@ -74,7 +95,7 @@ def torch_load(*args, **kwargs):
     Returns:
         (Any): The loaded PyTorch object.
 
-    Note:
+    Notes:
         For PyTorch versions 2.0 and above, this function automatically sets 'weights_only=False'
         if the argument is not provided, to avoid deprecation warnings.
     """
@@ -96,6 +117,13 @@ def torch_save(*args, **kwargs):
     Args:
         *args (Any): Positional arguments to pass to torch.save.
         **kwargs (Any): Keyword arguments to pass to torch.save.
+
+    Returns:
+        (Any): Result of torch.save operation if successful, None otherwise.
+
+    Examples:
+        >>> model = torch.nn.Linear(10, 1)
+        >>> torch_save(model.state_dict(), "model.pt")
     """
     for i in range(4):  # 3 retries
         try:

ultralytics/utils/triton.py

@@ -25,6 +25,9 @@ class TritonRemoteModel:
         output_names (List[str]): The names of the model outputs.
         metadata: The metadata associated with the model.
 
+    Methods:
+        __call__: Call the model with the given inputs and return the outputs.
+
     Examples:
         Initialize a Triton client with HTTP
         >>> model = TritonRemoteModel(url="localhost:8000", endpoint="yolov8", scheme="http")
@@ -34,7 +37,7 @@ class TritonRemoteModel:
 
     def __init__(self, url: str, endpoint: str = "", scheme: str = ""):
         """
-        Initialize the TritonRemoteModel.
+        Initialize the TritonRemoteModel for interacting with a remote Triton Inference Server.
 
         Arguments may be provided individually or parsed from a collective 'url' argument of the form
         <scheme>://<netloc>/<endpoint>/<task_name>
@@ -43,6 +46,10 @@ class TritonRemoteModel:
             url (str): The URL of the Triton server.
             endpoint (str): The name of the model on the Triton server.
             scheme (str): The communication scheme ('http' or 'grpc').
+
+        Examples:
+            >>> model = TritonRemoteModel(url="localhost:8000", endpoint="yolov8", scheme="http")
+            >>> model = TritonRemoteModel(url="http://localhost:8000/yolov8")
         """
         if not endpoint and not scheme:  # Parse all args from URL string
             splits = urlsplit(url)
@@ -83,10 +90,16 @@ class TritonRemoteModel:
         Call the model with the given inputs.
 
         Args:
-            *inputs (np.ndarray): Input data to the model.
+            *inputs (np.ndarray): Input data to the model. Each array should match the expected shape and type
+                for the corresponding model input.
 
         Returns:
-            (List[np.ndarray]): Model outputs with the same dtype as the input.
+            (List[np.ndarray]): Model outputs with the same dtype as the input. Each element in the list
+                corresponds to one of the model's output tensors.
+
+        Examples:
+            >>> model = TritonRemoteModel(url="localhost:8000", endpoint="yolov8", scheme="http")
+            >>> outputs = model(np.random.rand(1, 3, 640, 640).astype(np.float32))
         """
         infer_inputs = []
         input_format = inputs[0].dtype

{ultralytics-8.3.100.dist-info → ultralytics-8.3.102.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.100
+Version: 8.3.102
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -56,7 +56,6 @@ Requires-Dist: coverage[toml]; extra == "dev"
 Requires-Dist: mkdocs>=1.6.0; extra == "dev"
 Requires-Dist: mkdocs-material>=9.5.9; extra == "dev"
 Requires-Dist: mkdocstrings[python]; extra == "dev"
-Requires-Dist: mkdocs-redirects; extra == "dev"
 Requires-Dist: mkdocs-ultralytics-plugin>=0.1.17; extra == "dev"
 Requires-Dist: mkdocs-macros-plugin>=1.0.5; extra == "dev"
 Provides-Extra: export