Skip to content

Reference for ultralytics/utils/__init__.py

Note

This file is available at https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/__init__.py. If you spot a problem please help fix it by contributing a Pull Request 🛠️. Thank you 🙏!


ultralytics.utils.TQDM

TQDM(*args, **kwargs)

Bases: tqdm

A custom TQDM progress bar class that extends the original tqdm functionality.

This class modifies the behavior of the original tqdm progress bar based on global settings and provides additional customization options.

Attributes:

Name Type Description
disable bool

Whether to disable the progress bar. Determined by the global VERBOSE setting and any passed 'disable' argument.

bar_format str

The format string for the progress bar. Uses the global TQDM_BAR_FORMAT if not explicitly set.

Methods:

Name Description

Examples:

>>> from ultralytics.utils import TQDM
>>> for i in TQDM(range(100)):
...     # Your processing code here
...     pass

This class extends the original tqdm class to provide customized behavior for Ultralytics projects.

Parameters:

Name Type Description Default
*args Any

Variable length argument list to be passed to the original tqdm constructor.

()
**kwargs Any

Arbitrary keyword arguments to be passed to the original tqdm constructor.

{}
Notes
  • The progress bar is disabled if VERBOSE is False or if 'disable' is explicitly set to True in kwargs.
  • The default bar format is set to TQDM_BAR_FORMAT unless overridden in kwargs.

Examples:

>>> from ultralytics.utils import TQDM
>>> for i in TQDM(range(100)):
...     # Your code here
...     pass
Source code in ultralytics/utils/__init__.py
def __init__(self, *args, **kwargs):
    """
    Initializes a custom TQDM progress bar.

    This class extends the original tqdm class to provide customized behavior for Ultralytics projects.

    Args:
        *args (Any): Variable length argument list to be passed to the original tqdm constructor.
        **kwargs (Any): Arbitrary keyword arguments to be passed to the original tqdm constructor.

    Notes:
        - The progress bar is disabled if VERBOSE is False or if 'disable' is explicitly set to True in kwargs.
        - The default bar format is set to TQDM_BAR_FORMAT unless overridden in kwargs.

    Examples:
        >>> from ultralytics.utils import TQDM
        >>> for i in TQDM(range(100)):
        ...     # Your code here
        ...     pass
    """
    kwargs["disable"] = not VERBOSE or kwargs.get("disable", False)  # logical 'and' with default value if passed
    kwargs.setdefault("bar_format", TQDM_BAR_FORMAT)  # override default value if passed
    super().__init__(*args, **kwargs)





ultralytics.utils.SimpleClass

A simple base class for creating objects with string representations of their attributes.

This class provides a foundation for creating objects that can be easily printed or represented as strings, showing all their non-callable attributes. It's useful for debugging and introspection of object states.

Methods:

Name Description
__str__

Returns a human-readable string representation of the object.

__repr__

Returns a machine-readable string representation of the object.

__getattr__

Provides a custom attribute access error message with helpful information.

Examples:

>>> class MyClass(SimpleClass):
...     def __init__(self):
...         self.x = 10
...         self.y = "hello"
>>> obj = MyClass()
>>> print(obj)
__main__.MyClass object with attributes:

x: 10 y: 'hello'

Notes
  • This class is designed to be subclassed. It provides a convenient way to inspect object attributes.
  • The string representation includes the module and class name of the object.
  • Callable attributes and attributes starting with an underscore are excluded from the string representation.

__getattr__

__getattr__(attr)

Custom attribute access error message with helpful information.

Source code in ultralytics/utils/__init__.py
def __getattr__(self, attr):
    """Custom attribute access error message with helpful information."""
    name = self.__class__.__name__
    raise AttributeError(f"'{name}' object has no attribute '{attr}'. See valid attributes below.\n{self.__doc__}")

__repr__

__repr__()

Return a machine-readable string representation of the object.

Source code in ultralytics/utils/__init__.py
def __repr__(self):
    """Return a machine-readable string representation of the object."""
    return self.__str__()

__str__

__str__()

Return a human-readable string representation of the object.

Source code in ultralytics/utils/__init__.py
def __str__(self):
    """Return a human-readable string representation of the object."""
    attr = []
    for a in dir(self):
        v = getattr(self, a)
        if not callable(v) and not a.startswith("_"):
            if isinstance(v, SimpleClass):
                # Display only the module and class name for subclasses
                s = f"{a}: {v.__module__}.{v.__class__.__name__} object"
            else:
                s = f"{a}: {repr(v)}"
            attr.append(s)
    return f"{self.__module__}.{self.__class__.__name__} object with attributes:\n\n" + "\n".join(attr)





ultralytics.utils.IterableSimpleNamespace

Bases: SimpleNamespace

An iterable SimpleNamespace class that provides enhanced functionality for attribute access and iteration.

This class extends the SimpleNamespace class with additional methods for iteration, string representation, and attribute access. It is designed to be used as a convenient container for storing and accessing configuration parameters.

Methods:

Name Description
__iter__

Returns an iterator of key-value pairs from the namespace's attributes.

__str__

Returns a human-readable string representation of the object.

__getattr__

Provides a custom attribute access error message with helpful information.

get

Retrieves the value of a specified key, or a default value if the key doesn't exist.

Examples:

>>> cfg = IterableSimpleNamespace(a=1, b=2, c=3)
>>> for k, v in cfg:
...     print(f"{k}: {v}")
a: 1
b: 2
c: 3
>>> print(cfg)
a=1
b=2
c=3
>>> cfg.get("b")
2
>>> cfg.get("d", "default")
'default'
Notes

This class is particularly useful for storing configuration parameters in a more accessible and iterable format compared to a standard dictionary.

__getattr__

__getattr__(attr)

Custom attribute access error message with helpful information.

Source code in ultralytics/utils/__init__.py
def __getattr__(self, attr):
    """Custom attribute access error message with helpful information."""
    name = self.__class__.__name__
    raise AttributeError(
        f"""
        '{name}' object has no attribute '{attr}'. This may be caused by a modified or out of date ultralytics
        'default.yaml' file.\nPlease update your code with 'pip install -U ultralytics' and if necessary replace
        {DEFAULT_CFG_PATH} with the latest version from
        https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/default.yaml
        """
    )

