Saltar al contenido

Referencia para ultralytics/utils/__init__.py

Nota

Este archivo est谩 disponible en https://github.com/ultralytics/ ultralytics/blob/main/ ultralytics/utils/init.py. Si detectas alg煤n problema, por favor, ayuda a solucionarlo contribuyendo con una Pull Request 馃洜锔. 隆Gracias 馃檹!



ultralytics.utils.TQDM

Bases: tqdm

Clase personalizada Ultralytics tqdm con diferentes argumentos por defecto.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
*args list

Argumentos posicionales pasados al tqdm original.

()
**kwargs any

Argumentos de palabras clave, con valores predeterminados personalizados aplicados.

{}
C贸digo fuente en ultralytics/utils/__init__.py
class TQDM(tqdm_original):
    """
    Custom Ultralytics tqdm class with different default arguments.

    Args:
        *args (list): Positional arguments passed to original tqdm.
        **kwargs (any): Keyword arguments, with custom defaults applied.
    """

    def __init__(self, *args, **kwargs):
        """
        Initialize custom Ultralytics tqdm class with different default arguments.

        Note these can still be overridden when calling TQDM.
        """
        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)

__init__(*args, **kwargs)

Inicializa la clase personalizada Ultralytics tqdm con diferentes argumentos por defecto.

Ten en cuenta que a煤n se pueden anular al llamar a TQDM.

C贸digo fuente en ultralytics/utils/__init__.py
def __init__(self, *args, **kwargs):
    """
    Initialize custom Ultralytics tqdm class with different default arguments.

    Note these can still be overridden when calling TQDM.
    """
    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

Ultralytics SimpleClass es una clase base que proporciona una representaci贸n de cadenas 煤til, informes de errores y m茅todos de acceso a atributos para facilitar la depuraci贸n y el uso. para facilitar la depuraci贸n y el uso.

C贸digo fuente en ultralytics/utils/__init__.py
class SimpleClass:
    """Ultralytics SimpleClass is a base class providing helpful string representation, error reporting, and attribute
    access methods for easier debugging and usage.
    """

    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)

    def __repr__(self):
        """Return a machine-readable string representation of the object."""
        return self.__str__()

    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__}")

__getattr__(attr)

Mensaje de error personalizado de acceso a atributos con informaci贸n 煤til.

C贸digo fuente en 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__()

Devuelve una representaci贸n de cadena legible por m谩quina del objeto.

C贸digo fuente en ultralytics/utils/__init__.py
def __repr__(self):
    """Return a machine-readable string representation of the object."""
    return self.__str__()

__str__()

Devuelve una representaci贸n de cadena legible por humanos del objeto.

C贸digo fuente en 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

Ultralytics IterableSimpleNamespace es una clase de extensi贸n de SimpleNamespace que a帽ade funcionalidad iterable y permite su uso con dict() y bucles for.

C贸digo fuente en ultralytics/utils/__init__.py
class IterableSimpleNamespace(SimpleNamespace):
    """Ultralytics IterableSimpleNamespace is an extension class of SimpleNamespace that adds iterable functionality and
    enables usage with dict() and for loops.
    """

    def __iter__(self):
        """Return an iterator of key-value pairs from the namespace's attributes."""
        return iter(vars(self).items())

    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())

    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
            """
        )

    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)

__getattr__(attr)

Mensaje de error personalizado de acceso a atributos con informaci贸n 煤til.

C贸digo fuente en 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__()

Devuelve un iterador de pares clave-valor de los atributos del espacio de nombres.

C贸digo fuente en 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__()

Devuelve una representaci贸n de cadena legible por humanos del objeto.

C贸digo fuente en 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(key, default=None)

Devuelve el valor de la clave especificada si existe; en caso contrario, devuelve el valor por defecto.

C贸digo fuente en 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

Una clase decoradora para garantizar la ejecuci贸n segura de una funci贸n o m茅todo. Esta clase puede utilizarse como decorador para garantizar que, si la funci贸n decorada se llama desde varios subprocesos, s贸lo un subproceso a la vez podr谩 ejecutar la funci贸n. ejecutar la funci贸n.

Atributos:

Nombre Tipo Descripci贸n
lock Lock

Un objeto de bloqueo utilizado para gestionar el acceso a la funci贸n decorada.

Ejemplo
from ultralytics.utils import ThreadingLocked

@ThreadingLocked()
def my_function():
    # Your code here
    pass
C贸digo fuente en ultralytics/utils/__init__.py
class 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:
        lock (threading.Lock): A lock object used to manage access to the decorated function.

    Example:
        ```python
        from ultralytics.utils import ThreadingLocked

        @ThreadingLocked()
        def my_function():
            # Your code here
            pass
        ```
    """

    def __init__(self):
        """Initializes the decorator class for thread-safe execution of a function or method."""
        self.lock = threading.Lock()

    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

