μ½˜ν…μΈ λ‘œ κ±΄λ„ˆλ›°κΈ°

μ°Έμ‘° ultralytics/utils/checks.py

μ°Έκ³ 

이 νŒŒμΌμ€ https://github.com/ultralytics/ ultralytics/blob/main/ ultralytics/utils/checks .pyμ—μ„œ 확인할 수 μžˆμŠ΅λ‹ˆλ‹€. 문제λ₯Ό λ°œκ²¬ν•˜λ©΄ ν’€ λ¦¬ν€˜μŠ€νŠΈ (πŸ› οΈ) λ₯Ό 톡해 문제λ₯Ό ν•΄κ²°ν•˜λ„λ‘ λ„μ™€μ£Όμ„Έμš”. κ°μ‚¬ν•©λ‹ˆλ‹€ πŸ™!



ultralytics.utils.checks.parse_requirements(file_path=ROOT.parent / 'requirements.txt', package='')

'#'둜 μ‹œμž‘ν•˜λŠ” 쀄과 '#' μ΄ν›„μ˜ λͺ¨λ“  ν…μŠ€νŠΈλ₯Ό λ¬΄μ‹œν•˜κ³  μš”κ΅¬ 사항.txt νŒŒμΌμ„ ꡬ문 λΆ„μ„ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
file_path Path

μš”κ΅¬ 사항.txt 파일의 κ²½λ‘œμž…λ‹ˆλ‹€.

parent / 'requirements.txt'
package str

Python νŒ¨ν‚€μ§€λ₯Ό μš”κ΅¬μ‚¬ν•­.txt 파일 λŒ€μ‹  μ‚¬μš©ν•  수 μžˆμŠ΅λ‹ˆλ‹€(예: package='ultralytics').

''

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
List[Dict[str, str]]

λ‹€μŒμ„ μ‚¬μš©ν•˜μ—¬ ꡬ문 λΆ„μ„λœ μš”κ΅¬ 사항을 μ‚¬μ „μœΌλ‘œ λ‚˜μ—΄ν•©λ‹ˆλ‹€. name 그리고 specifier ν‚€λ₯Ό μž…λ ₯ν•©λ‹ˆλ‹€.

예
from ultralytics.utils.checks import parse_requirements

parse_requirements(package='ultralytics')
의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def parse_requirements(file_path=ROOT.parent / "requirements.txt", package=""):
    """
    Parse a requirements.txt file, ignoring lines that start with '#' and any text after '#'.

    Args:
        file_path (Path): Path to the requirements.txt file.
        package (str, optional): Python package to use instead of requirements.txt file, i.e. package='ultralytics'.

    Returns:
        (List[Dict[str, str]]): List of parsed requirements as dictionaries with `name` and `specifier` keys.

    Example:
        ```python
        from ultralytics.utils.checks import parse_requirements

        parse_requirements(package='ultralytics')
        ```
    """

    if package:
        requires = [x for x in metadata.distribution(package).requires if "extra == " not in x]
    else:
        requires = Path(file_path).read_text().splitlines()

    requirements = []
    for line in requires:
        line = line.strip()
        if line and not line.startswith("#"):
            line = line.split("#")[0].strip()  # ignore inline comments
            match = re.match(r"([a-zA-Z0-9-_]+)\s*([<>!=~]+.*)?", line)
            if match:
                requirements.append(SimpleNamespace(name=match[1], specifier=match[2].strip() if match[2] else ""))

    return requirements



ultralytics.utils.checks.parse_version(version='0.0.0')

버전 λ¬Έμžμ—΄μ„ μ •μˆ˜ νŠœν”Œλ‘œ λ³€ν™˜ν•˜μ—¬ 버전에 μ—°κ²°λœ μˆ«μžκ°€ μ•„λ‹Œ μΆ”κ°€ λ¬Έμžμ—΄μ„ λ¬΄μ‹œν•©λ‹ˆλ‹€. 이 ν•¨μˆ˜λŠ” 더 이상 μ‚¬μš©λ˜μ§€ μ•ŠλŠ” 'pkg_resources.parse_version(v)'을 λŒ€μ²΄ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
version str

버전 λ¬Έμžμ—΄(예: '2.0.1+cpu')

'0.0.0'

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
tuple

버전과 μΆ”κ°€ λ¬Έμžμ—΄μ˜ 숫자 뢀뢄을 λ‚˜νƒ€λ‚΄λŠ” μ •μˆ˜μ˜ νŠœν”Œ(예: (2, 0, 1))

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def parse_version(version="0.0.0") -> tuple:
    """
    Convert a version string to a tuple of integers, ignoring any extra non-numeric string attached to the version. This
    function replaces deprecated 'pkg_resources.parse_version(v)'.

    Args:
        version (str): Version string, i.e. '2.0.1+cpu'

    Returns:
        (tuple): Tuple of integers representing the numeric part of the version and the extra string, i.e. (2, 0, 1)
    """
    try:
        return tuple(map(int, re.findall(r"\d+", version)[:3]))  # '2.0.1+cpu' -> (2, 0, 1)
    except Exception as e:
        LOGGER.warning(f"WARNING ⚠️ failure for parse_version({version}), returning (0, 0, 0): {e}")
        return 0, 0, 0



ultralytics.utils.checks.is_ascii(s)

λ¬Έμžμ—΄μ΄ ASCII 문자둜만 κ΅¬μ„±λ˜μ–΄ μžˆλŠ”μ§€ ν™•μΈν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
s str

확인할 λ¬Έμžμ—΄μž…λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
bool