__iter__

__iter__()

Return an iterator of key-value pairs from the namespace's attributes.

Source code in ultralytics/utils/__init__.py
def __iter__(self):
    """Return an iterator of key-value pairs from the namespace's attributes."""
    return iter(vars(self).items())

__str__

__str__()

Return a human-readable string representation of the object.

Source code in ultralytics/utils/__init__.py
def __str__(self):
    """Return a human-readable string representation of the object."""
    return "\n".join(f"{k}={v}" for k, v in vars(self).items())

get

get(key, default=None)

Return the value of the specified key if it exists; otherwise, return the default value.

Source code in ultralytics/utils/__init__.py
def get(self, key, default=None):
    """Return the value of the specified key if it exists; otherwise, return the default value."""
    return getattr(self, key, default)





ultralytics.utils.ThreadingLocked

ThreadingLocked()

A decorator class for ensuring thread-safe execution of a function or method. This class can be used as a decorator to make sure that if the decorated function is called from multiple threads, only one thread at a time will be able to execute the function.

Attributes:

Name Type Description
lock Lock

A lock object used to manage access to the decorated function.

Example
from ultralytics.utils import ThreadingLocked

@ThreadingLocked()
def my_function():
    # Your code here
Source code in ultralytics/utils/__init__.py
def __init__(self):
    """Initializes the decorator class for thread-safe execution of a function or method."""
    self.lock = threading.Lock()

__call__

__call__(f)

Run thread-safe execution of function or method.

Source code in ultralytics/utils/__init__.py
def __call__(self, f):
    """Run thread-safe execution of function or method."""
    from functools import wraps

    @wraps(f)
    def decorated(*args, **kwargs):
        """Applies thread-safety to the decorated function or method."""
        with self.lock:
            return f(*args, **kwargs)

    return decorated





ultralytics.utils.TryExcept

TryExcept(msg='', verbose=True)

Bases: ContextDecorator

Ultralytics TryExcept class. Use as @TryExcept() decorator or 'with TryExcept():' context manager.

Examples:

As a decorator:

>>> @TryExcept(msg="Error occurred in func", verbose=True)
>>> def func():
>>> # Function logic here
>>>     pass

As a context manager:

>>> with TryExcept(msg="Error occurred in block", verbose=True):
>>> # Code block here
>>>     pass
Source code in ultralytics/utils/__init__.py
def __init__(self, msg="", verbose=True):
    """Initialize TryExcept class with optional message and verbosity settings."""
    self.msg = msg
    self.verbose = verbose

__enter__

__enter__()

Executes when entering TryExcept context, initializes instance.

Source code in ultralytics/utils/__init__.py
def __enter__(self):
    """Executes when entering TryExcept context, initializes instance."""
    pass

__exit__

__exit__(exc_type, value, traceback)

Defines behavior when exiting a 'with' block, prints error message if necessary.

Source code in ultralytics/utils/__init__.py
def __exit__(self, exc_type, value, traceback):
    """Defines behavior when exiting a 'with' block, prints error message if necessary."""
    if self.verbose and value:
        print(emojis(f"{self.msg}{': ' if self.msg else ''}{value}"))
    return True





ultralytics.utils.Retry

Retry(times=3, delay=2)

Bases: ContextDecorator

Retry class for function execution with exponential backoff.

Can be used as a decorator to retry a function on exceptions, up to a specified number of times with an exponentially increasing delay between retries.

Examples:

Example usage as a decorator:

>>> @Retry(times=3, delay=2)
>>> def test_func():
>>> # Replace with function logic that may raise exceptions
>>>     return True
Source code in ultralytics/utils/__init__.py
def __init__(self, times=3, delay=2):
    """Initialize Retry class with specified number of retries and delay."""
    self.times = times
    self.delay = delay
    self._attempts = 0

__call__

__call__(func)

Decorator implementation for Retry with exponential backoff.

Source code in ultralytics/utils/__init__.py
def __call__(self, func):
    """Decorator implementation for Retry with exponential backoff."""

    def wrapped_func(*args, **kwargs):
        """Applies retries to the decorated function or method."""
        self._attempts = 0
        while self._attempts < self.times:
            try:
                return func(*args, **kwargs)
            except Exception as e:
                self._attempts += 1
                print(f"Retry {self._attempts}/{self.times} failed: {e}")
                if self._attempts >= self.times:
                    raise e
                time.sleep(self.delay * (2**self._attempts))  # exponential backoff delay

    return wrapped_func





ultralytics.utils.JSONDict

JSONDict(file_path: Union[str, Path] = 'data.json')

Bases: dict

A dictionary-like class that provides JSON persistence for its contents.

This class extends the built-in dictionary to automatically save its contents to a JSON file whenever they are modified. It ensures thread-safe operations using a lock.

Attributes:

Name Type Description
file_path Path

The path to the JSON file used for persistence.

lock Lock

A lock object to ensure thread-safe operations.

Methods:

Name Description
_load

Loads the data from the JSON file into the dictionary.

_save

Saves the current state of the dictionary to the JSON file.

__setitem__

Stores a key-value pair and persists it to disk.

__delitem__

Removes an item and updates the persistent storage.

update

Updates the dictionary and persists changes.

clear

Clears all entries and updates the persistent storage.

Examples:

>>> json_dict = JSONDict("data.json")
>>> json_dict["key"] = "value"
>>> print(json_dict["key"])
value
>>> del json_dict["key"]
>>> json_dict.update({"new_key": "new_value"})
>>> json_dict.clear()
Source code in ultralytics/utils/__init__.py
def __init__(self, file_path: Union[str, Path] = "data.json"):
    """Initialize a JSONDict object with a specified file path for JSON persistence."""
    super().__init__()
    self.file_path = Path(file_path)
    self.lock = Lock()
    self._load()

__delitem__

__delitem__(key)

Remove an item and update the persistent storage.

Source code in ultralytics/utils/__init__.py
def __delitem__(self, key):
    """Remove an item and update the persistent storage."""
    with self.lock:
        super().__delitem__(key)
        self._save()

__setitem__

__setitem__(key, value)

Store a key-value pair and persist to disk.

Source code in ultralytics/utils/__init__.py
def __setitem__(self, key, value):
    """Store a key-value pair and persist to disk."""
    with self.lock:
        super().__setitem__(key, value)
        self._save()

