Saltar al contenido

Referencia para ultralytics/utils/files.py

Nota

Este archivo est├í disponible en https://github.com/ultralytics/ ultralytics/blob/main/ ultralytics/utils/files .py. Si detectas alg├║n problema, por favor, ayuda a solucionarlo contribuyendo con una Pull Request ­čŤá´ŞĆ. ┬íGracias ­čÖĆ!



ultralytics.utils.files.WorkingDirectory

Bases: ContextDecorator

Utilizaci├│n: @DirectorioDeTrabajo(dir) decorador o 'con DirectorioDeTrabajo(dir):' gestor de contexto.

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

Cambia el directorio actual por el directorio especificado.

C├│digo fuente en 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)

Restaura el directorio de trabajo actual al salir del contexto.

C├│digo fuente en 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)

Establece el directorio de trabajo en 'directorio_nuevo' al iniciarlo.

C├│digo fuente en 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)

Gestor de contexto para tratar las rutas con espacios en sus nombres. Si una ruta contiene espacios, los sustituye por guiones bajos, copia el archivo/directorio a la nueva ruta, ejecuta el bloque de c├│digo de contexto y, a continuaci├│n, copia el archivo/directorio a su ubicaci├│n original. archivo/directorio a su ubicaci├│n original.

Parámetros:

Nombre Tipo Descripci├│n Por defecto
path str | Path

El camino original.

necesario

Rendimiento:

Tipo Descripci├│n
Path

Ruta temporal con los espacios sustituidos por guiones bajos si hab├şa espacios, en caso contrario la ruta original.

Ejemplo
with ultralytics.utils.files import spaces_in_path

with spaces_in_path('/path/with spaces') as new_path:
    # Your code here
C├│digo fuente en 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)

Incrementa una ruta de archivo o directorio, es decir, runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.

Si la ruta existe y exist_ok no es Verdadero, se incrementará la ruta añadiendo un número y sep al al final de la ruta. Si la ruta es un archivo, se conservará la extensión del archivo. Si la ruta es un directorio, el número número se añadirá directamente al final de la ruta. Si el valor de mkdir es Verdadero, la ruta se creará como un directorio directorio si aún no existe.

Parámetros:

Nombre Tipo Descripci├│n Por defecto
path (str, Path)

Camino hacia el incremento.

necesario
exist_ok bool

Si es True, la ruta no se incrementará y se devolverá tal cual. Por defecto es Falso.

False
sep str

Separador a utilizar entre la ruta y el n├║mero de incremento. Por defecto es ''.

''
mkdir bool

Crea un directorio si no existe. Por defecto es Falso.

False

Devuelve:

Tipo Descripci├│n
Path

Ruta incrementada.

C├│digo fuente en 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__)

Devuelve los d├şas transcurridos desde la ├║ltima actualizaci├│n del archivo.

C├│digo fuente en 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__)

Devuelve una fecha de modificaci├│n del archivo legible por humanos, es decir, '2021-3-26'.

C├│digo fuente en 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)

Devuelve el tama├▒o del archivo/directorio (MB).

C├│digo fuente en 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='.')

Devuelve la ruta al 'último.pt' más reciente en /ejecuta (es decir, a --reanudar desde).

C├│digo fuente en 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)

Actualiza y vuelve a guardar los modelos YOLO especificados en un subdirectorio 'modelos_actualizados'.

Parámetros:

Nombre Tipo Descripci├│n Por defecto
model_names tuple

Nombres de archivo del modelo a actualizar, por defecto ("yolov8n.pt").

('yolov8n.pt')
source_dir Path

Directorio que contiene los modelos y el subdirectorio de destino, por defecto es el directorio actual.

Path('.')
update_names bool

Actualiza los nombres de los modelos a partir de un YAML de datos.

False
Ejemplo
from ultralytics.utils.files import update_models

model_names = (f"rtdetr-{size}.pt" for size in "lx")
update_models(model_names)
C├│digo fuente en 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)





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