λ¬Έμžμ—΄μ΄ ASCII 문자둜만 κ΅¬μ„±λœ 경우 True, 그렇지 μ•ŠμœΌλ©΄ Falseμž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def is_ascii(s) -> bool:
    """
    Check if a string is composed of only ASCII characters.

    Args:
        s (str): String to be checked.

    Returns:
        (bool): True if the string is composed only of ASCII characters, False otherwise.
    """
    # Convert list, tuple, None, etc. to string
    s = str(s)

    # Check if the string is composed of only ASCII characters
    return all(ord(c) < 128 for c in s)



ultralytics.utils.checks.check_imgsz(imgsz, stride=32, min_dim=1, max_dim=2, floor=0)

이미지 크기가 각 μ°¨μ›μ—μ„œ 주어진 보폭의 λ°°μˆ˜μΈμ§€ ν™•μΈν•©λ‹ˆλ‹€. 이미지 크기가 보폭의 λ°°μˆ˜κ°€ μ•„λ‹Œ 경우 보폭의 λ°°μˆ˜κ°€ μ•„λ‹Œ 경우, 주어진 λ°”λ‹₯ 값보닀 ν¬κ±°λ‚˜ 같은 보폭의 κ°€μž₯ κ°€κΉŒμš΄ 배수둜 μ—…λ°μ΄νŠΈν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
imgsz int | cList[int]

이미지 크기.

ν•„μˆ˜
stride int

보폭 κ°’μž…λ‹ˆλ‹€.

32
min_dim int

μ΅œμ†Œ 치수 μˆ˜μž…λ‹ˆλ‹€.

1
max_dim int

μ΅œλŒ€ 치수 μˆ˜μž…λ‹ˆλ‹€.

2
floor int

이미지 크기의 μ΅œμ†Œ ν—ˆμš©κ°’μž…λ‹ˆλ‹€.

0

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
List[int]

이미지 크기 μ—…λ°μ΄νŠΈ.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_imgsz(imgsz, stride=32, min_dim=1, max_dim=2, floor=0):
    """
    Verify image size is a multiple of the given stride in each dimension. If the image size is not a multiple of the
    stride, update it to the nearest multiple of the stride that is greater than or equal to the given floor value.

    Args:
        imgsz (int | cList[int]): Image size.
        stride (int): Stride value.
        min_dim (int): Minimum number of dimensions.
        max_dim (int): Maximum number of dimensions.
        floor (int): Minimum allowed value for image size.

    Returns:
        (List[int]): Updated image size.
    """
    # Convert stride to integer if it is a tensor
    stride = int(stride.max() if isinstance(stride, torch.Tensor) else stride)

    # Convert image size to list if it is an integer
    if isinstance(imgsz, int):
        imgsz = [imgsz]
    elif isinstance(imgsz, (list, tuple)):
        imgsz = list(imgsz)
    elif isinstance(imgsz, str):  # i.e. '640' or '[640,640]'
        imgsz = [int(imgsz)] if imgsz.isnumeric() else eval(imgsz)
    else:
        raise TypeError(
            f"'imgsz={imgsz}' is of invalid type {type(imgsz).__name__}. "
            f"Valid imgsz types are int i.e. 'imgsz=640' or list i.e. 'imgsz=[640,640]'"
        )

    # Apply max_dim
    if len(imgsz) > max_dim:
        msg = (
            "'train' and 'val' imgsz must be an integer, while 'predict' and 'export' imgsz may be a [h, w] list "
            "or an integer, i.e. 'yolo export imgsz=640,480' or 'yolo export imgsz=640'"
        )
        if max_dim != 1:
            raise ValueError(f"imgsz={imgsz} is not a valid image size. {msg}")
        LOGGER.warning(f"WARNING ⚠️ updating to 'imgsz={max(imgsz)}'. {msg}")
        imgsz = [max(imgsz)]
    # Make image size a multiple of the stride
    sz = [max(math.ceil(x / stride) * stride, floor) for x in imgsz]

    # Print warning message if image size was updated
    if sz != imgsz:
        LOGGER.warning(f"WARNING ⚠️ imgsz={imgsz} must be multiple of max stride {stride}, updating to {sz}")

    # Add missing dimensions if necessary
    sz = [sz[0], sz[0]] if min_dim == 2 and len(sz) == 1 else sz[0] if min_dim == 1 and len(sz) == 1 else sz

    return sz



ultralytics.utils.checks.check_version(current='0.0.0', required='0.0.0', name='version', hard=False, verbose=False, msg='')

ν˜„μž¬ 버전을 ν•„μš”ν•œ 버전 λ˜λŠ” λ²”μœ„μ™€ λΉ„κ΅ν•˜μ—¬ ν™•μΈν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
current str

버전을 κ°€μ Έμ˜¬ ν˜„μž¬ 버전 λ˜λŠ” νŒ¨ν‚€μ§€ μ΄λ¦„μž…λ‹ˆλ‹€.

'0.0.0'
required str

ν•„μˆ˜ 버전 λ˜λŠ” λ²”μœ„(핍 μŠ€νƒ€μΌ ν˜•μ‹)μž…λ‹ˆλ‹€.

'0.0.0'
name str

κ²½κ³  λ©”μ‹œμ§€μ— μ‚¬μš©ν•  μ΄λ¦„μž…λ‹ˆλ‹€.

'version'
hard bool

True이면 μš”κ΅¬ 사항이 μΆ©μ‘±λ˜μ§€ μ•ŠμœΌλ©΄ AssertionErrorλ₯Ό λ°œμƒμ‹œν‚΅λ‹ˆλ‹€.

False
verbose bool

True인 경우 μš”κ΅¬ 사항이 μΆ©μ‘±λ˜μ§€ μ•ŠμœΌλ©΄ κ²½κ³  λ©”μ‹œμ§€λ₯Ό μΈμ‡„ν•©λ‹ˆλ‹€.

False
msg str

μž₯ν™©ν•œ 경우 ν‘œμ‹œν•  μΆ”κ°€ λ©”μ‹œμ§€μž…λ‹ˆλ‹€.