__str__

__str__()

Return a pretty-printed JSON string representation of the dictionary.

Source code in ultralytics/utils/__init__.py
def __str__(self):
    """Return a pretty-printed JSON string representation of the dictionary."""
    return f'JSONDict("{self.file_path}"):\n{json.dumps(dict(self), indent=2, ensure_ascii=False, default=self._json_default)}'

clear

clear()

Clear all entries and update the persistent storage.

Source code in ultralytics/utils/__init__.py
def clear(self):
    """Clear all entries and update the persistent storage."""
    with self.lock:
        super().clear()
        self._save()

update

update(*args, **kwargs)

Update the dictionary and persist changes.

Source code in ultralytics/utils/__init__.py
def update(self, *args, **kwargs):
    """Update the dictionary and persist changes."""
    with self.lock:
        super().update(*args, **kwargs)
        self._save()





ultralytics.utils.SettingsManager

SettingsManager(file=SETTINGS_FILE, version='0.0.6')

Bases: JSONDict

SettingsManager class for managing and persisting Ultralytics settings.

This class extends JSONDict to provide JSON persistence for settings, ensuring thread-safe operations and default values. It validates settings on initialization and provides methods to update or reset settings.

Attributes:

Name Type Description
file Path

The path to the JSON file used for persistence.

version str

The version of the settings schema.

defaults Dict

A dictionary containing default settings.

help_msg str

A help message for users on how to view and update settings.

Methods:

Name Description
_validate_settings

Validates the current settings and resets if necessary.

update

Updates settings, validating keys and types.

reset

Resets the settings to default and saves them.

Examples:

Initialize and update settings:

>>> settings = SettingsManager()
>>> settings.update(runs_dir="/new/runs/dir")
>>> print(settings["runs_dir"])
/new/runs/dir
Source code in ultralytics/utils/__init__.py
def __init__(self, file=SETTINGS_FILE, version="0.0.6"):
    """Initializes the SettingsManager with default settings and loads user settings."""
    import hashlib

    from ultralytics.utils.torch_utils import torch_distributed_zero_first

    root = GIT_DIR or Path()
    datasets_root = (root.parent if GIT_DIR and is_dir_writeable(root.parent) else root).resolve()

    self.file = Path(file)
    self.version = version
    self.defaults = {
        "settings_version": version,  # Settings schema version
        "datasets_dir": str(datasets_root / "datasets"),  # Datasets directory
        "weights_dir": str(root / "weights"),  # Model weights directory
        "runs_dir": str(root / "runs"),  # Experiment runs directory
        "uuid": hashlib.sha256(str(uuid.getnode()).encode()).hexdigest(),  # SHA-256 anonymized UUID hash
        "sync": True,  # Enable synchronization
        "api_key": "",  # Ultralytics API Key
        "openai_api_key": "",  # OpenAI API Key
        "clearml": True,  # ClearML integration
        "comet": True,  # Comet integration
        "dvc": True,  # DVC integration
        "hub": True,  # Ultralytics HUB integration
        "mlflow": True,  # MLflow integration
        "neptune": True,  # Neptune integration
        "raytune": True,  # Ray Tune integration
        "tensorboard": True,  # TensorBoard logging
        "wandb": True,  # Weights & Biases logging
        "vscode_msg": True,  # VSCode messaging
    }

    self.help_msg = (
        f"\nView Ultralytics Settings with 'yolo settings' or at '{self.file}'"
        "\nUpdate Settings with 'yolo settings key=value', i.e. 'yolo settings runs_dir=path/to/dir'. "
        "For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings."
    )

    with torch_distributed_zero_first(RANK):
        super().__init__(self.file)

        if not self.file.exists() or not self:  # Check if file doesn't exist or is empty
            LOGGER.info(f"Creating new Ultralytics Settings v{version} file ✅ {self.help_msg}")
            self.reset()

        self._validate_settings()

reset

reset()

Resets the settings to default and saves them.

Source code in ultralytics/utils/__init__.py
def reset(self):
    """Resets the settings to default and saves them."""
    self.clear()
    self.update(self.defaults)

update

update(*args, **kwargs)

Updates settings, validating keys and types.

Source code in ultralytics/utils/__init__.py
def update(self, *args, **kwargs):
    """Updates settings, validating keys and types."""
    for k, v in kwargs.items():
        if k not in self.defaults:
            raise KeyError(f"No Ultralytics setting '{k}'. {self.help_msg}")
        t = type(self.defaults[k])
        if not isinstance(v, t):
            raise TypeError(f"Ultralytics setting '{k}' must be of type '{t}', not '{type(v)}'. {self.help_msg}")
    super().update(*args, **kwargs)





ultralytics.utils.plt_settings

plt_settings(rcparams=None, backend='Agg')

Decorator to temporarily set rc parameters and the backend for a plotting function.

Example

decorator: @plt_settings({"font.size": 12}) context manager: with plt_settings({"font.size": 12}):

Parameters:

Name Type Description Default
rcparams dict

Dictionary of rc parameters to set.

None
backend str

Name of the backend to use. Defaults to 'Agg'.

'Agg'

Returns:

Type Description
Callable

Decorated function with temporarily set rc parameters and backend. This decorator can be applied to any function that needs to have specific matplotlib rc parameters and backend for its execution.

Source code in ultralytics/utils/__init__.py
def plt_settings(rcparams=None, backend="Agg"):
    """
    Decorator to temporarily set rc parameters and the backend for a plotting function.

    Example:
        decorator: @plt_settings({"font.size": 12})
        context manager: with plt_settings({"font.size": 12}):

    Args:
        rcparams (dict): Dictionary of rc parameters to set.
        backend (str, optional): Name of the backend to use. Defaults to 'Agg'.

    Returns:
        (Callable): Decorated function with temporarily set rc parameters and backend. This decorator can be
            applied to any function that needs to have specific matplotlib rc parameters and backend for its execution.
    """
    if rcparams is None:
        rcparams = {"font.size": 11}

    def decorator(func):
        """Decorator to apply temporary rc parameters and backend to a function."""

        def wrapper(*args, **kwargs):
            """Sets rc parameters and backend, calls the original function, and restores the settings."""
            original_backend = plt.get_backend()
            switch = backend.lower() != original_backend.lower()
            if switch:
                plt.close("all")  # auto-close()ing of figures upon backend switching is deprecated since 3.8
                plt.switch_backend(backend)

            # Plot with backend and always revert to original backend
            try:
                with plt.rc_context(rcparams):
                    result = func(*args, **kwargs)
            finally:
                if switch:
                    plt.close("all")
                    plt.switch_backend(original_backend)
            return result

        return wrapper

    return decorator





