सामग्री पर जाएं

के लिए संदर्भ ultralytics/utils/__init__.py

नोट

यह फ़ाइल यहाँ उपलब्ध है https://github.com/ultralytics/ultralytics/बूँद/मुख्य/ultralytics/utils/init.py का उपयोग करें। यदि आप कोई समस्या देखते हैं तो कृपया पुल अनुरोध का योगदान करके इसे ठीक करने में मदद करें 🛠️। 🙏 धन्यवाद !



ultralytics.utils.TQDM

का रूप: tqdm

परम्परा Ultralytics विभिन्न डिफ़ॉल्ट तर्कों के साथ tqdm वर्ग।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
*args list

स्थितीय तर्क मूल tqdm को दिए गए।

()
**kwargs dict

कीवर्ड तर्क, कस्टम डिफ़ॉल्ट लागू होने के साथ।

{}
में स्रोत कोड ultralytics/utils/__init__.py
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126127
class TQDM(tqdm_original):
    """
    Custom Ultralytics tqdm class with different default arguments.

    Args:
        *args (list): Positional arguments passed to original tqdm.
        **kwargs (dict): 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)

कस्टम प्रारंभ करें Ultralytics विभिन्न डिफ़ॉल्ट तर्कों के साथ tqdm वर्ग।

ध्यान दें कि TQDM को कॉल करते समय इन्हें अभी भी ओवरराइड किया जा सकता है।

में स्रोत कोड ultralytics/utils/__init__.py
119 120 121 122 123 124 125 126 127
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 एक बेस क्लास है जो सहायक स्ट्रिंग प्रतिनिधित्व, त्रुटि रिपोर्टिंग और विशेषता प्रदान करता है आसान डिबगिंग और उपयोग के लिए एक्सेस विधियां।

में स्रोत कोड ultralytics/utils/__init__.py
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
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)

उपयोगी जानकारी के साथ कस्टम विशेषता पहुँच त्रुटि संदेश।

में स्रोत कोड ultralytics/utils/__init__.py
153 154 155 156
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__()

ऑब्जेक्ट का मशीन-पठनीय स्ट्रिंग प्रतिनिधित्व लौटाएं।

में स्रोत कोड ultralytics/utils/__init__.py
def __repr__(self):
    """Return a machine-readable string representation of the object."""
    return self.__str__()

__str__()

ऑब्जेक्ट का मानव-पठनीय स्ट्रिंग प्रतिनिधित्व लौटाएं।

में स्रोत कोड ultralytics/utils/__init__.py
135 136 137 138 139 140 141 142 143 144 145146147
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

का रूप: SimpleNamespace

Ultralytics IterableSimpleNamespace SimpleNamespace का एक एक्सटेंशन क्लास है जो पुनरावृत्त कार्यक्षमता जोड़ता है और dict() के साथ और लूप के लिए उपयोग सक्षम करता है।

में स्रोत कोड ultralytics/utils/__init__.py
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
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)

उपयोगी जानकारी के साथ कस्टम विशेषता पहुँच त्रुटि संदेश।

में स्रोत कोड ultralytics/utils/__init__.py
172 173 174 175 176 177 178179 180 181 182
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__()

नामस्थान की विशेषताओं से कुंजी-मान जोड़े का एक इटरेटर लौटाएं।

में स्रोत कोड 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__()

ऑब्जेक्ट का मानव-पठनीय स्ट्रिंग प्रतिनिधित्व लौटाएं।

में स्रोत कोड 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)

निर्दिष्ट कुंजी का मान लौटाएं यदि यह मौजूद है; अन्यथा, डिफ़ॉल्ट मान लौटाएं।

में स्रोत कोड 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

किसी कार्य या विधि के धागा-सुरक्षित निष्पादन को सुनिश्चित करने के लिए एक डेकोरेटर वर्ग। इस वर्ग का उपयोग डेकोरेटर के रूप में किया जा सकता है यह सुनिश्चित करने के लिए कि यदि सजाए गए फ़ंक्शन को कई थ्रेड्स से बुलाया जाता है, तो एक समय में केवल एक थ्रेड सक्षम होगा फ़ंक्शन निष्पादित करने के लिए।

विशेषताएँ:

नाम प्रकार विवरण: __________
lock Lock

एक लॉक ऑब्जेक्ट जिसका उपयोग सजाए गए फ़ंक्शन तक पहुंच का प्रबंधन करने के लिए किया जाता है।

उदाहरण
from ultralytics.utils import ThreadingLocked

@ThreadingLocked()
def my_function():
    # Your code here
    pass
में स्रोत कोड ultralytics/utils/__init__.py
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308309 310 311312313314 315
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)

फ़ंक्शन या विधि का थ्रेड-सुरक्षित निष्पादन चलाएँ।

में स्रोत कोड ultralytics/utils/__init__.py
305 306 307 308 309310 311 312 313 314315
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__()

किसी फ़ंक्शन या विधि के थ्रेड-सुरक्षित निष्पादन के लिए डेकोरेटर क्लास को इनिशियलाइज़ करता है।

में स्रोत कोड 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

का रूप: ContextDecorator

Ultralytics TryExcept class. @TryExcept() डेकोरेटर या 'TryExcept():' संदर्भ प्रबंधक के रूप में उपयोग करें।

उदाहरण:

एक डेकोरेटर के रूप में:

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

एक संदर्भ प्रबंधक के रूप में:

>>> with TryExcept(msg="Error occurred in block", verbose=True):
>>>     # Code block here
>>>     pass
में स्रोत कोड ultralytics/utils/__init__.py
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750751752753 
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__()

TryExcept संदर्भ दर्ज करते समय निष्पादित होता है, उदाहरण प्रारंभ करता है।

में स्रोत कोड ultralytics/utils/__init__.py
def __enter__(self):
    """Executes when entering TryExcept context, initializes instance."""
    pass

__exit__(exc_type, value, traceback)

'साथ' ब्लॉक से बाहर निकलते समय व्यवहार को परिभाषित करता है, यदि आवश्यक हो तो त्रुटि संदेश प्रिंट करता है।

में स्रोत कोड 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)

वैकल्पिक संदेश और वर्बोसिटी सेटिंग्स के साथ TryExcept वर्ग प्रारंभ करें।

में स्रोत कोड ultralytics/utils/__init__.py
740 741 742 743
def __init__(self, msg="", verbose=True):
    """Initialize TryExcept class with optional message and verbosity settings."""
    self.msg = msg
    self.verbose = verbose



ultralytics.utils.Retry

का रूप: ContextDecorator

घातीय बैकऑफ़ के साथ फ़ंक्शन निष्पादन के लिए पुनः प्रयास करें।

अपवादों पर किसी फ़ंक्शन या कोड के ब्लॉक को पुनः प्रयास करने के लिए एक डेकोरेटर या संदर्भ प्रबंधक के रूप में इस्तेमाल किया जा सकता है, एक तक पुनर्प्रयास के बीच तेजी से बढ़ती देरी के साथ निर्दिष्ट संख्या।

उदाहरण:

एक डेकोरेटर के रूप में उदाहरण उपयोग:

>>> @Retry(times=3, delay=2)
>>> def test_func():
>>>     # Replace with function logic that may raise exceptions
>>>     return True

संदर्भ प्रबंधक के रूप में उदाहरण उपयोग:

>>> with Retry(times=3, delay=2):
>>>     # Replace with code block that may raise exceptions
>>>     pass
में स्रोत कोड ultralytics/utils/__init__.py
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788789 790 791 792 793 794 795 796 797 798799 800 801 802 803 804 805 806 807 808809810811812
class Retry(contextlib.ContextDecorator):
    """
    Retry class for function execution with exponential backoff.

    Can be used as a decorator or a context manager to retry a function or block of code 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

        Example usage as a context manager:
        >>> with Retry(times=3, delay=2):
        >>>     # Replace with code block that may raise exceptions
        >>>     pass
    """

    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

    def __enter__(self):
        """Enter the runtime context related to this object."""
        self._attempts = 0

    def __exit__(self, exc_type, exc_value, traceback):
        """Exit the runtime context related to this object with exponential backoff."""
        if exc_type is not None:
            self._attempts += 1
            if self._attempts < self.times:
                print(f"Retry {self._attempts}/{self.times} failed: {exc_value}")
                time.sleep(self.delay * (2**self._attempts))  # exponential backoff delay
                return True  # Suppresses the exception and retries
        return False  # Re-raises the exception if retries are exhausted

__call__(func)

घातीय बैकऑफ़ के साथ पुनः प्रयास के लिए डेकोरेटर कार्यान्वयन।

में स्रोत कोड ultralytics/utils/__init__.py
782 783 784 785 786 787 788789 790 791 792 793 794 795 796 797798
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

__enter__()

इस ऑब्जेक्ट से संबंधित रनटाइम संदर्भ दर्ज करें।

में स्रोत कोड ultralytics/utils/__init__.py
def __enter__(self):
    """Enter the runtime context related to this object."""
    self._attempts = 0

__exit__(exc_type, exc_value, traceback)

घातांकी बैकऑफ़ के साथ इस ऑब्जेक्ट से संबंधित रनटाइम संदर्भ से बाहर निकलें।

में स्रोत कोड ultralytics/utils/__init__.py
def __exit__(self, exc_type, exc_value, traceback):
    """Exit the runtime context related to this object with exponential backoff."""
    if exc_type is not None:
        self._attempts += 1
        if self._attempts < self.times:
            print(f"Retry {self._attempts}/{self.times} failed: {exc_value}")
            time.sleep(self.delay * (2**self._attempts))  # exponential backoff delay
            return True  # Suppresses the exception and retries
    return False  # Re-raises the exception if retries are exhausted

__init__(times=3, delay=2)

पुनः प्रयास और विलंब की निर्दिष्ट संख्या के साथ पुनः प्रयास वर्ग प्रारंभ करें।

में स्रोत कोड ultralytics/utils/__init__.py
776 777 778 779780 
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

का रूप: dict

प्रबंधन Ultralytics YAML फ़ाइल में संग्रहीत सेटिंग्स।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
file str | Path

के लिए पथ Ultralytics सेटिंग्स YAML फ़ाइल। डिफ़ॉल्ट USER_CONFIG_DIR / 'settings.yaml' है।

SETTINGS_YAML
version str

सेटिंग संस्करण। स्थानीय संस्करण बेमेल होने की स्थिति में, नई डिफ़ॉल्ट सेटिंग्स सहेजी जाएंगी।

'0.0.4'
में स्रोत कोड ultralytics/utils/__init__.py
906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968969 970 971 972 973 974 975 976 977 978979 980981 982 983 984 985 986987
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

        git_dir = get_git_dir()
        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)
            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 "
                    "with your settings or a recent ultralytics package update. "
                    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'."
                )
                self.reset()

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

डिफ़ॉल्ट सेटिंग्स के साथ SettingsManager को इनिशियलाइज़ करें, YAML से वर्तमान सेटिंग्स को लोड और मान्य करें रेती।

में स्रोत कोड ultralytics/utils/__init__.py
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938939940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960961 962 963 964 965 966 967968
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

    git_dir = get_git_dir()
    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)
        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 "
                "with your settings or a recent ultralytics package update. "
                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'."
            )
            self.reset()

load()

YAML फ़ाइल से सेटिंग्स लोड करता है।

में स्रोत कोड ultralytics/utils/__init__.py
def load(self):
    """Loads settings from the YAML file."""
    super().update(yaml_load(self.file))

reset()

सेटिंग्स को डिफ़ॉल्ट पर रीसेट करता है और उन्हें सहेजता है।

में स्रोत कोड ultralytics/utils/__init__.py
983 984 985 986987
def reset(self):
    """Resets the settings to default and saves them."""
    self.clear()
    self.update(self.defaults)
    self.save()

save()

वर्तमान सेटिंग्स को YAML फ़ाइल में सहेजता है।

में स्रोत कोड ultralytics/utils/__init__.py
def save(self):
    """Saves the current settings to the YAML file."""
    yaml_save(self.file, dict(self))

update(*args, **kwargs)

वर्तमान सेटिंग्स में सेटिंग मान अद्यतन करता है.

में स्रोत कोड 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')

अस्थायी रूप से आरसी मापदंडों और एक साजिश समारोह के लिए बैकएंड सेट करने के लिए डेकोरेटर।

उदाहरण

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

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
rcparams dict

आरसी मापदंडों का शब्दकोश सेट करने के लिए।

None
backend str

उपयोग करने के लिए बैकएंड का नाम। 'Agg' के लिए डिफ़ॉल्ट।

'Agg'

देता:

प्रकार विवरण: __________
Callable

अस्थायी रूप से सेट आरसी मापदंडों और बैकएंड के साथ सजाया समारोह। यह डेकोरेटर हो सकता है किसी भी फ़ंक्शन पर लागू होता है जिसे इसके निष्पादन के लिए विशिष्ट MatPlotLiB RC पैरामीटर और बैकएंड की आवश्यकता होती है।

में स्रोत कोड ultralytics/utils/__init__.py
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208209 210 211 212 213 214 215 216 217 218219220221 222 223 224 225 226 227 228 229
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)

दिए गए नाम के लिए UTF-8 एन्कोडिंग समर्थन के साथ लॉगिंग सेट अप करता है.

में स्रोत कोड ultralytics/utils/__init__.py
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248249 250 251 252 253 254 255 256 257 258 259 260 261 262263264265266 267
def set_logging(name=LOGGING_NAME, verbose=True):
    """Sets up logging for the given name with UTF-8 encoding support."""
    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
    formatter = logging.Formatter("%(message)s")  # Default formatter
    if WINDOWS and sys.stdout.encoding != "utf-8":
        try:
            if hasattr(sys.stdout, "reconfigure"):
                sys.stdout.reconfigure(encoding="utf-8")
            elif hasattr(sys.stdout, "buffer"):
                import io

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

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

            formatter = CustomFormatter("%(message)s")  # Use CustomFormatter to eliminate UTF-8 output as last recourse

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

    logger = logging.getLogger(name)
    logger.setLevel(level)
    logger.addHandler(stream_handler)
    logger.propagate = False
    return logger



ultralytics.utils.emojis(string='')

स्ट्रिंग का प्लेटफ़ॉर्म-निर्भर इमोजी-सुरक्षित संस्करण लौटाएं।

में स्रोत कोड 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='')

YAML डेटा को किसी फ़ाइल में सहेजें।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
file str

फ़ाइल का नाम. डिफ़ॉल्ट 'data.yaml' है।

'data.yaml'
data dict

YAML प्रारूप में सहेजने के लिए डेटा।

None
header str

जोड़ने के लिए YAML शीर्षलेख।

''

देता:

प्रकार विवरण: __________
None

डेटा निर्दिष्ट फ़ाइल में सहेजा गया है।

में स्रोत कोड ultralytics/utils/__init__.py
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338339 340341 342343 344345346 347
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)

फ़ाइल से YAML डेटा लोड करें।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
file str

फ़ाइल का नाम. डिफ़ॉल्ट 'data.yaml' है।

'data.yaml'
append_filename bool

YAML शब्दकोश में YAML फ़ाइल नाम जोड़ें। डिफ़ॉल्ट ग़लत है.

False

देता:

प्रकार विवरण: __________
dict

YAML डेटा और फ़ाइल नाम।

में स्रोत कोड ultralytics/utils/__init__.py
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369370 371372 373
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)

सुंदर एक YAML फ़ाइल या YAML-स्वरूपित शब्दकोश प्रिंट करता है।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
yaml_file Union[str, Path, dict]

YAML फ़ाइल या YAML-स्वरूपित शब्दकोश का फ़ाइल पथ.

आवश्यक

देता:

प्रकार विवरण: __________
None

(कोई नहीं)

में स्रोत कोड ultralytics/utils/__init__.py
376 377 378 379 380 381 382 383 384 385 386 387 388
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.is_ubuntu()

जांचें कि क्या ओएस उबंटू है।

देता:

प्रकार विवरण: __________
bool

सच है अगर ओएस उबंटू है, तो गलत अन्यथा।

में स्रोत कोड ultralytics/utils/__init__.py
400 401 402 403 404 405 406 407 408409 410
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()

देखें कि मौजूदा स्क्रिप्ट Google Colab नोटबुक में चल रही है या नहीं.

देता:

प्रकार विवरण: __________
bool

Colab नोटबुक के अंदर चलने पर सही, अन्यथा गलत।

में स्रोत कोड ultralytics/utils/__init__.py
413 414 415 416 417 418 419420
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()

जांचें कि क्या वर्तमान स्क्रिप्ट Kaggle कर्नेल के अंदर चल रही है।

देता:

प्रकार विवरण: __________
bool

सच है अगर एक Kaggle कर्नेल के अंदर चल रहा है, अन्यथा गलत।

में स्रोत कोड ultralytics/utils/__init__.py
423 424 425 426 427 428 429430
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()

जांचें कि क्या वर्तमान स्क्रिप्ट ज्यूपिटर नोटबुक के अंदर चल रही है। पर सत्यापित Colab, Jupyterlab, Kaggle, Paperspace.

देता:

प्रकार विवरण: __________
bool

सच है अगर ज्यूपिटर नोटबुक के अंदर चल रहा है, तो गलत अन्यथा।

में स्रोत कोड ultralytics/utils/__init__.py
433 434 435 436 437 438 439 440 441 442443 444
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()

निर्धारित करें कि स्क्रिप्ट डॉकर कंटेनर के अंदर चल रही है या नहीं।

देता:

प्रकार विवरण: __________
bool

सच है अगर स्क्रिप्ट डॉकर कंटेनर के अंदर चल रही है, तो गलत अन्यथा।

में स्रोत कोड ultralytics/utils/__init__.py
447 448 449 450 451 452 453 454 455 456 457 458 459
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.
    """
    file = Path("/proc/self/cgroup")
    if file.exists():
        with open(file) as f:
            return "docker" in f.read()
    else:
        return False