''

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
bool

μš”κ΅¬ 사항이 좩쑱되면 μ°Έ, 그렇지 μ•ŠμœΌλ©΄ κ±°μ§“μž…λ‹ˆλ‹€.

예
# Check if current version is exactly 22.04
check_version(current='22.04', required='==22.04')

# Check if current version is greater than or equal to 22.04
check_version(current='22.10', required='22.04')  # assumes '>=' inequality if none passed

# Check if current version is less than or equal to 22.04
check_version(current='22.04', required='<=22.04')

# Check if current version is between 20.04 (inclusive) and 22.04 (exclusive)
check_version(current='21.10', required='>20.04,<22.04')
의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_version(
    current: str = "0.0.0",
    required: str = "0.0.0",
    name: str = "version",
    hard: bool = False,
    verbose: bool = False,
    msg: str = "",
) -> bool:
    """
    Check current version against the required version or range.

    Args:
        current (str): Current version or package name to get version from.
        required (str): Required version or range (in pip-style format).
        name (str, optional): Name to be used in warning message.
        hard (bool, optional): If True, raise an AssertionError if the requirement is not met.
        verbose (bool, optional): If True, print warning message if requirement is not met.
        msg (str, optional): Extra message to display if verbose.

    Returns:
        (bool): True if requirement is met, False otherwise.

    Example:
        ```python
        # Check if current version is exactly 22.04
        check_version(current='22.04', required='==22.04')

        # Check if current version is greater than or equal to 22.04
        check_version(current='22.10', required='22.04')  # assumes '>=' inequality if none passed

        # Check if current version is less than or equal to 22.04
        check_version(current='22.04', required='<=22.04')

        # Check if current version is between 20.04 (inclusive) and 22.04 (exclusive)
        check_version(current='21.10', required='>20.04,<22.04')
        ```
    """
    if not current:  # if current is '' or None
        LOGGER.warning(f"WARNING ⚠️ invalid check_version({current}, {required}) requested, please check values.")
        return True
    elif not current[0].isdigit():  # current is package name rather than version string, i.e. current='ultralytics'
        try:
            name = current  # assigned package name to 'name' arg
            current = metadata.version(current)  # get version string from package name
        except metadata.PackageNotFoundError as e:
            if hard:
                raise ModuleNotFoundError(emojis(f"WARNING ⚠️ {current} package is required but not installed")) from e
            else:
                return False

    if not required:  # if required is '' or None
        return True

    op = ""
    version = ""
    result = True
    c = parse_version(current)  # '1.2.3' -> (1, 2, 3)
    for r in required.strip(",").split(","):
        op, version = re.match(r"([^0-9]*)([\d.]+)", r).groups()  # split '>=22.04' -> ('>=', '22.04')
        v = parse_version(version)  # '1.2.3' -> (1, 2, 3)
        if op == "==" and c != v:
            result = False
        elif op == "!=" and c == v:
            result = False
        elif op in {">=", ""} and not (c >= v):  # if no constraint passed assume '>=required'
            result = False
        elif op == "<=" and not (c <= v):
            result = False
        elif op == ">" and not (c > v):
            result = False
        elif op == "<" and not (c < v):
            result = False
    if not result:
        warning = f"WARNING ⚠️ {name}{op}{version} is required, but {name}=={current} is currently installed {msg}"
        if hard:
            raise ModuleNotFoundError(emojis(warning))  # assert version requirements met
        if verbose:
            LOGGER.warning(warning)
    return result



ultralytics.utils.checks.check_latest_pypi_version(package_name='ultralytics')

λ‹€μš΄λ‘œλ“œν•˜κ±°λ‚˜ μ„€μΉ˜ν•˜μ§€ μ•Šκ³  μ΅œμ‹  λ²„μ „μ˜ PyPI νŒ¨ν‚€μ§€λ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
package_name str

μ΅œμ‹  버전을 찾을 νŒ¨ν‚€μ§€μ˜ μ΄λ¦„μž…λ‹ˆλ‹€.

'ultralytics'

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
str

μ΅œμ‹  λ²„μ „μ˜ νŒ¨ν‚€μ§€μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_latest_pypi_version(package_name="ultralytics"):
    """
    Returns the latest version of a PyPI package without downloading or installing it.

    Parameters:
        package_name (str): The name of the package to find the latest version for.

    Returns:
        (str): The latest version of the package.
    """
    with contextlib.suppress(Exception):
        requests.packages.urllib3.disable_warnings()  # Disable the InsecureRequestWarning
        response = requests.get(f"https://pypi.org/pypi/{package_name}/json", timeout=3)
        if response.status_code == 200:
            return response.json()["info"]["version"]



ultralytics.utils.checks.check_pip_update_available()

PyPIμ—μ„œ ultralytics νŒ¨ν‚€μ§€μ˜ μƒˆ 버전을 μ‚¬μš©ν•  수 μžˆλŠ”μ§€ ν™•μΈν•©λ‹ˆλ‹€.

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
bool

μ—…λ°μ΄νŠΈλ₯Ό μ‚¬μš©ν•  수 있으면 True, 그렇지 μ•ŠμœΌλ©΄ Falseμž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_pip_update_available():
    """
    Checks if a new version of the ultralytics package is available on PyPI.

    Returns:
        (bool): True if an update is available, False otherwise.
    """
    if ONLINE and IS_PIP_PACKAGE:
        with contextlib.suppress(Exception):
            from ultralytics import __version__

            latest = check_latest_pypi_version()
            if check_version(__version__, f"<{latest}"):  # check if current version is < latest version
                LOGGER.info(
                    f"New https://pypi.org/project/ultralytics/{latest} available πŸ˜ƒ "
                    f"Update with 'pip install -U ultralytics'"
                )
                return True
    return False