ultralytics.utils.set_logging

set_logging(name='LOGGING_NAME', verbose=True)

Sets up logging with UTF-8 encoding and configurable verbosity.

This function configures logging for the Ultralytics library, setting the appropriate logging level and formatter based on the verbosity flag and the current process rank. It handles special cases for Windows environments where UTF-8 encoding might not be the default.

Parameters:

Name Type Description Default
name str

Name of the logger. Defaults to "LOGGING_NAME".

'LOGGING_NAME'
verbose bool

Flag to set logging level to INFO if True, ERROR otherwise. Defaults to True.

True

Examples:

>>> set_logging(name="ultralytics", verbose=True)
>>> logger = logging.getLogger("ultralytics")
>>> logger.info("This is an info message")
Notes
  • On Windows, this function attempts to reconfigure stdout to use UTF-8 encoding if possible.
  • If reconfiguration is not possible, it falls back to a custom formatter that handles non-UTF-8 environments.
  • The function sets up a StreamHandler with the appropriate formatter and level.
  • The logger's propagate flag is set to False to prevent duplicate logging in parent loggers.
Source code in ultralytics/utils/__init__.py
def set_logging(name="LOGGING_NAME", verbose=True):
    """
    Sets up logging with UTF-8 encoding and configurable verbosity.

    This function configures logging for the Ultralytics library, setting the appropriate logging level and
    formatter based on the verbosity flag and the current process rank. It handles special cases for Windows
    environments where UTF-8 encoding might not be the default.

    Args:
        name (str): Name of the logger. Defaults to "LOGGING_NAME".
        verbose (bool): Flag to set logging level to INFO if True, ERROR otherwise. Defaults to True.

    Examples:
        >>> set_logging(name="ultralytics", verbose=True)
        >>> logger = logging.getLogger("ultralytics")
        >>> logger.info("This is an info message")

    Notes:
        - On Windows, this function attempts to reconfigure stdout to use UTF-8 encoding if possible.
        - If reconfiguration is not possible, it falls back to a custom formatter that handles non-UTF-8 environments.
        - The function sets up a StreamHandler with the appropriate formatter and level.
        - The logger's propagate flag is set to False to prevent duplicate logging in parent loggers.
    """
    level = logging.INFO if verbose and RANK in {-1, 0} else logging.ERROR  # rank in world for Multi-GPU trainings

    # Configure the console (stdout) encoding to UTF-8, with checks for compatibility
    formatter = logging.Formatter("%(message)s")  # Default formatter
    if WINDOWS and hasattr(sys.stdout, "encoding") and sys.stdout.encoding != "utf-8":

        class CustomFormatter(logging.Formatter):
            def format(self, record):
                """Sets up logging with UTF-8 encoding and configurable verbosity."""
                return emojis(super().format(record))

        try:
            # Attempt to reconfigure stdout to use UTF-8 encoding if possible
            if hasattr(sys.stdout, "reconfigure"):
                sys.stdout.reconfigure(encoding="utf-8")
            # For environments where reconfigure is not available, wrap stdout in a TextIOWrapper
            elif hasattr(sys.stdout, "buffer"):
                import io

                sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
            else:
                formatter = CustomFormatter("%(message)s")
        except Exception as e:
            print(f"Creating custom formatter for non UTF-8 environments due to {e}")
            formatter = CustomFormatter("%(message)s")

    # Create and configure the StreamHandler with the appropriate formatter and level
    stream_handler = logging.StreamHandler(sys.stdout)
    stream_handler.setFormatter(formatter)
    stream_handler.setLevel(level)

    # Set up the logger
    logger = logging.getLogger(name)
    logger.setLevel(level)
    logger.addHandler(stream_handler)
    logger.propagate = False
    return logger





ultralytics.utils.emojis

emojis(string='')

Return platform-dependent emoji-safe version of string.

Source code in ultralytics/utils/__init__.py
def emojis(string=""):
    """Return platform-dependent emoji-safe version of string."""
    return string.encode().decode("ascii", "ignore") if WINDOWS else string





ultralytics.utils.yaml_save

yaml_save(file='data.yaml', data=None, header='')

Save YAML data to a file.

Parameters:

Name Type Description Default
file str

File name. Default is 'data.yaml'.

'data.yaml'
data dict

Data to save in YAML format.

None
header str

YAML header to add.

''

Returns:

Type Description
None

Data is saved to the specified file.

Source code in ultralytics/utils/__init__.py
def yaml_save(file="data.yaml", data=None, header=""):
    """
    Save YAML data to a file.

    Args:
        file (str, optional): File name. Default is 'data.yaml'.
        data (dict): Data to save in YAML format.
        header (str, optional): YAML header to add.

    Returns:
        (None): Data is saved to the specified file.
    """
    if data is None:
        data = {}
    file = Path(file)
    if not file.parent.exists():
        # Create parent directories if they don't exist
        file.parent.mkdir(parents=True, exist_ok=True)

    # Convert Path objects to strings
    valid_types = int, float, str, bool, list, tuple, dict, type(None)
    for k, v in data.items():
        if not isinstance(v, valid_types):
            data[k] = str(v)

    # Dump data to file in YAML format
    with open(file, "w", errors="ignore", encoding="utf-8") as f:
        if header:
            f.write(header)
        yaml.safe_dump(data, f, sort_keys=False, allow_unicode=True)





ultralytics.utils.yaml_load

yaml_load(file='data.yaml', append_filename=False)

Load YAML data from a file.

Parameters:

Name Type Description Default
file str

File name. Default is 'data.yaml'.

'data.yaml'
append_filename bool

Add the YAML filename to the YAML dictionary. Default is False.

False

Returns:

Type Description
dict

YAML data and file name.