__call__(f)

Ejecuta una funci贸n o m茅todo a prueba de hilos.

C贸digo fuente en 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

__init__()

Inicializa la clase decoradora para la ejecuci贸n a prueba de hilos de una funci贸n o m茅todo.

C贸digo fuente en ultralytics/utils/__init__.py
def __init__(self):
    """Initializes the decorator class for thread-safe execution of a function or method."""
    self.lock = threading.Lock()



ultralytics.utils.TryExcept

Bases: ContextDecorator

Ultralytics Clase TryExcept. Util铆zalo como decorador @TryExcept() o gestor de contexto 'with TryExcept():'.

Ejemplos:

Como decorador:

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

Como gestor de contexto:

>>> with TryExcept(msg="Error occurred in block", verbose=True):
>>>     # Code block here
>>>     pass
C贸digo fuente en ultralytics/utils/__init__.py
class TryExcept(contextlib.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
    """

    def __init__(self, msg="", verbose=True):
        """Initialize TryExcept class with optional message and verbosity settings."""
        self.msg = msg
        self.verbose = verbose

    def __enter__(self):
        """Executes when entering TryExcept context, initializes instance."""
        pass

    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

__enter__()

Se ejecuta al entrar en el contexto TryExcept, inicializa la instancia.

C贸digo fuente en ultralytics/utils/__init__.py
def __enter__(self):
    """Executes when entering TryExcept context, initializes instance."""
    pass

__exit__(exc_type, value, traceback)

Define el comportamiento al salir de un bloque 'con', imprime un mensaje de error si es necesario.

C贸digo fuente en 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

__init__(msg='', verbose=True)

Inicializa la clase TryExcept con las opciones de mensaje y verbosidad.

C贸digo fuente en 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



ultralytics.utils.Retry

Bases: ContextDecorator

Clase de reintentos para la ejecuci贸n de funciones con backoff exponencial.

Puede utilizarse como decorador para reintentar una funci贸n en caso de excepci贸n, hasta un n煤mero especificado de veces con un retardo retraso exponencialmente creciente entre los reintentos.

Ejemplos:

Ejemplo de uso como decorador:

>>> @Retry(times=3, delay=2)
>>> def test_func():
>>>     # Replace with function logic that may raise exceptions
>>>     return True
C贸digo fuente en ultralytics/utils/__init__.py
class Retry(contextlib.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
    """

    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

    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

__call__(func)

Implementaci贸n de decorador para Reintento con backoff exponencial.

C贸digo fuente en 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

__init__(times=3, delay=2)

Inicializa la clase Reintentos con el n煤mero de reintentos y el retardo especificados.

C贸digo fuente en 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



ultralytics.utils.SettingsManager

Bases: dict

Gestiona los ajustes de Ultralytics almacenados en un archivo YAML.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
file str | Path

Ruta al archivo YAML de configuraci贸n de Ultralytics . Por defecto es USER_CONFIG_DIR / 'settings.yaml'.

SETTINGS_YAML
version str

Versi贸n de los ajustes. En caso de que la versi贸n local no coincida, se guardar谩n los nuevos ajustes por defecto.

'0.0.4'
C贸digo fuente en ultralytics/utils/__init__.py
class SettingsManager(dict):
    """
    Manages Ultralytics settings stored in a YAML file.

    Args:
        file (str | Path): Path to the Ultralytics settings YAML file. Default is USER_CONFIG_DIR / 'settings.yaml'.
        version (str): Settings version. In case of local version mismatch, new default settings will be saved.
    """

    def __init__(self, file=SETTINGS_YAML, version="0.0.4"):
        """Initialize the SettingsManager with default settings, load and validate current settings from the YAML
        file.
        """
        import copy
        import hashlib

        from ultralytics.utils.checks import check_version
        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,
            "datasets_dir": str(datasets_root / "datasets"),
            "weights_dir": str(root / "weights"),
            "runs_dir": str(root / "runs"),
            "uuid": hashlib.sha256(str(uuid.getnode()).encode()).hexdigest(),
            "sync": True,
            "api_key": "",
            "openai_api_key": "",
            "clearml": True,  # integrations
            "comet": True,
            "dvc": True,
            "hub": True,
            "mlflow": True,
            "neptune": True,
            "raytune": True,
            "tensorboard": True,
            "wandb": True,
        }

        super().__init__(copy.deepcopy(self.defaults))

        with torch_distributed_zero_first(RANK):
            if not self.file.exists():
                self.save()

            self.load()
            correct_keys = self.keys() == self.defaults.keys()
            correct_types = all(type(a) is type(b) for a, b in zip(self.values(), self.defaults.values()))
            correct_version = check_version(self["settings_version"], self.version)
            help_msg = (
                f"\nView 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."
            )
            if not (correct_keys and correct_types and correct_version):
                LOGGER.warning(
                    "WARNING 鈿狅笍 Ultralytics settings reset to default values. This may be due to a possible problem "
                    f"with your settings or a recent ultralytics package update. {help_msg}"
                )
                self.reset()

            if self.get("datasets_dir") == self.get("runs_dir"):
                LOGGER.warning(
                    f"WARNING 鈿狅笍 Ultralytics setting 'datasets_dir: {self.get('datasets_dir')}' "
                    f"must be different than 'runs_dir: {self.get('runs_dir')}'. "
                    f"Please change one to avoid possible issues during training. {help_msg}"
                )

    def load(self):
        """Loads settings from the YAML file."""
        super().update(yaml_load(self.file))

    def save(self):
        """Saves the current settings to the YAML file."""
        yaml_save(self.file, dict(self))

    def update(self, *args, **kwargs):
        """Updates a setting value in the current settings."""
        super().update(*args, **kwargs)
        self.save()

    def reset(self):
        """Resets the settings to default and saves them."""
        self.clear()
        self.update(self.defaults)
        self.save()