ultralytics.utils.checks.check_font(font='Arial.ttf')

글꼴이 μ—†λŠ” 경우 λ‘œμ»¬μ—μ„œ μ°Ύκ±°λ‚˜ μ‚¬μš©μžμ˜ μ„€μ • 디렉토리에 λ‹€μš΄λ‘œλ“œν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
font str

κΈ€κΌ΄μ˜ 경둜 λ˜λŠ” μ΄λ¦„μž…λ‹ˆλ‹€.

'Arial.ttf'

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
file Path

ν™•μΈλœ κΈ€κΌ΄ 파일 경둜.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
@ThreadingLocked()
def check_font(font="Arial.ttf"):
    """
    Find font locally or download to user's configuration directory if it does not already exist.

    Args:
        font (str): Path or name of font.

    Returns:
        file (Path): Resolved font file path.
    """
    from matplotlib import font_manager

    # Check USER_CONFIG_DIR
    name = Path(font).name
    file = USER_CONFIG_DIR / name
    if file.exists():
        return file

    # Check system fonts
    matches = [s for s in font_manager.findSystemFonts() if font in s]
    if any(matches):
        return matches[0]

    # Download to USER_CONFIG_DIR if missing
    url = f"https://ultralytics.com/assets/{name}"
    if downloads.is_url(url, check=True):
        downloads.safe_download(url=url, file=file)
        return file



ultralytics.utils.checks.check_python(minimum='3.8.0', hard=True)

ν˜„μž¬ python 버전을 ν•„μš”ν•œ μ΅œμ†Œ 버전과 λΉ„κ΅ν•˜μ—¬ ν™•μΈν•˜μ„Έμš”.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
minimum str

python 의 μ΅œμ†Œ 버전이 ν•„μš”ν•©λ‹ˆλ‹€.

'3.8.0'
hard bool

True이면 μš”κ΅¬ 사항이 μΆ©μ‘±λ˜μ§€ μ•ŠμœΌλ©΄ AssertionErrorλ₯Ό λ°œμƒμ‹œν‚΅λ‹ˆλ‹€.

True

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
bool

μ„€μΉ˜λœ Python 버전이 μ΅œμ†Œ μ œμ•½ 쑰건을 μΆ©μ‘±ν•˜λŠ”μ§€ μ—¬λΆ€μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_python(minimum: str = "3.8.0", hard: bool = True) -> bool:
    """
    Check current python version against the required minimum version.

    Args:
        minimum (str): Required minimum version of python.
        hard (bool, optional): If True, raise an AssertionError if the requirement is not met.

    Returns:
        (bool): Whether the installed Python version meets the minimum constraints.
    """
    return check_version(PYTHON_VERSION, minimum, name="Python", hard=hard)



ultralytics.utils.checks.check_requirements(requirements=ROOT.parent / 'requirements.txt', exclude=(), install=True, cmds='')

μ„€μΉ˜λœ 쒅속성이 YOLOv8 μš”κ΅¬ 사항을 μΆ©μ‘±ν•˜λŠ”μ§€ ν™•μΈν•˜κ³  ν•„μš”ν•œ 경우 μžλ™ μ—…λ°μ΄νŠΈλ₯Ό μ‹œλ„ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
requirements Union[Path, str, List[str]]

μš”κ΅¬ 사항.txt 파일의 경둜, 단일 νŒ¨ν‚€μ§€ μš”κ΅¬ μ‚¬ν•­μ˜ 경우 λ¬Έμžμ—΄ λ˜λŠ” νŒ¨ν‚€μ§€ μš”κ΅¬ 사항 λͺ©λ‘μ„ λ¬Έμžμ—΄λ‘œ μ§€μ •ν•©λ‹ˆλ‹€.

parent / 'requirements.txt'
exclude Tuple[str]

κ²€μ‚¬μ—μ„œ μ œμ™Έν•  νŒ¨ν‚€μ§€ μ΄λ¦„μ˜ νŠœν”Œμž…λ‹ˆλ‹€.

()
install bool

True이면 μš”κ΅¬ 사항을 μΆ©μ‘±ν•˜μ§€ μ•ŠλŠ” νŒ¨ν‚€μ§€λ₯Ό μžλ™ μ—…λ°μ΄νŠΈν•˜λ €κ³  μ‹œλ„ν•©λ‹ˆλ‹€.

True
cmds str

μžλ™ μ—…λ°μ΄νŠΈ μ‹œ pip μ„€μΉ˜ λͺ…령에 전달할 μΆ”κ°€ λͺ…λ Ήμ–΄μž…λ‹ˆλ‹€.

''
예
from ultralytics.utils.checks import check_requirements

# Check a requirements.txt file
check_requirements('path/to/requirements.txt')

# Check a single package
check_requirements('ultralytics>=8.0.0')

