Bỏ để qua phần nội dung

Tài liệu tham khảo cho ultralytics/utils/__init__.py

Ghi

Tệp này có sẵn tại https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/init.py. Nếu bạn phát hiện ra một vấn đề, vui lòng giúp khắc phục nó bằng cách đóng góp Yêu cầu 🛠️ kéo. Cảm ơn bạn 🙏 !



ultralytics.utils.TQDM

Căn cứ: tqdm

Phong tục Ultralytics Lớp TQDM với các đối số mặc định khác nhau.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
*args list

Các đối số vị trí được chuyển sang tqdm ban đầu.

()
**kwargs any

Đối số từ khóa, với mặc định tùy chỉnh được áp dụng.

{}
Mã nguồn trong 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)

Khởi tạo tùy chỉnh Ultralytics Lớp TQDM với các đối số mặc định khác nhau.

Lưu ý rằng chúng vẫn có thể bị ghi đè khi gọi TQDM.

Mã nguồn trong 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 là một lớp cơ sở cung cấp biểu diễn chuỗi, báo cáo lỗi và thuộc tính hữu ích Phương pháp truy cập để gỡ lỗi và sử dụng dễ dàng hơn.

Mã nguồn trong 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)

Thông báo lỗi truy cập thuộc tính tùy chỉnh với thông tin hữu ích.

Mã nguồn trong 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__()

Trả về biểu diễn chuỗi có thể đọc được bằng máy của đối tượng.

Mã nguồn trong ultralytics/utils/__init__.py
def __repr__(self):
    """Return a machine-readable string representation of the object."""
    return self.__str__()

__str__()

Trả về biểu diễn chuỗi mà con người có thể đọc được của đối tượng.

Mã nguồn trong 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

Căn cứ: SimpleNamespace

Ultralytics IterableSimpleNamespace là một lớp mở rộng của SimpleNamespace bổ sung chức năng lặp lại và cho phép sử dụng với dict() và cho các vòng lặp.

Mã nguồn trong 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)

Thông báo lỗi truy cập thuộc tính tùy chỉnh với thông tin hữu ích.

Mã nguồn trong 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__()

Trả về một vòng lặp của các cặp khóa-giá trị từ các thuộc tính của vùng chứa tên.

Mã nguồn trong 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__()

Trả về biểu diễn chuỗi mà con người có thể đọc được của đối tượng.

Mã nguồn trong 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)

Trả về giá trị của khóa được chỉ định nếu nó tồn tại; nếu không, hãy trả về giá trị mặc định.

Mã nguồn trong 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

Một lớp trang trí để đảm bảo thực thi an toàn luồng của một hàm hoặc phương thức. Lớp này có thể được sử dụng như một trang trí Để đảm bảo rằng nếu chức năng trang trí được gọi từ nhiều luồng, chỉ một luồng tại một thời điểm sẽ có thể để thực hiện hàm.

Thuộc tính:

Tên Kiểu Sự miêu tả
lock Lock

Một đối tượng khóa được sử dụng để quản lý quyền truy cập vào chức năng trang trí.

Ví dụ
from ultralytics.utils import ThreadingLocked

@ThreadingLocked()
def my_function():
    # Your code here
    pass
Mã nguồn trong 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)

Chạy thực thi thread-safe của hàm hoặc phương thức.

Mã nguồn trong 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__()

Khởi tạo lớp decorator để thực thi thread-safe của một hàm hoặc phương thức.

Mã nguồn trong 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

Căn cứ: ContextDecorator

Ultralytics Lớp TryExcept . Sử dụng làm trình trang trí @TryExcept() hoặc trình quản lý ngữ cảnh 'với TryExcept():'.

Ví dụ:

Là một người trang trí:

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

Là người quản lý ngữ cảnh:

>>> with TryExcept(msg="Error occurred in block", verbose=True):
>>>     # Code block here
>>>     pass
Mã nguồn trong 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__()

Thực thi khi nhập ngữ cảnh TryExcept , khởi tạo instance.

Mã nguồn trong ultralytics/utils/__init__.py
def __enter__(self):
    """Executes when entering TryExcept context, initializes instance."""
    pass

__exit__(exc_type, value, traceback)

Xác định hành vi khi thoát khỏi khối 'với', in thông báo lỗi nếu cần.

Mã nguồn trong 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)

Khởi tạo lớp TryExcept với cài đặt thông điệp và độ chi tiết tùy chọn.

Mã nguồn trong 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

Căn cứ: ContextDecorator

Thử lại lớp để thực thi hàm với backoff theo cấp số nhân.