Source code in ultralytics/utils/__init__.py
def yaml_load(file="data.yaml", append_filename=False):
    """
    Load YAML data from a file.

    Args:
        file (str, optional): File name. Default is 'data.yaml'.
        append_filename (bool): Add the YAML filename to the YAML dictionary. Default is False.

    Returns:
        (dict): YAML data and file name.
    """
    assert Path(file).suffix in {".yaml", ".yml"}, f"Attempting to load non-YAML file {file} with yaml_load()"
    with open(file, errors="ignore", encoding="utf-8") as f:
        s = f.read()  # string

        # Remove special characters
        if not s.isprintable():
            s = re.sub(r"[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD\U00010000-\U0010ffff]+", "", s)

        # Add YAML filename to dict and return
        data = yaml.safe_load(s) or {}  # always return a dict (yaml.safe_load() may return None for empty files)
        if append_filename:
            data["yaml_file"] = str(file)
        return data





ultralytics.utils.yaml_print

yaml_print(yaml_file: Union[str, Path, dict]) -> None

Pretty prints a YAML file or a YAML-formatted dictionary.

Parameters:

Name Type Description Default
yaml_file Union[str, Path, dict]

The file path of the YAML file or a YAML-formatted dictionary.

required

Returns:

Type Description
None

(None)

Source code in ultralytics/utils/__init__.py
def yaml_print(yaml_file: Union[str, Path, dict]) -> None:
    """
    Pretty prints a YAML file or a YAML-formatted dictionary.

    Args:
        yaml_file: The file path of the YAML file or a YAML-formatted dictionary.

    Returns:
        (None)
    """
    yaml_dict = yaml_load(yaml_file) if isinstance(yaml_file, (str, Path)) else yaml_file
    dump = yaml.dump(yaml_dict, sort_keys=False, allow_unicode=True, width=float("inf"))
    LOGGER.info(f"Printing '{colorstr('bold', 'black', yaml_file)}'\n\n{dump}")





ultralytics.utils.read_device_model

read_device_model() -> str

Reads the device model information from the system and caches it for quick access. Used by is_jetson() and is_raspberrypi().

Returns:

Type Description
str

Model file contents if read successfully or empty string otherwise.

Source code in ultralytics/utils/__init__.py
def read_device_model() -> str:
    """
    Reads the device model information from the system and caches it for quick access. Used by is_jetson() and
    is_raspberrypi().

    Returns:
        (str): Model file contents if read successfully or empty string otherwise.
    """
    try:
        with open("/proc/device-tree/model") as f:
            return f.read()
    except:  # noqa E722
        return ""





ultralytics.utils.is_ubuntu

is_ubuntu() -> bool

Check if the OS is Ubuntu.

Returns:

Type Description
bool

True if OS is Ubuntu, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_ubuntu() -> bool:
    """
    Check if the OS is Ubuntu.

    Returns:
        (bool): True if OS is Ubuntu, False otherwise.
    """
    try:
        with open("/etc/os-release") as f:
            return "ID=ubuntu" in f.read()
    except FileNotFoundError:
        return False





ultralytics.utils.is_colab

is_colab()

Check if the current script is running inside a Google Colab notebook.

Returns:

Type Description
bool

True if running inside a Colab notebook, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_colab():
    """
    Check if the current script is running inside a Google Colab notebook.

    Returns:
        (bool): True if running inside a Colab notebook, False otherwise.
    """
    return "COLAB_RELEASE_TAG" in os.environ or "COLAB_BACKEND_VERSION" in os.environ





ultralytics.utils.is_kaggle

is_kaggle()

Check if the current script is running inside a Kaggle kernel.

Returns:

Type Description
bool

True if running inside a Kaggle kernel, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_kaggle():
    """
    Check if the current script is running inside a Kaggle kernel.

    Returns:
        (bool): True if running inside a Kaggle kernel, False otherwise.
    """
    return os.environ.get("PWD") == "/kaggle/working" and os.environ.get("KAGGLE_URL_BASE") == "https://www.kaggle.com"





ultralytics.utils.is_jupyter

is_jupyter()

Check if the current script is running inside a Jupyter Notebook. Verified on Colab, Jupyterlab, Kaggle, Paperspace.

Returns:

Type Description
bool

True if running inside a Jupyter Notebook, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_jupyter():
    """
    Check if the current script is running inside a Jupyter Notebook. Verified on Colab, Jupyterlab, Kaggle, Paperspace.

    Returns:
        (bool): True if running inside a Jupyter Notebook, False otherwise.
    """
    return "get_ipython" in locals()





ultralytics.utils.is_docker

is_docker() -> bool

Determine if the script is running inside a Docker container.

Returns:

Type Description
bool

True if the script is running inside a Docker container, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_docker() -> bool:
    """
    Determine if the script is running inside a Docker container.

    Returns:
        (bool): True if the script is running inside a Docker container, False otherwise.
    """
    try:
        with open("/proc/self/cgroup") as f:
            return "docker" in f.read()
    except:  # noqa E722
        return False





ultralytics.utils.is_raspberrypi

is_raspberrypi() -> bool

Determines if the Python environment is running on a Raspberry Pi by checking the device model information.

Returns:

Type Description
bool

True if running on a Raspberry Pi, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_raspberrypi() -> bool:
    """
    Determines if the Python environment is running on a Raspberry Pi by checking the device model information.

    Returns:
        (bool): True if running on a Raspberry Pi, False otherwise.
    """
    return "Raspberry Pi" in PROC_DEVICE_MODEL





ultralytics.utils.is_jetson

is_jetson() -> bool

Determines if the Python environment is running on a Jetson Nano or Jetson Orin device by checking the device model information.

Returns:

Type Description
bool

True if running on a Jetson Nano or Jetson Orin, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_jetson() -> bool:
    """
    Determines if the Python environment is running on a Jetson Nano or Jetson Orin device by checking the device model
    information.

    Returns:
        (bool): True if running on a Jetson Nano or Jetson Orin, False otherwise.
    """
    return "NVIDIA" in PROC_DEVICE_MODEL  # i.e. "NVIDIA Jetson Nano" or "NVIDIA Orin NX"





ultralytics.utils.is_online

is_online() -> bool

Check internet connectivity by attempting to connect to a known online host.