# Check multiple packages
check_requirements(['numpy', 'ultralytics>=8.0.0'])
의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
@TryExcept()
def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=(), install=True, cmds=""):
    """
    Check if installed dependencies meet YOLOv8 requirements and attempt to auto-update if needed.

    Args:
        requirements (Union[Path, str, List[str]]): Path to a requirements.txt file, a single package requirement as a
            string, or a list of package requirements as strings.
        exclude (Tuple[str]): Tuple of package names to exclude from checking.
        install (bool): If True, attempt to auto-update packages that don't meet requirements.
        cmds (str): Additional commands to pass to the pip install command when auto-updating.

    Example:
        ```python
        from ultralytics.utils.checks import check_requirements

        # Check a requirements.txt file
        check_requirements('path/to/requirements.txt')

        # Check a single package
        check_requirements('ultralytics>=8.0.0')

        # Check multiple packages
        check_requirements(['numpy', 'ultralytics>=8.0.0'])
        ```
    """

    prefix = colorstr("red", "bold", "requirements:")
    check_python()  # check python version
    check_torchvision()  # check torch-torchvision compatibility
    if isinstance(requirements, Path):  # requirements.txt file
        file = requirements.resolve()
        assert file.exists(), f"{prefix} {file} not found, check failed."
        requirements = [f"{x.name}{x.specifier}" for x in parse_requirements(file) if x.name not in exclude]
    elif isinstance(requirements, str):
        requirements = [requirements]

    pkgs = []
    for r in requirements:
        r_stripped = r.split("/")[-1].replace(".git", "")  # replace git+https://org/repo.git -> 'repo'
        match = re.match(r"([a-zA-Z0-9-_]+)([<>!=~]+.*)?", r_stripped)
        name, required = match[1], match[2].strip() if match[2] else ""
        try:
            assert check_version(metadata.version(name), required)  # exception if requirements not met
        except (AssertionError, metadata.PackageNotFoundError):
            pkgs.append(r)

    @Retry(times=2, delay=1)
    def attempt_install(packages, commands):
        """Attempt pip install command with retries on failure."""
        return subprocess.check_output(f"pip install --no-cache-dir {packages} {commands}", shell=True).decode()

    s = " ".join(f'"{x}"' for x in pkgs)  # console string
    if s:
        if install and AUTOINSTALL:  # check environment variable
            n = len(pkgs)  # number of packages updates
            LOGGER.info(f"{prefix} Ultralytics requirement{'s' * (n > 1)} {pkgs} not found, attempting AutoUpdate...")
            try:
                t = time.time()
                assert ONLINE, "AutoUpdate skipped (offline)"
                LOGGER.info(attempt_install(s, cmds))
                dt = time.time() - t
                LOGGER.info(
                    f"{prefix} AutoUpdate success βœ… {dt:.1f}s, installed {n} package{'s' * (n > 1)}: {pkgs}\n"
                    f"{prefix} ⚠️ {colorstr('bold', 'Restart runtime or rerun command for updates to take effect')}\n"
                )
            except Exception as e:
                LOGGER.warning(f"{prefix} ❌ {e}")
                return False
        else:
            return False

    return True



ultralytics.utils.checks.check_torchvision()

PyTorch 및 Torchvision의 μ„€μΉ˜λœ 버전이 ν˜Έν™˜λ˜λŠ”μ§€ ν™•μΈν•©λ‹ˆλ‹€.

이 κΈ°λŠ₯은 PyTorch 및 Torchvision의 μ„€μΉ˜λœ 버전을 ν™•μΈν•˜κ³  ν˜Έν™˜λ˜μ§€ μ•ŠλŠ” 경우 λ‹€μŒκ³Ό 같이 κ²½κ³ ν•©λ‹ˆλ‹€. ν˜Έν™˜λ˜μ§€ μ•ŠλŠ” 경우 κ²½κ³ ν•©λ‹ˆλ‹€: https://github.com/pytorch/λΉ„μ „#μ„€μΉ˜.

ν˜Έν™˜μ„± ν…Œμ΄λΈ”μ€ ν‚€κ°€ PyTorch 버전이고 값이 ν˜Έν™˜λ˜λŠ” ν˜Έν™˜ κ°€λŠ₯ν•œ ν† μΉ˜λΉ„μ „ 버전 λͺ©λ‘μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_torchvision():
    """
    Checks the installed versions of PyTorch and Torchvision to ensure they're compatible.

    This function checks the installed versions of PyTorch and Torchvision, and warns if they're incompatible according
    to the provided compatibility table based on:
    https://github.com/pytorch/vision#installation.

    The compatibility table is a dictionary where the keys are PyTorch versions and the values are lists of compatible
    Torchvision versions.
    """

    # Compatibility table
    compatibility_table = {
        "2.3": ["0.18"],
        "2.2": ["0.17"],
        "2.1": ["0.16"],
        "2.0": ["0.15"],
        "1.13": ["0.14"],
        "1.12": ["0.13"],
    }

    # Extract only the major and minor versions
    v_torch = ".".join(torch.__version__.split("+")[0].split(".")[:2])
    if v_torch in compatibility_table:
        compatible_versions = compatibility_table[v_torch]
        v_torchvision = ".".join(TORCHVISION_VERSION.split("+")[0].split(".")[:2])
        if all(v_torchvision != v for v in compatible_versions):
            print(
                f"WARNING ⚠️ torchvision=={v_torchvision} is incompatible with torch=={v_torch}.\n"
                f"Run 'pip install torchvision=={compatible_versions[0]}' to fix torchvision or "
                "'pip install -U torch torchvision' to update both.\n"
                "For a full compatibility table see https://github.com/pytorch/vision#installation"
            )



ultralytics.utils.checks.check_suffix(file='yolov8n.pt', suffix='.pt', msg='')

νŒŒμΌμ—μ„œ ν—ˆμš©λ˜λŠ” 접미사가 μžˆλŠ”μ§€ ν™•μΈν•˜μ„Έμš”.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_suffix(file="yolov8n.pt", suffix=".pt", msg=""):
    """Check file(s) for acceptable suffix."""
    if file and suffix:
        if isinstance(suffix, str):
            suffix = (suffix,)
        for f in file if isinstance(file, (list, tuple)) else [file]:
            s = Path(f).suffix.lower().strip()  # file suffix
            if len(s):
                assert s in suffix, f"{msg}{f} acceptable suffix is {suffix}, not {s}"



ultralytics.utils.checks.check_yolov5u_filename(file, verbose=True)