Có thể được sử dụng như một người trang trí để thử lại một chức năng trên các trường hợp ngoại lệ, tối đa một số lần được chỉ định với một độ trễ tăng theo cấp số nhân giữa các lần thử lại.

Ví dụ:

Ví dụ sử dụng như một người trang trí:

>>> @Retry(times=3, delay=2)
>>> def test_func():
>>>     # Replace with function logic that may raise exceptions
>>>     return True
Mã nguồn trong 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)

Triển khai trang trí cho Thử lại với backoff theo cấp số nhân.

Mã nguồn trong 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)

Khởi tạo lớp Retry với số lần thử lại và độ trễ được chỉ định.

Mã nguồn trong 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

Căn cứ: dict

Quản lý Ultralytics cài đặt được lưu trữ trong tệp YAML.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
file str | Path

Đường dẫn đến Ultralytics cài đặt tệp YAML. Mặc định là USER_CONFIG_DIR / 'settings.yaml'.

SETTINGS_YAML
version str

Phiên bản cài đặt. Trong trường hợp phiên bản cục bộ không khớp, cài đặt mặc định mới sẽ được lưu.

'0.0.4'
Mã nguồn trong 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')

Khởi tạo SettingsManager với các cài đặt mặc định, tải và xác thực các cài đặt hiện tại từ YAML tệp.

Mã nguồn trong 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()

Tải cài đặt từ tệp YAML.

Mã nguồn trong ultralytics/utils/__init__.py
def load(self):
    """Loads settings from the YAML file."""
    super().update(yaml_load(self.file))

reset()

Đặt lại cài đặt về mặc định và lưu chúng.

Mã nguồn trong ultralytics/utils/__init__.py
def reset(self):
    """Resets the settings to default and saves them."""
    self.clear()
    self.update(self.defaults)
    self.save()

save()

Lưu cài đặt hiện tại vào tệp YAML.

Mã nguồn trong ultralytics/utils/__init__.py
def save(self):
    """Saves the current settings to the YAML file."""
    yaml_save(self.file, dict(self))

update(*args, **kwargs)

Cập nhật giá trị cài đặt trong cài đặt hiện tại.

Mã nguồn trong 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')

Trang trí để tạm thời thiết lập các tham số rc và phụ trợ cho chức năng vẽ.

Ví dụ

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

Thông số:

Tên Kiểu Sự miêu tả Mặc định
rcparams dict

Từ điển các tham số rc để thiết lập.

None
backend str

Tên của backend để sử dụng. Mặc định là 'Agg'.

'Agg'

Trở lại:

Kiểu Sự miêu tả
Callable

Chức năng trang trí với các thông số rc được thiết lập tạm thời và phụ trợ. Trang trí này có thể là Áp dụng cho bất kỳ chức năng nào cần có các tham số Matplotlib RC cụ thể và phụ trợ để thực thi.

Mã nguồn trong 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)

Thiết lập ghi nhật ký cho tên đã cho với hỗ trợ mã hóa UTF-8, đảm bảo khả năng tương thích giữa các tên khác nhau Môi trường.

Mã nguồn trong 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='')

Trả lại phiên bản chuỗi an toàn cho biểu tượng cảm xúc phụ thuộc vào nền tảng.

Mã nguồn trong 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='')

Lưu dữ liệu YAML vào một tệp.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
file str

Tên tập tin. Mặc định là 'data.yaml'.

'data.yaml'
data dict

Dữ liệu cần lưu ở định dạng YAML.

None
header str

Tiêu đề YAML để thêm.

''

Trở lại:

Kiểu Sự miêu tả
None

Dữ liệu được lưu vào tệp được chỉ định.

Mã nguồn trong 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)

Tải dữ liệu YAML từ một tệp.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
file str

Tên tập tin. Mặc định là 'data.yaml'.

'data.yaml'
append_filename bool

Thêm tên tệp YAML vào từ điển YAML. Mặc định là False.

False

Trở lại:

Kiểu Sự miêu tả
dict

Dữ liệu YAML và tên tệp.

Mã nguồn trong 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)

Pretty in một tập tin YAML hoặc một từ điển định dạng YAML.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
yaml_file Union[str, Path, dict]

Đường dẫn tệp của tệp YAML hoặc từ điển định dạng YAML.

bắt buộc

Trở lại:

Kiểu Sự miêu tả
None

(Không có)

Mã nguồn trong 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()

Đọc thông tin kiểu thiết bị từ hệ thống và lưu vào bộ nhớ cache để truy cập nhanh. Được sử dụng bởi is_jetson() và is_raspberrypi().

