Overslaan naar inhoud

Referentie voor ultralytics/utils/files.py

Opmerking

Dit bestand is beschikbaar op https://github.com/ultralytics/ ultralytics/blob/main/ ultralytics/utils/files .py. Als je een probleem ziet, help het dan oplossen door een Pull Request 🛠️ bij te dragen. Bedankt 🙏!



ultralytics.utils.files.WorkingDirectory

Basis: ContextDecorator

Gebruik: @WorkingDirectory(dir) decorator of 'with WorkingDirectory(dir):' contextmanager.

Broncode in ultralytics/utils/files.py
class WorkingDirectory(contextlib.ContextDecorator):
    """Usage: @WorkingDirectory(dir) decorator or 'with WorkingDirectory(dir):' context manager."""

    def __init__(self, new_dir):
        """Sets the working directory to 'new_dir' upon instantiation."""
        self.dir = new_dir  # new dir
        self.cwd = Path.cwd().resolve()  # current dir

    def __enter__(self):
        """Changes the current directory to the specified directory."""
        os.chdir(self.dir)

    def __exit__(self, exc_type, exc_val, exc_tb):  # noqa
        """Restore the current working directory on context exit."""
        os.chdir(self.cwd)

__enter__()

Verandert de huidige map in de opgegeven map.

Broncode in ultralytics/utils/files.py
def __enter__(self):
    """Changes the current directory to the specified directory."""
    os.chdir(self.dir)

__exit__(exc_type, exc_val, exc_tb)

Herstel de huidige werkmap bij het afsluiten van de context.

Broncode in ultralytics/utils/files.py
def __exit__(self, exc_type, exc_val, exc_tb):  # noqa
    """Restore the current working directory on context exit."""
    os.chdir(self.cwd)

__init__(new_dir)

Stelt de werkdirectory in op 'new_dir' bij het instantiëren.

Broncode in ultralytics/utils/files.py
def __init__(self, new_dir):
    """Sets the working directory to 'new_dir' upon instantiation."""
    self.dir = new_dir  # new dir
    self.cwd = Path.cwd().resolve()  # current dir



ultralytics.utils.files.spaces_in_path(path)

Contextmanager voor het afhandelen van paden met spaties in hun naam. Als een pad spaties bevat, worden deze vervangen door underscores, kopieert het bestand/de map naar het nieuwe pad, voert het context codeblok uit en kopieert dan het bestand/directory terug naar de oorspronkelijke locatie.

Parameters:

Naam Type Beschrijving Standaard
path str | Path

Het oorspronkelijke pad.

vereist

Opbrengsten:

Type Beschrijving
Path

Tijdelijk pad met spaties vervangen door underscores als spaties aanwezig waren, anders het oorspronkelijke pad.

Voorbeeld
with ultralytics.utils.files import spaces_in_path

with spaces_in_path('/path/with spaces') as new_path:
    # Your code here
Broncode in ultralytics/utils/files.py
@contextmanager
def spaces_in_path(path):
    """
    Context manager to handle paths with spaces in their names. If a path contains spaces, it replaces them with
    underscores, copies the file/directory to the new path, executes the context code block, then copies the
    file/directory back to its original location.

    Args:
        path (str | Path): The original path.

    Yields:
        (Path): Temporary path with spaces replaced by underscores if spaces were present, otherwise the original path.

    Example:
        ```python
        with ultralytics.utils.files import spaces_in_path

        with spaces_in_path('/path/with spaces') as new_path:
            # Your code here
        ```
    """

    # If path has spaces, replace them with underscores
    if " " in str(path):
        string = isinstance(path, str)  # input type
        path = Path(path)

        # Create a temporary directory and construct the new path
        with tempfile.TemporaryDirectory() as tmp_dir:
            tmp_path = Path(tmp_dir) / path.name.replace(" ", "_")

            # Copy file/directory
            if path.is_dir():
                # tmp_path.mkdir(parents=True, exist_ok=True)
                shutil.copytree(path, tmp_path)
            elif path.is_file():
                tmp_path.parent.mkdir(parents=True, exist_ok=True)
                shutil.copy2(path, tmp_path)

            try:
                # Yield the temporary path
                yield str(tmp_path) if string else tmp_path

            finally:
                # Copy file/directory back
                if tmp_path.is_dir():
                    shutil.copytree(tmp_path, path, dirs_exist_ok=True)
                elif tmp_path.is_file():
                    shutil.copy2(tmp_path, path)  # Copy back the file

    else:
        # If there are no spaces, just yield the original path
        yield path



ultralytics.utils.files.increment_path(path, exist_ok=False, sep='', mkdir=False)

Verhoogt het pad van een bestand of map, bijv. runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... enz.

Als het pad bestaat en exist_ok is niet ingesteld op True, dan wordt het pad opgehoogd door een nummer en sep toe te voegen aan toe te voegen aan het einde van het pad. Als het pad een bestand is, zal de bestandsextensie behouden blijven. Als het pad een map is, wordt het nummer direct aan het einde van het pad toegevoegd. Als mkdir is ingesteld op True, wordt het pad aangemaakt als een map aangemaakt als deze nog niet bestaat.

Parameters:

Naam Type Beschrijving Standaard
path (str, Path)

Pad naar toename.

vereist
exist_ok bool

Als dit Waar is, wordt het pad niet opgehoogd en wordt het geretourneerd zoals het is. Standaard is dit Onwaar.

False
sep str

Scheidingsteken dat moet worden gebruikt tussen het pad en het toenamegetal. Staat standaard op ''.

''
mkdir bool