κΈ°μ‘΄ YOLOv5 파일λͺ…을 μ—…λ°μ΄νŠΈλœ YOLOv5u 파일λͺ…μœΌλ‘œ λ°”κΏ‰λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_yolov5u_filename(file: str, verbose: bool = True):
    """Replace legacy YOLOv5 filenames with updated YOLOv5u filenames."""
    if "yolov3" in file or "yolov5" in file:
        if "u.yaml" in file:
            file = file.replace("u.yaml", ".yaml")  # i.e. yolov5nu.yaml -> yolov5n.yaml
        elif ".pt" in file and "u" not in file:
            original_file = file
            file = re.sub(r"(.*yolov5([nsmlx]))\.pt", "\\1u.pt", file)  # i.e. yolov5n.pt -> yolov5nu.pt
            file = re.sub(r"(.*yolov5([nsmlx])6)\.pt", "\\1u.pt", file)  # i.e. yolov5n6.pt -> yolov5n6u.pt
            file = re.sub(r"(.*yolov3(|-tiny|-spp))\.pt", "\\1u.pt", file)  # i.e. yolov3-spp.pt -> yolov3-sppu.pt
            if file != original_file and verbose:
                LOGGER.info(
                    f"PRO TIP πŸ’‘ Replace 'model={original_file}' with new 'model={file}'.\nYOLOv5 'u' models are "
                    f"trained with https://github.com/ultralytics/ultralytics and feature improved performance vs "
                    f"standard YOLOv5 models trained with https://github.com/ultralytics/yolov5.\n"
                )
    return file



ultralytics.utils.checks.check_model_file_from_stem(model='yolov8n')

μœ νš¨ν•œ λͺ¨λΈ μŠ€ν…œμ—μ„œ λͺ¨λΈ 파일λͺ…을 λ°˜ν™˜ν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_model_file_from_stem(model="yolov8n"):
    """Return a model filename from a valid model stem."""
    if model and not Path(model).suffix and Path(model).stem in downloads.GITHUB_ASSETS_STEMS:
        return Path(model).with_suffix(".pt")  # add suffix, i.e. yolov8n -> yolov8n.pt
    else:
        return model



ultralytics.utils.checks.check_file(file, suffix='', download=True, hard=True)

파일 검색/λ‹€μš΄λ‘œλ“œ(ν•„μš”ν•œ 경우) 및 λ°˜ν™˜ 경둜λ₯Ό μž…λ ₯ν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_file(file, suffix="", download=True, hard=True):
    """Search/download file (if necessary) and return path."""
    check_suffix(file, suffix)  # optional
    file = str(file).strip()  # convert to string and strip spaces
    file = check_yolov5u_filename(file)  # yolov5n -> yolov5nu
    if (
        not file
        or ("://" not in file and Path(file).exists())  # '://' check required in Windows Python<3.10
        or file.lower().startswith("grpc://")
    ):  # file exists or gRPC Triton images
        return file
    elif download and file.lower().startswith(("https://", "http://", "rtsp://", "rtmp://", "tcp://")):  # download
        url = file  # warning: Pathlib turns :// -> :/
        file = url2file(file)  # '%2F' to '/', split https://url.com/file.txt?auth
        if Path(file).exists():
            LOGGER.info(f"Found {clean_url(url)} locally at {file}")  # file already exists
        else:
            downloads.safe_download(url=url, file=file, unzip=False)
        return file
    else:  # search
        files = glob.glob(str(ROOT / "**" / file), recursive=True) or glob.glob(str(ROOT.parent / file))  # find file
        if not files and hard:
            raise FileNotFoundError(f"'{file}' does not exist")
        elif len(files) > 1 and hard:
            raise FileNotFoundError(f"Multiple files match '{file}', specify exact path: {files}")
        return files[0] if len(files) else []  # return file



ultralytics.utils.checks.check_yaml(file, suffix=('.yaml', '.yml'), hard=True)

ν•„μš”ν•œ 경우 YAML νŒŒμΌμ„ 검색/λ‹€μš΄λ‘œλ“œν•˜κ³  접미사λ₯Ό ν™•μΈν•˜μ—¬ 경둜λ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_yaml(file, suffix=(".yaml", ".yml"), hard=True):
    """Search/download YAML file (if necessary) and return path, checking suffix."""
    return check_file(file, suffix, hard=hard)



ultralytics.utils.checks.check_is_path_safe(basedir, path)

경둜 탐색을 λ°©μ§€ν•˜κΈ° μœ„ν•΄ ν™•μΈλœ κ²½λ‘œκ°€ μ˜λ„ν•œ 디렉토리 μ•„λž˜μ— μžˆλŠ”μ§€ ν™•μΈν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
basedir Path | str

μ˜λ„ν•œ λ””λ ‰ν„°λ¦¬μž…λ‹ˆλ‹€.

ν•„μˆ˜
path Path | str

확인할 κ²½λ‘œμž…λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
bool

κ²½λ‘œκ°€ μ•ˆμ „ν•˜λ©΄ 참이고, 그렇지 μ•ŠμœΌλ©΄ κ±°μ§“μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_is_path_safe(basedir, path):
    """
    Check if the resolved path is under the intended directory to prevent path traversal.

    Args:
        basedir (Path | str): The intended directory.
        path (Path | str): The path to check.

    Returns:
        (bool): True if the path is safe, False otherwise.
    """
    base_dir_resolved = Path(basedir).resolve()
    path_resolved = Path(path).resolve()

    return path_resolved.exists() and path_resolved.parts[: len(base_dir_resolved.parts)] == base_dir_resolved.parts



ultralytics.utils.checks.check_imshow(warn=False)