Trở lại:

Kiểu Sự miêu tả
str

Mô hình hóa nội dung tệp nếu đọc thành công hoặc chuỗi trống khác.

Mã nguồn trong 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()

Kiểm tra xem hệ điều hành có phải là Ubuntu không.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu OS là Ubuntu, False nếu không.

Mã nguồn trong 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()

Kiểm tra xem tập lệnh hiện tại có đang chạy bên trong sổ ghi chép Google Colab hay không.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu chạy bên trong sổ ghi chép Colab, False nếu không.

Mã nguồn trong 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()

Kiểm tra xem tập lệnh hiện tại có đang chạy bên trong hạt nhân Kaggle hay không.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu chạy bên trong hạt nhân Kaggle, False nếu không.

Mã nguồn trong 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()

Kiểm tra xem tập lệnh hiện tại có đang chạy bên trong Jupyter Notebook hay không. Được xác minh trên Colab, Jupyterlab, Kaggle, Paperspace.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu chạy bên trong Jupyter Notebook, False nếu không.

Mã nguồn trong 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()

Xác định xem tập lệnh có đang chạy bên trong bộ chứa Docker hay không.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu script đang chạy bên trong Docker container, False nếu không.

Mã nguồn trong 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()

Xác định xem Python môi trường đang chạy trên Raspberry Pi bằng cách kiểm tra thông tin mô hình thiết bị.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu chạy trên Raspberry Pi, False nếu không.

Mã nguồn trong 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()

Xác định xem Python môi trường đang chạy trên thiết bị Jetson Nano hoặc Jetson Orin bằng cách kiểm tra kiểu thiết bị thông tin.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu chạy trên Jetson Nano hoặc Jetson Orin, False nếu không.

Mã nguồn trong 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()

Kiểm tra kết nối internet bằng cách cố gắng kết nối với một máy chủ trực tuyến đã biết.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu kết nối thành công, False nếu không.

Mã nguồn trong 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__)

Xác định xem tệp tại đường dẫn tệp đã cho có phải là một phần của gói pip hay không.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
filepath str

Đường dẫn tệp để kiểm tra.

__name__

Trở lại:

Kiểu Sự miêu tả
bool

True nếu tệp là một phần của gói pip, False nếu không.

Mã nguồn trong 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)

Kiểm tra xem một thư mục có thể ghi được không.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
dir_path str | Path

Đường dẫn đến thư mục.

bắt buộc

Trở lại:

Kiểu Sự miêu tả
bool

True nếu thư mục có thể ghi được, False nếu không.

Mã nguồn trong 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()

Xác định xem pytest hiện có đang chạy hay không.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu pytest đang chạy, False nếu không.

Mã nguồn trong 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()

Xác định xem môi trường hiện tại có phải là trình chạy GitHub Actions hay không.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu môi trường hiện tại là GitHub Actions runner, False nếu không.

Mã nguồn trong 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()

Xác định xem tệp hiện tại có phải là một phần của kho lưu trữ git hay không và nếu có, trả về thư mục gốc của kho lưu trữ. Nếu tệp hiện tại không phải là một phần của kho lưu trữ git, trả về Không có.

Trở lại:

Kiểu Sự miêu tả
Path | None

Thư mục gốc Git nếu tìm thấy hoặc Không có nếu không tìm thấy.

Mã nguồn trong 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()

Xác định xem tệp hiện tại có phải là một phần của kho lưu trữ git hay không. Nếu tệp hiện tại không phải là một phần của git kho lưu trữ, trả về Không có.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu tệp hiện tại là một phần của kho lưu trữ git.

Mã nguồn trong 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()

Truy xuất URL gốc của kho lưu trữ git.

Trở lại:

Kiểu Sự miêu tả
str | None

URL gốc của git repository hoặc None nếu không phải là thư mục git.

Mã nguồn trong 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()

Trả về tên nhánh git hiện tại. Nếu không có trong kho lưu trữ git, trả về Không có.

Trở lại:

Kiểu Sự miêu tả
str | None

Tên nhánh git hiện tại hoặc Không có nếu không phải là thư mục git.

Mã nguồn trong 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)

Trả về từ điển các đối số mặc định cho một hàm.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
func callable

Chức năng kiểm tra.

bắt buộc

Trở lại:

Kiểu Sự miêu tả
dict

Từ điển trong đó mỗi khóa là một tên tham số và mỗi giá trị là giá trị mặc định của tham số đó.

Mã nguồn trong 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()

Truy xuất phiên bản Ubuntu nếu HĐH là Ubuntu.

Trở lại:

Kiểu Sự miêu tả
str

Phiên bản Ubuntu hoặc Không có nếu không phải là hệ điều hành Ubuntu.

Mã nguồn trong 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')

Trả về thư mục cấu hình thích hợp dựa trên hệ điều hành môi trường.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
sub_dir str

Tên của thư mục con để tạo.

'Ultralytics'

Trở lại:

Kiểu Sự miêu tả
Path

Đường dẫn đến thư mục cấu hình người dùng.

Mã nguồn trong 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)

Tô màu một chuỗi dựa trên các đối số màu và kiểu được cung cấp. Sử dụng mã thoát ANSI. Xem https://en.wikipedia.org/wiki/ANSI_escape_code để biết thêm chi tiết.

Hàm này có thể được gọi theo hai cách:
  • colorstr('màu', 'kiểu', 'chuỗi của bạn')
  • colorstr ('chuỗi của bạn')

Ở dạng thứ hai, 'xanh dương' và 'đậm' sẽ được áp dụng theo mặc định.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
*input str

Một chuỗi các chuỗi trong đó chuỗi n-1 đầu tiên là các đối số màu và kiểu, và chuỗi cuối cùng là chuỗi được tô màu.

()
Màu sắc và kiểu dáng được hỗ trợ

Màu cơ bản: 'đen', 'đỏ', 'xanh lá cây', 'vàng', 'xanh dương', 'đỏ tươi', 'lục lam', 'trắng' Màu sắc tươi sáng: 'bright_black', 'bright_red', 'bright_green', 'bright_yellow', 'bright_blue', 'bright_magenta', 'bright_cyan', 'bright_white' Misc: 'kết thúc', 'đậm', 'gạch chân'

Trở lại:

Kiểu Sự miêu tả
str

Chuỗi đầu vào được bọc bằng mã thoát ANSI cho màu sắc và kiểu dáng được chỉ định.

Ví dụ:

>>> colorstr("blue", "bold", "hello world")
>>> "hello world"
Mã nguồn trong 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)

Loại bỏ mã thoát ANSI khỏi một chuỗi, bỏ tô màu nó một cách hiệu quả.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
input_string str

Chuỗi để loại bỏ màu sắc và kiểu dáng.

bắt buộc

Trở lại:

Kiểu Sự miêu tả
str

Một chuỗi mới với tất cả các mã thoát ANSI bị xóa.

Ví dụ:

>>> remove_colorstr(colorstr('blue', 'bold', 'hello world'))
>>> 'hello world'
Mã nguồn trong 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)

Đa luồng một hàm đích theo mặc định và trả về kết quả chuỗi hoặc hàm.

Sử dụng như @threaded trang trí. Hàm chạy trong một luồng riêng biệt trừ khi 'threaded = False' được thông qua.

Mã nguồn trong 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()

Khởi tạo Sentry SDK để theo dõi và báo cáo lỗi. Chỉ được sử dụng nếu gói sentry_sdk được cài đặt và sync=True trong cài đặt. Chạy 'yolo cài đặt 'để xem và cập nhật cài đặt tệp YAML.

Các điều kiện cần thiết để gửi lỗi (TẤT CẢ các điều kiện phải được đáp ứng hoặc sẽ không có lỗi nào được báo cáo): - sentry_sdk gói được cài đặt - sync=True trong YOLO Cài đặt - pytest không chạy - chạy trong cài đặt gói pip - chạy trong một thư mục không phải git - Chạy với thứ hạng -1 hoặc 0 - Môi trường trực tuyến - CLI được sử dụng để chạy gói (kiểm tra với 'yolo' như tên của chính CLI chỉ huy)

Chức năng này cũng cấu hình Sentry SDK để bỏ qua KeyboardInterrupt và FileNotFoundError ngoại lệ và để loại trừ các sự kiện có 'hết bộ nhớ' trong thông báo ngoại lệ.

Ngoài ra, hàm đặt thẻ tùy chỉnh và thông tin người dùng cho các sự kiện Sentry.

Mã nguồn trong 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)

Đưa ra cảnh báo không dùng nữa khi sử dụng đối số không dùng nữa, đề xuất đối số cập nhật.

Mã nguồn trong 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)

Dải auth từ URL, tức là https://url.com/file.txt?auth -> https://url.com/file.txt.

Mã nguồn trong 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)

Chuyển đổi URL thành tên tệp, tức là https://url.com/file.txt?auth -> file.txt.

Mã nguồn trong 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





Created 2023-11-12, Updated 2024-06-02
Authors: glenn-jocher (10), Burhan-Q (1), Laughing-q (1)