__init__(file=SETTINGS_YAML, version='0.0.4')

Inicializa el SettingsManager con la configuraci贸n por defecto, carga y valida la configuraci贸n actual desde el archivo YAML del archivo YAML.

C贸digo fuente en ultralytics/utils/__init__.py
def __init__(self, file=SETTINGS_YAML, version="0.0.4"):
    """Initialize the SettingsManager with default settings, load and validate current settings from the YAML
    file.
    """
    import copy
    import hashlib

    from ultralytics.utils.checks import check_version
    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,
        "datasets_dir": str(datasets_root / "datasets"),
        "weights_dir": str(root / "weights"),
        "runs_dir": str(root / "runs"),
        "uuid": hashlib.sha256(str(uuid.getnode()).encode()).hexdigest(),
        "sync": True,
        "api_key": "",
        "openai_api_key": "",
        "clearml": True,  # integrations
        "comet": True,
        "dvc": True,
        "hub": True,
        "mlflow": True,
        "neptune": True,
        "raytune": True,
        "tensorboard": True,
        "wandb": True,
    }

    super().__init__(copy.deepcopy(self.defaults))

    with torch_distributed_zero_first(RANK):
        if not self.file.exists():
            self.save()

        self.load()
        correct_keys = self.keys() == self.defaults.keys()
        correct_types = all(type(a) is type(b) for a, b in zip(self.values(), self.defaults.values()))
        correct_version = check_version(self["settings_version"], self.version)
        help_msg = (
            f"\nView 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."
        )
        if not (correct_keys and correct_types and correct_version):
            LOGGER.warning(
                "WARNING 鈿狅笍 Ultralytics settings reset to default values. This may be due to a possible problem "
                f"with your settings or a recent ultralytics package update. {help_msg}"
            )
            self.reset()

        if self.get("datasets_dir") == self.get("runs_dir"):
            LOGGER.warning(
                f"WARNING 鈿狅笍 Ultralytics setting 'datasets_dir: {self.get('datasets_dir')}' "
                f"must be different than 'runs_dir: {self.get('runs_dir')}'. "
                f"Please change one to avoid possible issues during training. {help_msg}"
            )