ν™˜κ²½μ΄ 이미지 λ””μŠ€ν”Œλ ˆμ΄λ₯Ό μ§€μ›ν•˜λŠ”μ§€ ν™•μΈν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_imshow(warn=False):
    """Check if environment supports image displays."""
    try:
        if LINUX:
            assert not IS_COLAB and not IS_KAGGLE
            assert "DISPLAY" in os.environ, "The DISPLAY environment variable isn't set."
        cv2.imshow("test", np.zeros((8, 8, 3), dtype=np.uint8))  # show a small 8-pixel image
        cv2.waitKey(1)
        cv2.destroyAllWindows()
        cv2.waitKey(1)
        return True
    except Exception as e:
        if warn:
            LOGGER.warning(f"WARNING ⚠️ Environment does not support cv2.imshow() or PIL Image.show()\n{e}")
        return False



ultralytics.utils.checks.check_yolo(verbose=True, device='')

μ‚¬λžŒμ΄ 읽을 수 μžˆλŠ” YOLO μ†Œν”„νŠΈμ›¨μ–΄ 및 ν•˜λ“œμ›¨μ–΄ μš”μ•½λ³Έμ„ λ°˜ν™˜ν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_yolo(verbose=True, device=""):
    """Return a human-readable YOLO software and hardware summary."""
    import psutil

    from ultralytics.utils.torch_utils import select_device

    if IS_JUPYTER:
        if check_requirements("wandb", install=False):
            os.system("pip uninstall -y wandb")  # uninstall wandb: unwanted account creation prompt with infinite hang
        if IS_COLAB:
            shutil.rmtree("sample_data", ignore_errors=True)  # remove colab /sample_data directory

    if verbose:
        # System info
        gib = 1 << 30  # bytes per GiB
        ram = psutil.virtual_memory().total
        total, used, free = shutil.disk_usage("/")
        s = f"({os.cpu_count()} CPUs, {ram / gib:.1f} GB RAM, {(total - free) / gib:.1f}/{total / gib:.1f} GB disk)"
        with contextlib.suppress(Exception):  # clear display if ipython is installed
            from IPython import display

            display.clear_output()
    else:
        s = ""

    select_device(device=device, newline=False)
    LOGGER.info(f"Setup complete βœ… {s}")



ultralytics.utils.checks.collect_system_info()

OS, Python, RAM, CPU, CUDA λ“± κ΄€λ ¨ μ‹œμŠ€ν…œ 정보λ₯Ό μˆ˜μ§‘ν•˜κ³  μΈμ‡„ν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def collect_system_info():
    """Collect and print relevant system information including OS, Python, RAM, CPU, and CUDA."""

    import psutil

    from ultralytics.utils import ENVIRONMENT, IS_GIT_DIR
    from ultralytics.utils.torch_utils import get_cpu_info

    ram_info = psutil.virtual_memory().total / (1024**3)  # Convert bytes to GB
    check_yolo()
    LOGGER.info(
        f"\n{'OS':<20}{platform.platform()}\n"
        f"{'Environment':<20}{ENVIRONMENT}\n"
        f"{'Python':<20}{PYTHON_VERSION}\n"
        f"{'Install':<20}{'git' if IS_GIT_DIR else 'pip' if IS_PIP_PACKAGE else 'other'}\n"
        f"{'RAM':<20}{ram_info:.2f} GB\n"
        f"{'CPU':<20}{get_cpu_info()}\n"
        f"{'CUDA':<20}{torch.version.cuda if torch and torch.cuda.is_available() else None}\n"
    )

    for r in parse_requirements(package="ultralytics"):
        try:
            current = metadata.version(r.name)
            is_met = "βœ… " if check_version(current, str(r.specifier), hard=True) else "❌ "
        except metadata.PackageNotFoundError:
            current = "(not installed)"
            is_met = "❌ "
        LOGGER.info(f"{r.name:<20}{is_met}{current}{r.specifier}")

    if is_github_action_running():
        LOGGER.info(
            f"\nRUNNER_OS: {os.getenv('RUNNER_OS')}\n"
            f"GITHUB_EVENT_NAME: {os.getenv('GITHUB_EVENT_NAME')}\n"
            f"GITHUB_WORKFLOW: {os.getenv('GITHUB_WORKFLOW')}\n"
            f"GITHUB_ACTOR: {os.getenv('GITHUB_ACTOR')}\n"
            f"GITHUB_REPOSITORY: {os.getenv('GITHUB_REPOSITORY')}\n"
            f"GITHUB_REPOSITORY_OWNER: {os.getenv('GITHUB_REPOSITORY_OWNER')}\n"
        )



ultralytics.utils.checks.check_amp(model)

이 κΈ°λŠ₯은 YOLOv8 λͺ¨λΈμ˜ PyTorch μžλ™ ν˜Όν•© 정밀도(AMP) κΈ°λŠ₯을 ν™•μΈν•©λ‹ˆλ‹€. 검사에 에 μ‹€νŒ¨ν•˜λ©΄ μ‹œμŠ€ν…œμ—μ„œ AMP에 이상이 μžˆμ–΄ NaN 손싀 λ˜λŠ” 제둜 맡 κ²°κ³Όλ₯Ό μ΄ˆλž˜ν•  수 μžˆμœΌλ―€λ‘œ ν›ˆλ ¨ 쀑에 AMPκ°€ ν›ˆλ ¨ 쀑에 λΉ„ν™œμ„±ν™”λ©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
model Module

YOLOv8 λͺ¨λΈ μΈμŠ€ν„΄μŠ€μž…λ‹ˆλ‹€.

ν•„μˆ˜
예
from ultralytics import YOLO
from ultralytics.utils.checks import check_amp

model = YOLO('yolov8n.pt').model.cuda()
check_amp(model)

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
bool