Maak een map als deze niet bestaat. Staat standaard op False.

False

Retourneert:

Type Beschrijving
Path

Verhoogd pad.

Broncode in ultralytics/utils/files.py
def increment_path(path, exist_ok=False, sep="", mkdir=False):
    """
    Increments a file or directory path, i.e. runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.

    If the path exists and exist_ok is not set to True, the path will be incremented by appending a number and sep to
    the end of the path. If the path is a file, the file extension will be preserved. If the path is a directory, the
    number will be appended directly to the end of the path. If mkdir is set to True, the path will be created as a
    directory if it does not already exist.

    Args:
        path (str, pathlib.Path): Path to increment.
        exist_ok (bool, optional): If True, the path will not be incremented and returned as-is. Defaults to False.
        sep (str, optional): Separator to use between the path and the incrementation number. Defaults to ''.
        mkdir (bool, optional): Create a directory if it does not exist. Defaults to False.

    Returns:
        (pathlib.Path): Incremented path.
    """
    path = Path(path)  # os-agnostic
    if path.exists() and not exist_ok:
        path, suffix = (path.with_suffix(""), path.suffix) if path.is_file() else (path, "")

        # Method 1
        for n in range(2, 9999):
            p = f"{path}{sep}{n}{suffix}"  # increment path
            if not os.path.exists(p):
                break
        path = Path(p)

    if mkdir:
        path.mkdir(parents=True, exist_ok=True)  # make directory

    return path



ultralytics.utils.files.file_age(path=__file__)

Dagen sinds de laatste bestandsupdate.

Broncode in ultralytics/utils/files.py
def file_age(path=__file__):
    """Return days since last file update."""
    dt = datetime.now() - datetime.fromtimestamp(Path(path).stat().st_mtime)  # delta
    return dt.days  # + dt.seconds / 86400  # fractional days



ultralytics.utils.files.file_date(path=__file__)

Geeft de menselijk leesbare wijzigingsdatum van een bestand, bijvoorbeeld '2021-3-26'.

Broncode in ultralytics/utils/files.py
def file_date(path=__file__):
    """Return human-readable file modification date, i.e. '2021-3-26'."""
    t = datetime.fromtimestamp(Path(path).stat().st_mtime)
    return f"{t.year}-{t.month}-{t.day}"



ultralytics.utils.files.file_size(path)

Grootte retourbestand/dir (MB).

Broncode in ultralytics/utils/files.py
def file_size(path):
    """Return file/dir size (MB)."""
    if isinstance(path, (str, Path)):
        mb = 1 << 20  # bytes to MiB (1024 ** 2)
        path = Path(path)
        if path.is_file():
            return path.stat().st_size / mb
        elif path.is_dir():
            return sum(f.stat().st_size for f in path.glob("**/*") if f.is_file()) / mb
    return 0.0



ultralytics.utils.files.get_latest_run(search_dir='.')

Geeft het pad terug naar de meest recente 'last.pt' in /runs (dus naar --hervatten vanaf).

Broncode in ultralytics/utils/files.py
def get_latest_run(search_dir="."):
    """Return path to most recent 'last.pt' in /runs (i.e. to --resume from)."""
    last_list = glob.glob(f"{search_dir}/**/last*.pt", recursive=True)
    return max(last_list, key=os.path.getctime) if last_list else ""



ultralytics.utils.files.update_models(model_names=('yolov8n.pt'), source_dir=Path('.'), update_names=False)

Updates en opnieuw opslaan van gespecificeerde YOLO modellen in een 'updated_models' subdirectory.

Parameters:

Naam Type Beschrijving Standaard
model_names tuple

Modelbestandsnamen die moeten worden bijgewerkt, standaard ("yolov8n.pt").

('yolov8n.pt')
source_dir Path

Directory met modellen en doel subdirectory, standaard de huidige directory.

Path('.')
update_names bool

Modelnamen bijwerken vanuit een YAML-gegeven.

False
Voorbeeld
from ultralytics.utils.files import update_models

model_names = (f"rtdetr-{size}.pt" for size in "lx")
update_models(model_names)
Broncode in ultralytics/utils/files.py
def update_models(model_names=("yolov8n.pt",), source_dir=Path("."), update_names=False):
    """
    Updates and re-saves specified YOLO models in an 'updated_models' subdirectory.

    Args:
        model_names (tuple, optional): Model filenames to update, defaults to ("yolov8n.pt").
        source_dir (Path, optional): Directory containing models and target subdirectory, defaults to current directory.
        update_names (bool, optional): Update model names from a data YAML.

    Example:
        ```python
        from ultralytics.utils.files import update_models

        model_names = (f"rtdetr-{size}.pt" for size in "lx")
        update_models(model_names)
        ```
    """
    from ultralytics import YOLO
    from ultralytics.nn.autobackend import default_class_names

    target_dir = source_dir / "updated_models"
    target_dir.mkdir(parents=True, exist_ok=True)  # Ensure target directory exists

    for model_name in model_names:
        model_path = source_dir / model_name
        print(f"Loading model from {model_path}")

        # Load model
        model = YOLO(model_path)
        model.half()
        if update_names:  # update model names from a dataset YAML
            model.model.names = default_class_names("coco8.yaml")

        # Define new save path
        save_path = target_dir / model_name

        # Save model using model.save()
        print(f"Re-saving {model_name} model to {save_path}")
        model.save(save_path, use_dill=False)





Aangemaakt 2023-11-12, Bijgewerkt 2024-06-02
Auteurs: glenn-jocher (6), Burhan-Q (1), Laughing-q (1)