load()

Carga la configuraci贸n desde el archivo YAML.

C贸digo fuente en ultralytics/utils/__init__.py
def load(self):
    """Loads settings from the YAML file."""
    super().update(yaml_load(self.file))

reset()

Restablece los ajustes por defecto y gu谩rdalos.

C贸digo fuente en ultralytics/utils/__init__.py
def reset(self):
    """Resets the settings to default and saves them."""
    self.clear()
    self.update(self.defaults)
    self.save()

save()

Guarda la configuraci贸n actual en el archivo YAML.

C贸digo fuente en ultralytics/utils/__init__.py
def save(self):
    """Saves the current settings to the YAML file."""
    yaml_save(self.file, dict(self))

update(*args, **kwargs)

Actualiza un valor de configuraci贸n en los ajustes actuales.

C贸digo fuente en ultralytics/utils/__init__.py
def update(self, *args, **kwargs):
    """Updates a setting value in the current settings."""
    super().update(*args, **kwargs)
    self.save()



ultralytics.utils.plt_settings(rcparams=None, backend='Agg')

Decorador para establecer temporalmente los par谩metros rc y el backend de una funci贸n de trazado.

Ejemplo

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

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
rcparams dict

Diccionario de par谩metros rc a ajustar.

None
backend str

Nombre del backend a utilizar. Por defecto es 'Agg'.

'Agg'

Devuelve:

Tipo Descripci贸n
Callable

Funci贸n decorada con par谩metros rc y backend establecidos temporalmente. Este decorador se puede aplicado a cualquier funci贸n que necesite tener par谩metros rc y backend matplotlib espec铆ficos para su ejecuci贸n.

C贸digo fuente en 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()
            if backend.lower() != original_backend.lower():
                plt.close("all")  # auto-close()ing of figures upon backend switching is deprecated since 3.8
                plt.switch_backend(backend)

            with plt.rc_context(rcparams):
                result = func(*args, **kwargs)

            if backend != original_backend:
                plt.close("all")
                plt.switch_backend(original_backend)
            return result

        return wrapper

    return decorator



ultralytics.utils.set_logging(name='LOGGING_NAME', verbose=True)

Configura el registro para el nombre dado con soporte de codificaci贸n UTF-8, asegurando la compatibilidad en distintos entornos.

C贸digo fuente en ultralytics/utils/__init__.py
def set_logging(name="LOGGING_NAME", verbose=True):
    """Sets up logging for the given name with UTF-8 encoding support, ensuring compatibility across different
    environments.
    """
    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(string='')

Devuelve la versi贸n segura para emoji de la cadena seg煤n la plataforma.

C贸digo fuente en 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(file='data.yaml', data=None, header='')

Guarda los datos YAML en un archivo.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
file str

Nombre del archivo. Por defecto es 'data.yaml'.

'data.yaml'
data dict

Datos a guardar en formato YAML.

None
header str

Cabecera YAML a a帽adir.

''

Devuelve:

Tipo Descripci贸n
None

Los datos se guardan en el archivo especificado.

C贸digo fuente en 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(file='data.yaml', append_filename=False)

Carga datos YAML de un archivo.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
file str

Nombre del archivo. Por defecto es 'data.yaml'.

'data.yaml'
append_filename bool

A帽ade el nombre del archivo YAML al diccionario YAML. Por defecto es Falso.

False

Devuelve:

Tipo Descripci贸n
dict

Datos YAML y nombre del archivo.

C贸digo fuente en 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_file)

Imprime un archivo YAML o un diccionario con formato YAML.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
yaml_file Union[str, Path, dict]

La ruta del archivo YAML o de un diccionario con formato YAML.

necesario

Devuelve:

Tipo Descripci贸n
None

(Ninguno)