Returns:

Type Description
bool

True if connection is successful, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_online() -> bool:
    """
    Check internet connectivity by attempting to connect to a known online host.

    Returns:
        (bool): True if connection is successful, False otherwise.
    """
    try:
        assert str(os.getenv("YOLO_OFFLINE", "")).lower() != "true"  # check if ENV var YOLO_OFFLINE="True"
        import socket

        for dns in ("1.1.1.1", "8.8.8.8"):  # check Cloudflare and Google DNS
            socket.create_connection(address=(dns, 80), timeout=2.0).close()
            return True
    except:  # noqa E722
        return False





ultralytics.utils.is_pip_package

is_pip_package(filepath: str = __name__) -> bool

Determines if the file at the given filepath is part of a pip package.

Parameters:

Name Type Description Default
filepath str

The filepath to check.

__name__

Returns:

Type Description
bool

True if the file is part of a pip package, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_pip_package(filepath: str = __name__) -> bool:
    """
    Determines if the file at the given filepath is part of a pip package.

    Args:
        filepath (str): The filepath to check.

    Returns:
        (bool): True if the file is part of a pip package, False otherwise.
    """
    import importlib.util

    # Get the spec for the module
    spec = importlib.util.find_spec(filepath)

    # Return whether the spec is not None and the origin is not None (indicating it is a package)
    return spec is not None and spec.origin is not None





ultralytics.utils.is_dir_writeable

is_dir_writeable(dir_path: Union[str, Path]) -> bool

Check if a directory is writeable.

Parameters:

Name Type Description Default
dir_path str | Path

The path to the directory.

required

Returns:

Type Description
bool

True if the directory is writeable, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_dir_writeable(dir_path: Union[str, Path]) -> bool:
    """
    Check if a directory is writeable.

    Args:
        dir_path (str | Path): The path to the directory.

    Returns:
        (bool): True if the directory is writeable, False otherwise.
    """
    return os.access(str(dir_path), os.W_OK)





ultralytics.utils.is_pytest_running

is_pytest_running()

Determines whether pytest is currently running or not.

Returns:

Type Description
bool

True if pytest is running, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_pytest_running():
    """
    Determines whether pytest is currently running or not.

    Returns:
        (bool): True if pytest is running, False otherwise.
    """
    return ("PYTEST_CURRENT_TEST" in os.environ) or ("pytest" in sys.modules) or ("pytest" in Path(ARGV[0]).stem)





ultralytics.utils.is_github_action_running

is_github_action_running() -> bool

Determine if the current environment is a GitHub Actions runner.

Returns:

Type Description
bool

True if the current environment is a GitHub Actions runner, False otherwise.

Source code in ultralytics/utils/__init__.py
def is_github_action_running() -> bool:
    """
    Determine if the current environment is a GitHub Actions runner.

    Returns:
        (bool): True if the current environment is a GitHub Actions runner, False otherwise.
    """
    return "GITHUB_ACTIONS" in os.environ and "GITHUB_WORKFLOW" in os.environ and "RUNNER_OS" in os.environ





ultralytics.utils.get_git_dir

get_git_dir()

Determines whether the current file is part of a git repository and if so, returns the repository root directory. If the current file is not part of a git repository, returns None.

Returns:

Type Description
Path | None

Git root directory if found or None if not found.

Source code in ultralytics/utils/__init__.py
def get_git_dir():
    """
    Determines whether the current file is part of a git repository and if so, returns the repository root directory. If
    the current file is not part of a git repository, returns None.

    Returns:
        (Path | None): Git root directory if found or None if not found.
    """
    for d in Path(__file__).parents:
        if (d / ".git").is_dir():
            return d





ultralytics.utils.is_git_dir

is_git_dir()

Determines whether the current file is part of a git repository. If the current file is not part of a git repository, returns None.

Returns:

Type Description
bool

True if current file is part of a git repository.

Source code in ultralytics/utils/__init__.py
def is_git_dir():
    """
    Determines whether the current file is part of a git repository. If the current file is not part of a git
    repository, returns None.

    Returns:
        (bool): True if current file is part of a git repository.
    """
    return GIT_DIR is not None





ultralytics.utils.get_git_origin_url

get_git_origin_url()

Retrieves the origin URL of a git repository.

Returns:

Type Description
str | None

The origin URL of the git repository or None if not git directory.

Source code in ultralytics/utils/__init__.py
def get_git_origin_url():
    """
    Retrieves the origin URL of a git repository.

    Returns:
        (str | None): The origin URL of the git repository or None if not git directory.
    """
    if IS_GIT_DIR:
        try:
            origin = subprocess.check_output(["git", "config", "--get", "remote.origin.url"])
            return origin.decode().strip()
        except subprocess.CalledProcessError:
            return None





ultralytics.utils.get_git_branch

get_git_branch()

Returns the current git branch name. If not in a git repository, returns None.

Returns:

Type Description
str | None

The current git branch name or None if not a git directory.

Source code in ultralytics/utils/__init__.py
def get_git_branch():
    """
    Returns the current git branch name. If not in a git repository, returns None.

    Returns:
        (str | None): The current git branch name or None if not a git directory.
    """
    if IS_GIT_DIR:
        try:
            origin = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
            return origin.decode().strip()
        except subprocess.CalledProcessError:
            return None





ultralytics.utils.get_default_args

get_default_args(func)

Returns a dictionary of default arguments for a function.

Parameters:

Name Type Description Default
func callable

The function to inspect.

required

Returns:

Type Description
dict

A dictionary where each key is a parameter name, and each value is the default value of that parameter.

Source code in ultralytics/utils/__init__.py
def get_default_args(func):
    """
    Returns a dictionary of default arguments for a function.

    Args:
        func (callable): The function to inspect.

    Returns:
        (dict): A dictionary where each key is a parameter name, and each value is the default value of that parameter.
    """
    signature = inspect.signature(func)
    return {k: v.default for k, v in signature.parameters.items() if v.default is not inspect.Parameter.empty}





ultralytics.utils.get_ubuntu_version

get_ubuntu_version()

Retrieve the Ubuntu version if the OS is Ubuntu.

Returns:

Type Description
str

Ubuntu version or None if not an Ubuntu OS.