AMP κΈ°λŠ₯이 YOLOv8 λͺ¨λΈμ—μ„œ μ˜¬λ°”λ₯΄κ²Œ μž‘λ™ν•˜λ©΄ 참을 λ°˜ν™˜ν•˜κ³ , 그렇지 μ•ŠμœΌλ©΄ 거짓을 λ°˜ν™˜ν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def check_amp(model):
    """
    This function checks the PyTorch Automatic Mixed Precision (AMP) functionality of a YOLOv8 model. If the checks
    fail, it means there are anomalies with AMP on the system that may cause NaN losses or zero-mAP results, so AMP will
    be disabled during training.

    Args:
        model (nn.Module): A YOLOv8 model instance.

    Example:
        ```python
        from ultralytics import YOLO
        from ultralytics.utils.checks import check_amp

        model = YOLO('yolov8n.pt').model.cuda()
        check_amp(model)
        ```

    Returns:
        (bool): Returns True if the AMP functionality works correctly with YOLOv8 model, else False.
    """
    device = next(model.parameters()).device  # get model device
    if device.type in {"cpu", "mps"}:
        return False  # AMP only used on CUDA devices

    def amp_allclose(m, im):
        """All close FP32 vs AMP results."""
        a = m(im, device=device, verbose=False)[0].boxes.data  # FP32 inference
        with torch.cuda.amp.autocast(True):
            b = m(im, device=device, verbose=False)[0].boxes.data  # AMP inference
        del m
        return a.shape == b.shape and torch.allclose(a, b.float(), atol=0.5)  # close to 0.5 absolute tolerance

    im = ASSETS / "bus.jpg"  # image to check
    prefix = colorstr("AMP: ")
    LOGGER.info(f"{prefix}running Automatic Mixed Precision (AMP) checks with YOLOv8n...")
    warning_msg = "Setting 'amp=True'. If you experience zero-mAP or NaN losses you can disable AMP with amp=False."
    try:
        from ultralytics import YOLO

        assert amp_allclose(YOLO("yolov8n.pt"), im)
        LOGGER.info(f"{prefix}checks passed βœ…")
    except ConnectionError:
        LOGGER.warning(f"{prefix}checks skipped ⚠️, offline and unable to download YOLOv8n. {warning_msg}")
    except (AttributeError, ModuleNotFoundError):
        LOGGER.warning(
            f"{prefix}checks skipped ⚠️. "
            f"Unable to load YOLOv8n due to possible Ultralytics package modifications. {warning_msg}"
        )
    except AssertionError:
        LOGGER.warning(
            f"{prefix}checks failed ❌. Anomalies were detected with AMP on your system that may lead to "
            f"NaN losses or zero-mAP results, so AMP will be disabled during training."
        )
        return False
    return True



ultralytics.utils.checks.git_describe(path=ROOT)

μ‚¬λžŒμ΄ 읽을 수 μžˆλŠ” git μ„€λͺ…(예: v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe)을 λ°˜ν™˜ν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def git_describe(path=ROOT):  # path must be a directory
    """Return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe."""
    with contextlib.suppress(Exception):
        return subprocess.check_output(f"git -C {path} describe --tags --long --always", shell=True).decode()[:-1]
    return ""



ultralytics.utils.checks.print_args(args=None, show_file=True, show_func=False)

ν•¨μˆ˜ 인수λ₯Ό μΈμ‡„ν•©λ‹ˆλ‹€(선택적 인수 λ”•μ…”λ„ˆλ¦¬).

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def print_args(args: Optional[dict] = None, show_file=True, show_func=False):
    """Print function arguments (optional args dict)."""

    def strip_auth(v):
        """Clean longer Ultralytics HUB URLs by stripping potential authentication information."""
        return clean_url(v) if (isinstance(v, str) and v.startswith("http") and len(v) > 100) else v

    x = inspect.currentframe().f_back  # previous frame
    file, _, func, _, _ = inspect.getframeinfo(x)
    if args is None:  # get args automatically
        args, _, _, frm = inspect.getargvalues(x)
        args = {k: v for k, v in frm.items() if k in args}
    try:
        file = Path(file).resolve().relative_to(ROOT).with_suffix("")
    except ValueError:
        file = Path(file).stem
    s = (f"{file}: " if show_file else "") + (f"{func}: " if show_func else "")
    LOGGER.info(colorstr(s) + ", ".join(f"{k}={strip_auth(v)}" for k, v in args.items()))



ultralytics.utils.checks.cuda_device_count()

ν™˜κ²½μ—μ„œ μ‚¬μš© κ°€λŠ₯ν•œ NVIDIA GPU 수λ₯Ό ν™•μΈν•©λ‹ˆλ‹€.

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
int

μ‚¬μš© κ°€λŠ₯ν•œ NVIDIA GPU μˆ˜μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def cuda_device_count() -> int:
    """
    Get the number of NVIDIA GPUs available in the environment.

    Returns:
        (int): The number of NVIDIA GPUs available.
    """
    try:
        # Run the nvidia-smi command and capture its output
        output = subprocess.check_output(
            ["nvidia-smi", "--query-gpu=count", "--format=csv,noheader,nounits"], encoding="utf-8"
        )

        # Take the first line and strip any leading/trailing white space
        first_line = output.strip().split("\n")[0]

        return int(first_line)
    except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
        # If the command fails, nvidia-smi is not found, or output is not an integer, assume no GPUs are available
        return 0



ultralytics.utils.checks.cuda_is_available()

ν™˜κ²½μ—μ„œ CUDAλ₯Ό μ‚¬μš©ν•  수 μžˆλŠ”μ§€ ν™•μΈν•©λ‹ˆλ‹€.

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
bool

ν•˜λ‚˜ μ΄μƒμ˜ NVIDIA GPUλ₯Ό μ‚¬μš©ν•  수 있으면 True, 그렇지 μ•ŠμœΌλ©΄ Falseμž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/checks.py
def cuda_is_available() -> bool:
    """
    Check if CUDA is available in the environment.

    Returns:
        (bool): True if one or more NVIDIA GPUs are available, False otherwise.
    """
    return cuda_device_count() > 0





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