C贸digo fuente en 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)
    LOGGER.info(f"Printing '{colorstr('bold', 'black', yaml_file)}'\n\n{dump}")



ultralytics.utils.read_device_model()

Lee la informaci贸n del modelo de dispositivo del sistema y la almacena en cach茅 para un acceso r谩pido. Utilizado por is_jetson() y is_raspberrypi().

Devuelve:

Tipo Descripci贸n
str

Contenido del fichero modelo si se lee correctamente o cadena vac铆a en caso contrario.

C贸digo fuente en 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.
    """
    with contextlib.suppress(Exception):
        with open("/proc/device-tree/model") as f:
            return f.read()
    return ""



ultralytics.utils.is_ubuntu()

Comprueba si el SO es Ubuntu.

Devuelve:

Tipo Descripci贸n
bool

Verdadero si el SO es Ubuntu, Falso en caso contrario.

C贸digo fuente en ultralytics/utils/__init__.py
def is_ubuntu() -> bool:
    """
    Check if the OS is Ubuntu.

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



ultralytics.utils.is_colab()

Comprueba si el script actual se est谩 ejecutando dentro de un bloc de notas de Google Colab.

Devuelve:

Tipo Descripci贸n
bool

Verdadero si se ejecuta dentro de un cuaderno Colab, Falso en caso contrario.

C贸digo fuente en 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()

Comprueba si el script actual se est谩 ejecutando dentro de un n煤cleo Kaggle.

Devuelve:

Tipo Descripci贸n
bool

True si se ejecuta dentro de un n煤cleo Kaggle, False en caso contrario.

C贸digo fuente en 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()

Comprueba si el script actual se est谩 ejecutando dentro de un Jupyter Notebook. Verificado en Colab, Jupyterlab, Kaggle, Paperspace.

Devuelve:

Tipo Descripci贸n
bool

True si se ejecuta dentro de un Jupyter Notebook, False en caso contrario.

C贸digo fuente en 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.
    """
    with contextlib.suppress(Exception):
        from IPython import get_ipython

        return get_ipython() is not None
    return False



ultralytics.utils.is_docker()

Determina si el script se est谩 ejecutando dentro de un contenedor Docker.

Devuelve:

Tipo Descripci贸n
bool

True si el script se est谩 ejecutando dentro de un contenedor Docker, False en caso contrario.

C贸digo fuente en 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.
    """
    with contextlib.suppress(Exception):
        with open("/proc/self/cgroup") as f:
            return "docker" in f.read()
    return False



ultralytics.utils.is_raspberrypi()

Determina si el entorno Python se est谩 ejecutando en una Raspberry Pi comprobando la informaci贸n del modelo del dispositivo.

Devuelve:

Tipo Descripci贸n
bool

Verdadero si se ejecuta en una Raspberry Pi, Falso en caso contrario.

C贸digo fuente en 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()

Determina si el entorno Python se est谩 ejecutando en un dispositivo Jetson Nano o Jetson Orin comprobando la informaci贸n del modelo de dispositivo del dispositivo.

Devuelve:

Tipo Descripci贸n
bool

Verdadero si se ejecuta en una Jetson Nano o una Jetson Orin, Falso en caso contrario.

C贸digo fuente en 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()

Comprueba la conectividad a Internet intentando conectarte a un host online conocido.

Devuelve:

Tipo Descripci贸n
bool

Verdadero si la conexi贸n tiene 茅xito, Falso en caso contrario.