ultralytics.utils.is_online()

किसी ज्ञात ऑनलाइन होस्ट से कनेक्ट करने का प्रयास करके इंटरनेट कनेक्टिविटी की जाँच करें।

देता:

प्रकार विवरण: __________
bool

सच है अगर कनेक्शन सफल है, अन्यथा गलत।

में स्रोत कोड ultralytics/utils/__init__.py
462 463 464 465 466 467 468469 470 471 472 473 474 475 476 477 478479480
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.
    """
    import socket

    for host in "1.1.1.1", "8.8.8.8", "223.5.5.5":  # Cloudflare, Google, AliDNS:
        try:
            test_connection = socket.create_connection(address=(host, 53), timeout=2)
        except (socket.timeout, socket.gaierror, OSError):
            continue
        else:
            # If the connection was successful, close it to avoid a ResourceWarning
            test_connection.close()
            return True
    return False



ultralytics.utils.is_pip_package(filepath=__name__)

निर्धारित करता है कि दिए गए फ़ाइलपथ पर फ़ाइल एक पाइप पैकेज का हिस्सा है या नहीं।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
filepath str

जाँच करने के लिए फ़ाइलपथ।

__name__

देता:

प्रकार विवरण: __________
bool

सच है अगर फ़ाइल एक पाइप पैकेज का हिस्सा है, अन्यथा गलत।

में स्रोत कोड ultralytics/utils/__init__.py
486 487 488 489 490 491 492 493 494 495 496 497498 499500 501502
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)

जांचें कि क्या कोई निर्देशिका लिखने योग्य है।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
dir_path str | Path

निर्देशिका का पथ.

आवश्यक

देता:

प्रकार विवरण: __________
bool

सही है अगर निर्देशिका लिखने योग्य है, अन्यथा गलत।

में स्रोत कोड ultralytics/utils/__init__.py
505 506 507 508 509510 511 512 513 514515
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()

निर्धारित करता है कि pytest वर्तमान में चल रहा है या नहीं।

देता:

प्रकार विवरण: __________
bool

सच है अगर pytest चल रहा है, अन्यथा गलत।

में स्रोत कोड 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(sys.argv[0]).stem)



ultralytics.utils.is_github_action_running()

निर्धारित करें कि वर्तमान परिवेश GitHub एक्शन रनर है या नहीं।

देता:

प्रकार विवरण: __________
bool

सच है अगर वर्तमान वातावरण एक GitHub एक्शन रनर है, अन्यथा गलत।

में स्रोत कोड ultralytics/utils/__init__.py
528 529530 531 532 533 534 535
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.is_git_dir()

निर्धारित करता है कि वर्तमान फ़ाइल गिट रिपॉजिटरी का हिस्सा है या नहीं। यदि वर्तमान फ़ाइल गिट का हिस्सा नहीं है भंडार, कोई नहीं लौटाता है।

देता:

प्रकार विवरण: __________
bool

सच है अगर वर्तमान फ़ाइल एक गिट भंडार का हिस्सा है।

में स्रोत कोड ultralytics/utils/__init__.py
538 539 540 541 542543 544 545 546
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 get_git_dir() is not None



ultralytics.utils.get_git_dir()

निर्धारित करता है कि वर्तमान फ़ाइल गिट रिपॉजिटरी का हिस्सा है या नहीं और यदि ऐसा है, तो रिपॉजिटरी रूट निर्देशिका लौटाता है। अगर वर्तमान फ़ाइल गिट रिपॉजिटरी का हिस्सा नहीं है, कोई नहीं लौटाता है।

देता:

प्रकार विवरण: __________
Path | None

गिट रूट निर्देशिका अगर मिली या कोई नहीं मिली तो नहीं।

में स्रोत कोड ultralytics/utils/__init__.py
549 550 551 552 553 554 555 556 557 558559
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.get_git_origin_url()

गिट रिपॉजिटरी का मूल URL प्राप्त करता है।

देता:

प्रकार विवरण: __________
str | None

गिट रिपॉजिटरी का मूल URL या कोई नहीं यदि git निर्देशिका नहीं है।

में स्रोत कोड ultralytics/utils/__init__.py
562 563 564 565 566 567 568 569 570 571 572
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()

वर्तमान git शाखा नाम लौटाता है। यदि गिट रिपॉजिटरी में नहीं है, तो कोई नहीं लौटाता है।

देता:

प्रकार विवरण: __________
str | None

वर्तमान git शाखा नाम या कोई नहीं यदि git निर्देशिका नहीं है।

में स्रोत कोड ultralytics/utils/__init__.py
575 576 577 578 579 580 581 582 583 584585
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)

किसी फ़ंक्शन के लिए डिफ़ॉल्ट तर्कों का शब्दकोश लौटाता है.

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
func callable

निरीक्षण करने के लिए समारोह।

आवश्यक

देता:

प्रकार विवरण: __________
dict

एक शब्दकोश जहां प्रत्येक कुंजी एक पैरामीटर नाम है, और प्रत्येक मान उस पैरामीटर का डिफ़ॉल्ट मान है।

में स्रोत कोड ultralytics/utils/__init__.py
588 589 590 591 592 593 594 595 596 597 598599
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()

यदि ओएस उबंटू है तो उबंटू संस्करण को पुनः प्राप्त करें।

देता:

प्रकार विवरण: __________
str

उबंटू संस्करण या कोई नहीं अगर उबंटू ओएस नहीं है।

में स्रोत कोड ultralytics/utils/__init__.py
602 603 604 605 606 607 608609610 611612 
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')

पर्यावरण ऑपरेटिंग सिस्टम के आधार पर उपयुक्त कॉन्फ़िगरेशन निर्देशिका लौटाएं।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
sub_dir str

बनाने के लिए उपनिर्देशिका का नाम।

'Ultralytics'

देता:

प्रकार विवरण: __________
Path

उपयोगकर्ता कॉन्फ़िगरेशन निर्देशिका का पथ।

में स्रोत कोड ultralytics/utils/__init__.py
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638639 640 641 642 643 644 645
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)

प्रदान किए गए रंग और शैली तर्कों के आधार पर एक स्ट्रिंग को रंग देता है। एएनएसआई एस्केप कोड का उपयोग करता है। अधिक जानकारी के लिए https://en.wikipedia.org/wiki/ANSI_escape_code देखें।

इस फ़ंक्शन को दो तरह से बुलाया जा सकता है
  • colorstr('रंग', 'शैली', 'आपकी स्ट्रिंग')
  • colorstr('आपकी स्ट्रिंग')

दूसरे रूप में, 'नीला' और 'बोल्ड' डिफ़ॉल्ट रूप से लागू किया जाएगा।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
*input str

स्ट्रिंग्स का एक क्रम जहां पहले n-1 स्ट्रिंग्स रंग और शैली तर्क हैं, और अंतिम स्ट्रिंग रंगीन होने वाली है।

()
समर्थित रंग और शैलियाँ

मूल रंग: 'काला', 'लाल', 'हरा', 'पीला', 'नीला', 'मैजेंटा', 'सियान', 'सफेद' चमकीले रंग: 'bright_black', 'bright_red', 'bright_green', 'bright_yellow', 'bright_blue', 'bright_magenta', 'bright_cyan', 'bright_white' विविध: 'अंत', 'बोल्ड', 'रेखांकित'

देता:

प्रकार विवरण: __________
str

निर्दिष्ट रंग और शैली के लिए ANSI एस्केप कोड के साथ लपेटी गई इनपुट स्ट्रिंग।

उदाहरण:

>>> colorstr('blue', 'bold', 'hello world')
>>> 'hello world'
में स्रोत कोड ultralytics/utils/__init__.py
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699700701702
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)

एक स्ट्रिंग से एएनएसआई एस्केप कोड निकालता है, प्रभावी रूप से इसे अन-कलर करता है।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
input_string str

रंग और शैली को हटाने के लिए स्ट्रिंग।

आवश्यक

देता:

प्रकार विवरण: __________
str

सभी ANSI एस्केप कोड के साथ एक नई स्ट्रिंग हटा दी गई।

उदाहरण:

>>> remove_colorstr(colorstr('blue', 'bold', 'hello world'))
>>> 'hello world'
में स्रोत कोड ultralytics/utils/__init__.py
705 706 707 708 709 710 711 712 713 714 715 716 717 718719720
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)

डिफ़ॉल्ट रूप से लक्ष्य फ़ंक्शन को मल्टी-थ्रेड करता है और थ्रेड या फ़ंक्शन परिणाम लौटाता है।

@threaded डेकोरेटर के रूप में उपयोग करें। फ़ंक्शन एक अलग थ्रेड में चलता है जब तक कि 'थ्रेडेड = गलत' पारित नहीं किया जाता है।

में स्रोत कोड ultralytics/utils/__init__.py
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831
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()

त्रुटि ट्रैकिंग और रिपोर्टिंग के लिए संतरी एसडीके को प्रारंभ करें। केवल तभी उपयोग किया जाता है जब sentry_sdk पैकेज स्थापित हो और sync=सेटिंग्स में True पर टैप करें. भागो 'yolo सेटिंग्स 'देखने और अपडेट करने के लिए सेटिंग्स YAML फ़ाइल।

त्रुटियां भेजने के लिए आवश्यक शर्तें (सभी शर्तों को पूरा किया जाना चाहिए या कोई त्रुटि रिपोर्ट नहीं की जाएगी): - sentry_sdk पैकेज स्थापित है - सिंक = में सच है YOLO सेटिंग्स - पाइटेस्ट नहीं चल रहा है - एक पाइप पैकेज स्थापना में चल रहा है - एक गैर-गिट निर्देशिका में चल रहा है - रैंक -1 या 0 के साथ चल रहा है - ऑनलाइन वातावरण - CLI पैकेज चलाने के लिए उपयोग किया जाता है (' के साथ चेक किया गया)yolo' मुख्य के नाम के रूप में CLI आदेश)

फ़ंक्शन भी KeyboardInterrupt और FileNotFoundError को अनदेखा करने के लिए संतरी SDK को कॉन्फ़िगर करता है अपवाद और उनके अपवाद संदेश में 'स्मृति से बाहर' के साथ घटनाओं को बाहर करने के लिए।

इसके अतिरिक्त, फ़ंक्शन संतरी घटनाओं के लिए कस्टम टैग और उपयोगकर्ता जानकारी सेट करता है।

में स्रोत कोड ultralytics/utils/__init__.py
834 835 836 837 838839 840 841 842 843 844 845 846 847 848849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896897898899 900 901 902 903
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": sys.argv[0],
            "sys_argv_name": Path(sys.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(sys.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)

एक बहिष्करण चेतावनी जारी करें जब एक पदावनत तर्क का उपयोग किया जाता है, एक अद्यतन तर्क का सुझाव देता है।

में स्रोत कोड ultralytics/utils/__init__.py
990 991 992 993 994 995 996 997
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)

URL से स्ट्रिप ऑथ, यानी https://url.com/file.txt?auth -> https://url.com/file.txt।

में स्रोत कोड ultralytics/utils/__init__.py
1000 1001 1002 1003
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)

URL को फ़ाइल नाम में कनवर्ट करें, यानी https://url.com/file.txt?auth -> फ़ाइल.txt।

में स्रोत कोड ultralytics/utils/__init__.py
1006 1007 1008
def url2file(url):
    """Convert URL to filename, i.e. https://url.com/file.txt?auth -> file.txt."""
    return Path(clean_url(url)).name





2023-11-12 बनाया गया, अपडेट किया गया 2024-01-27
लेखक: ग्लेन-जोचर (7), लाफिंग-क्यू (1)