Source code in ultralytics/utils/__init__.py
def get_ubuntu_version():
    """
    Retrieve the Ubuntu version if the OS is Ubuntu.

    Returns:
        (str): Ubuntu version or None if not an Ubuntu OS.
    """
    if is_ubuntu():
        try:
            with open("/etc/os-release") as f:
                return re.search(r'VERSION_ID="(\d+\.\d+)"', f.read())[1]
        except (FileNotFoundError, AttributeError):
            return None





ultralytics.utils.get_user_config_dir

get_user_config_dir(sub_dir='Ultralytics')

Return the appropriate config directory based on the environment operating system.

Parameters:

Name Type Description Default
sub_dir str

The name of the subdirectory to create.

'Ultralytics'

Returns:

Type Description
Path

The path to the user config directory.

Source code in ultralytics/utils/__init__.py
def get_user_config_dir(sub_dir="Ultralytics"):
    """
    Return the appropriate config directory based on the environment operating system.

    Args:
        sub_dir (str): The name of the subdirectory to create.

    Returns:
        (Path): The path to the user config directory.
    """
    if WINDOWS:
        path = Path.home() / "AppData" / "Roaming" / sub_dir
    elif MACOS:  # macOS
        path = Path.home() / "Library" / "Application Support" / sub_dir
    elif LINUX:
        path = Path.home() / ".config" / sub_dir
    else:
        raise ValueError(f"Unsupported operating system: {platform.system()}")

    # GCP and AWS lambda fix, only /tmp is writeable
    if not is_dir_writeable(path.parent):
        LOGGER.warning(
            f"WARNING ⚠️ user config directory '{path}' is not writeable, defaulting to '/tmp' or CWD."
            "Alternatively you can define a YOLO_CONFIG_DIR environment variable for this path."
        )
        path = Path("/tmp") / sub_dir if is_dir_writeable("/tmp") else Path().cwd() / sub_dir

    # Create the subdirectory if it does not exist
    path.mkdir(parents=True, exist_ok=True)

    return path





ultralytics.utils.colorstr

colorstr(*input)

Colors a string based on the provided color and style arguments. Utilizes ANSI escape codes. See https://en.wikipedia.org/wiki/ANSI_escape_code for more details.

This function can be called in two ways
  • colorstr('color', 'style', 'your string')
  • colorstr('your string')

In the second form, 'blue' and 'bold' will be applied by default.

Parameters:

Name Type Description Default
*input str | Path

A sequence of strings where the first n-1 strings are color and style arguments, and the last string is the one to be colored.

()
Supported Colors and Styles

Basic Colors: 'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white' Bright Colors: 'bright_black', 'bright_red', 'bright_green', 'bright_yellow', 'bright_blue', 'bright_magenta', 'bright_cyan', 'bright_white' Misc: 'end', 'bold', 'underline'

Returns:

Type Description
str

The input string wrapped with ANSI escape codes for the specified color and style.

Examples:

>>> colorstr("blue", "bold", "hello world")
>>> "\033[34m\033[1mhello world\033[0m"
Source code in ultralytics/utils/__init__.py
def colorstr(*input):
    r"""
    Colors a string based on the provided color and style arguments. Utilizes ANSI escape codes.
    See https://en.wikipedia.org/wiki/ANSI_escape_code for more details.

    This function can be called in two ways:
        - colorstr('color', 'style', 'your string')
        - colorstr('your string')

    In the second form, 'blue' and 'bold' will be applied by default.

    Args:
        *input (str | Path): A sequence of strings where the first n-1 strings are color and style arguments,
                      and the last string is the one to be colored.

    Supported Colors and Styles:
        Basic Colors: 'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'
        Bright Colors: 'bright_black', 'bright_red', 'bright_green', 'bright_yellow',
                       'bright_blue', 'bright_magenta', 'bright_cyan', 'bright_white'
        Misc: 'end', 'bold', 'underline'

    Returns:
        (str): The input string wrapped with ANSI escape codes for the specified color and style.

    Examples:
        >>> colorstr("blue", "bold", "hello world")
        >>> "\033[34m\033[1mhello world\033[0m"
    """
    *args, string = input if len(input) > 1 else ("blue", "bold", input[0])  # color arguments, string
    colors = {
        "black": "\033[30m",  # basic colors
        "red": "\033[31m",
        "green": "\033[32m",
        "yellow": "\033[33m",
        "blue": "\033[34m",
        "magenta": "\033[35m",
        "cyan": "\033[36m",
        "white": "\033[37m",
        "bright_black": "\033[90m",  # bright colors
        "bright_red": "\033[91m",
        "bright_green": "\033[92m",
        "bright_yellow": "\033[93m",
        "bright_blue": "\033[94m",
        "bright_magenta": "\033[95m",
        "bright_cyan": "\033[96m",
        "bright_white": "\033[97m",
        "end": "\033[0m",  # misc
        "bold": "\033[1m",
        "underline": "\033[4m",
    }
    return "".join(colors[x] for x in args) + f"{string}" + colors["end"]





ultralytics.utils.remove_colorstr

remove_colorstr(input_string)

Removes ANSI escape codes from a string, effectively un-coloring it.

Parameters:

Name Type Description Default
input_string str

The string to remove color and style from.

required

Returns:

Type Description
str

A new string with all ANSI escape codes removed.

Examples:

>>> remove_colorstr(colorstr("blue", "bold", "hello world"))
>>> "hello world"
Source code in ultralytics/utils/__init__.py
def remove_colorstr(input_string):
    """
    Removes ANSI escape codes from a string, effectively un-coloring it.

    Args:
        input_string (str): The string to remove color and style from.

    Returns:
        (str): A new string with all ANSI escape codes removed.

    Examples:
        >>> remove_colorstr(colorstr("blue", "bold", "hello world"))
        >>> "hello world"
    """
    ansi_escape = re.compile(r"\x1B\[[0-9;]*[A-Za-z]")
    return ansi_escape.sub("", input_string)





ultralytics.utils.threaded

threaded(func)

Multi-threads a target function by default and returns the thread or function result.

Use as @threaded decorator. The function runs in a separate thread unless 'threaded=False' is passed.