C贸digo fuente en 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.
    """
    with contextlib.suppress(Exception):
        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
    return False



ultralytics.utils.is_pip_package(filepath=__name__)

Determina si el archivo de la ruta dada forma parte de un paquete pip.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
filepath str

La ruta del archivo a comprobar.

__name__

Devuelve:

Tipo Descripci贸n
bool

True si el archivo forma parte de un paquete pip, False en caso contrario.

C贸digo fuente en 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(dir_path)

Comprueba si se puede escribir en un directorio.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
dir_path str | Path

La ruta al directorio.

necesario

Devuelve:

Tipo Descripci贸n
bool

True si el directorio es escribible, False en caso contrario.

C贸digo fuente en 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()

Determina si pytest se est谩 ejecutando o no.

Devuelve:

Tipo Descripci贸n
bool

Verdadero si pytest se est谩 ejecutando, Falso en caso contrario.

C贸digo fuente en 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()

Determina si el entorno actual es un ejecutor de Acciones de GitHub.

Devuelve:

Tipo Descripci贸n
bool

True si el entorno actual es un ejecutor de Acciones de GitHub, False en caso contrario.

C贸digo fuente en 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()

Determina si el archivo actual forma parte de un repositorio git y, en caso afirmativo, devuelve el directorio ra铆z del repositorio. Si el archivo actual no forma parte de un repositorio git, devuelve Ninguno.

Devuelve:

Tipo Descripci贸n
Path | None

Directorio ra铆z de Git si se encuentra o Ninguno si no se encuentra.

C贸digo fuente en 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()

Determina si el archivo actual forma parte de un repositorio git. Si el archivo actual no forma parte de un repositorio git devuelve Ninguno.

Devuelve:

Tipo Descripci贸n
bool

Verdadero si el archivo actual forma parte de un repositorio git.

C贸digo fuente en 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()

Recupera la URL de origen de un repositorio git.

Devuelve:

Tipo Descripci贸n
str | None

La URL de origen del repositorio git o Ninguno si no es el directorio git.

C贸digo fuente en 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:
        with contextlib.suppress(subprocess.CalledProcessError):
            origin = subprocess.check_output(["git", "config", "--get", "remote.origin.url"])
            return origin.decode().strip()



ultralytics.utils.get_git_branch()

Devuelve el nombre de la rama git actual. Si no est谩 en un repositorio git, devuelve Ninguno.

Devuelve:

Tipo Descripci贸n
str | None

El nombre de la rama git actual o Ninguno si no es un directorio git.

C贸digo fuente en 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:
        with contextlib.suppress(subprocess.CalledProcessError):
            origin = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
            return origin.decode().strip()



ultralytics.utils.get_default_args(func)

Devuelve un diccionario de argumentos por defecto para una funci贸n.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
func callable

La funci贸n a inspeccionar.

necesario

Devuelve:

Tipo Descripci贸n
dict

Un diccionario en el que cada clave es un nombre de par谩metro, y cada valor es el valor por defecto de ese par谩metro.

C贸digo fuente en 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()

Recupera la versi贸n de Ubuntu si el SO es Ubuntu.

Devuelve:

Tipo Descripci贸n
str

Versi贸n de Ubuntu o Ninguna si no es un SO Ubuntu.

C贸digo fuente en 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():
        with contextlib.suppress(FileNotFoundError, AttributeError):
            with open("/etc/os-release") as f:
                return re.search(r'VERSION_ID="(\d+\.\d+)"', f.read())[1]



ultralytics.utils.get_user_config_dir(sub_dir='Ultralytics')

Devuelve el directorio de configuraci贸n adecuado en funci贸n del sistema operativo del entorno.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
sub_dir str

El nombre del subdirectorio a crear.

'Ultralytics'

Devuelve:

Tipo Descripci贸n
Path

La ruta al directorio de configuraci贸n del usuario.

C贸digo fuente en 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(*input)

Colorea una cadena bas谩ndote en los argumentos de color y estilo proporcionados. Utiliza c贸digos de escape ANSI. Consulta https://en.wikipedia.org/wiki/ANSI_escape_code para m谩s detalles.

Esta funci贸n se puede llamar de dos formas
  • colorstr('color', 'estilo', 'tu cadena')
  • colorstr('tu cadena')

En el segundo formulario, se aplicar谩n por defecto "azul" y "negrita".

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
*input str

Una secuencia de cadenas donde las primeras n-1 cadenas son argumentos de color y estilo, y la 煤ltima cadena es la que se va a colorear.

()
Colores y estilos admitidos

Colores b谩sicos: 'negro', 'rojo', 'verde', 'amarillo', 'azul', 'magenta', 'cian', 'blanco' Colores brillantes: 'negro_brillante', 'rojo_brillante', 'verde_brillante', 'amarillo_brillante', azul_brillante, magenta_brillante, cian_brillante, blanco_brillante Misc: 'fin', 'negrita', 'subrayado'

Devuelve:

Tipo Descripci贸n
str

La cadena de entrada envuelta con c贸digos de escape ANSI para el color y estilo especificados.

Ejemplos:

>>> colorstr("blue", "bold", "hello world")
>>> "hello world"
C贸digo fuente en ultralytics/utils/__init__.py
def 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.

    Args:
        *input (str): 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(input_string)

Elimina los c贸digos de escape ANSI de una cadena, des colore谩ndola.

Par谩metros:

Nombre Tipo Descripci贸n Por defecto
input_string str

La cadena de la que eliminar el color y el estilo.

necesario

Devuelve:

Tipo Descripci贸n
str

Una nueva cadena con todos los c贸digos de escape ANSI eliminados.

Ejemplos:

>>> remove_colorstr(colorstr('blue', 'bold', 'hello world'))
>>> 'hello world'
C贸digo fuente en 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(func)

Multihilo de una funci贸n objetivo por defecto y devuelve el hilo o el resultado de la funci贸n.

Util铆zalo como decorador @threaded. La funci贸n se ejecuta en un hilo independiente a menos que se pase 'threaded=False'.

C贸digo fuente en 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()

Inicializa el SDK Sentry para el seguimiento y notificaci贸n de errores. S贸lo se utiliza si el paquete sentry_sdk est谩 instalado y sync=True en la configuraci贸n. Ejecuta 'yolo settings' para ver y actualizar el archivo YAML de configuraci贸n.

Condiciones necesarias para enviar errores (deben cumplirse TODAS las condiciones o no se informar谩 de los errores): - el paquete sentry_sdk est谩 instalado - sync=True en los ajustes de YOLO - pytest no se est谩 ejecutando - ejecut谩ndose en una instalaci贸n de paquete pip - se ejecuta en un directorio que no es git - ejecut谩ndose con rango -1 o 0 - entorno en l铆nea - CLI utilizado para ejecutar el paquete (comprobado con 'yolo' como nombre del comando principal CLI )

La funci贸n tambi茅n configura Sentry SDK para que ignore las excepciones KeyboardInterrupt y FileNotFoundError y para excluir los eventos con "sin memoria" en su mensaje de excepci贸n.

Adem谩s, la funci贸n establece etiquetas personalizadas e informaci贸n de usuario para los eventos de Sentry.

C贸digo fuente en 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 YAML file.

    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.
    """

    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, tb = 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

    if (
        SETTINGS["sync"]
        and RANK in {-1, 0}
        and Path(ARGV[0]).name == "yolo"
        and not TESTS_RUNNING
        and ONLINE
        and IS_PIP_PACKAGE
        and not IS_GIT_DIR
    ):
        # If sentry_sdk package is not installed then return and do not use Sentry
        try:
            import sentry_sdk  # noqa
        except ImportError:
            return

        sentry_sdk.init(
            dsn="https://5ff1556b71594bfea135ff0203a0d290@o4504521589325824.ingest.sentry.io/4504521592406016",
            debug=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(arg, new_arg, version=None)

Emitir un aviso de obsoleto cuando se utilice un argumento obsoleto, sugiriendo un argumento actualizado.

C贸digo fuente en ultralytics/utils/__init__.py
def deprecation_warn(arg, new_arg, version=None):
    """Issue a deprecation warning when a deprecated argument is used, suggesting an updated argument."""
    if not version:
        version = float(__version__[:3]) + 0.2  # deprecate after 2nd major release
    LOGGER.warning(
        f"WARNING 鈿狅笍 '{arg}' is deprecated and will be removed in 'ultralytics {version}' in the future. "
        f"Please use '{new_arg}' instead."
    )



ultralytics.utils.clean_url(url)

Elimina la autenticidad de la URL, es decir, https://url.com/file.txt?auth -> https://url.com/file.txt.

C贸digo fuente en 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(url)

Convierte la URL en nombre de archivo, es decir, https://url.com/file.txt?auth -> archivo.txt.

C贸digo fuente en 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





Creado 2023-11-12, Actualizado 2024-05-18
Autores: glenn-jocher (9), Burhan-Q (1), Laughing-q (1)