Source code in ultralytics/utils/__init__.py
def threaded(func):
    """
    Multi-threads a target function by default and returns the thread or function result.

    Use as @threaded decorator. The function runs in a separate thread unless 'threaded=False' is passed.
    """

    def wrapper(*args, **kwargs):
        """Multi-threads a given function based on 'threaded' kwarg and returns the thread or function result."""
        if kwargs.pop("threaded", True):  # run in thread
            thread = threading.Thread(target=func, args=args, kwargs=kwargs, daemon=True)
            thread.start()
            return thread
        else:
            return func(*args, **kwargs)

    return wrapper





ultralytics.utils.set_sentry

set_sentry()

Initialize the Sentry SDK for error tracking and reporting. Only used if sentry_sdk package is installed and sync=True in settings. Run 'yolo settings' to see and update settings.

Conditions required to send errors (ALL conditions must be met or no errors will be reported): - sentry_sdk package is installed - sync=True in YOLO settings - pytest is not running - running in a pip package installation - running in a non-git directory - running with rank -1 or 0 - online environment - CLI used to run package (checked with 'yolo' as the name of the main CLI command)

The function also configures Sentry SDK to ignore KeyboardInterrupt and FileNotFoundError exceptions and to exclude events with 'out of memory' in their exception message.

Additionally, the function sets custom tags and user information for Sentry events.

Source code in ultralytics/utils/__init__.py
def set_sentry():
    """
    Initialize the Sentry SDK for error tracking and reporting. Only used if sentry_sdk package is installed and
    sync=True in settings. Run 'yolo settings' to see and update settings.

    Conditions required to send errors (ALL conditions must be met or no errors will be reported):
        - sentry_sdk package is installed
        - sync=True in YOLO settings
        - pytest is not running
        - running in a pip package installation
        - running in a non-git directory
        - running with rank -1 or 0
        - online environment
        - CLI used to run package (checked with 'yolo' as the name of the main CLI command)

    The function also configures Sentry SDK to ignore KeyboardInterrupt and FileNotFoundError exceptions and to exclude
    events with 'out of memory' in their exception message.

    Additionally, the function sets custom tags and user information for Sentry events.
    """
    if (
        not SETTINGS["sync"]
        or RANK not in {-1, 0}
        or Path(ARGV[0]).name != "yolo"
        or TESTS_RUNNING
        or not ONLINE
        or not IS_PIP_PACKAGE
        or IS_GIT_DIR
    ):
        return
    # If sentry_sdk package is not installed then return and do not use Sentry
    try:
        import sentry_sdk  # noqa
    except ImportError:
        return

    def before_send(event, hint):
        """
        Modify the event before sending it to Sentry based on specific exception types and messages.

        Args:
            event (dict): The event dictionary containing information about the error.
            hint (dict): A dictionary containing additional information about the error.

        Returns:
            dict: The modified event or None if the event should not be sent to Sentry.
        """
        if "exc_info" in hint:
            exc_type, exc_value, _ = hint["exc_info"]
            if exc_type in {KeyboardInterrupt, FileNotFoundError} or "out of memory" in str(exc_value):
                return None  # do not send event

        event["tags"] = {
            "sys_argv": ARGV[0],
            "sys_argv_name": Path(ARGV[0]).name,
            "install": "git" if IS_GIT_DIR else "pip" if IS_PIP_PACKAGE else "other",
            "os": ENVIRONMENT,
        }
        return event

    sentry_sdk.init(
        dsn="https://888e5a0778212e1d0314c37d4b9aae5d@o4504521589325824.ingest.us.sentry.io/4504521592406016",
        debug=False,
        auto_enabling_integrations=False,
        traces_sample_rate=1.0,
        release=__version__,
        environment="production",  # 'dev' or 'production'
        before_send=before_send,
        ignore_errors=[KeyboardInterrupt, FileNotFoundError],
    )
    sentry_sdk.set_user({"id": SETTINGS["uuid"]})  # SHA-256 anonymized UUID hash





ultralytics.utils.deprecation_warn

deprecation_warn(arg, new_arg)

Issue a deprecation warning when a deprecated argument is used, suggesting an updated argument.

Source code in ultralytics/utils/__init__.py
def deprecation_warn(arg, new_arg):
    """Issue a deprecation warning when a deprecated argument is used, suggesting an updated argument."""
    LOGGER.warning(f"WARNING ⚠️ '{arg}' is deprecated and will be removed in in the future. Use '{new_arg}' instead.")





ultralytics.utils.clean_url

clean_url(url)

Strip auth from URL, i.e. https://url.com/file.txt?auth -> https://url.com/file.txt.

Source code in ultralytics/utils/__init__.py
def clean_url(url):
    """Strip auth from URL, i.e. https://url.com/file.txt?auth -> https://url.com/file.txt."""
    url = Path(url).as_posix().replace(":/", "://")  # Pathlib turns :// -> :/, as_posix() for Windows
    return urllib.parse.unquote(url).split("?")[0]  # '%2F' to '/', split https://url.com/file.txt?auth





ultralytics.utils.url2file

url2file(url)

Convert URL to filename, i.e. https://url.com/file.txt?auth -> file.txt.

Source code in ultralytics/utils/__init__.py
def url2file(url):
    """Convert URL to filename, i.e. https://url.com/file.txt?auth -> file.txt."""
    return Path(clean_url(url)).name





ultralytics.utils.vscode_msg

vscode_msg(ext='ultralytics.ultralytics-snippets') -> str

Display a message to install Ultralytics-Snippets for VS Code if not already installed.

Source code in ultralytics/utils/__init__.py
def vscode_msg(ext="ultralytics.ultralytics-snippets") -> str:
    """Display a message to install Ultralytics-Snippets for VS Code if not already installed."""
    path = (USER_CONFIG_DIR.parents[2] if WINDOWS else USER_CONFIG_DIR.parents[1]) / ".vscode/extensions"
    obs_file = path / ".obsolete"  # file tracks uninstalled extensions, while source directory remains
    installed = any(path.glob(f"{ext}*")) and ext not in (obs_file.read_text("utf-8") if obs_file.exists() else "")
    url = "https://docs.ultralytics.com/integrations/vscode"
    return "" if installed else f"{colorstr('VS Code:')} view Ultralytics VS Code Extension ⚡ at {url}"




📅 Created 11 months ago ✏️ Updated 21 days ago