Clean up imports and remove them

src/accelerator.py

@@ -1,140 +1,3 @@
-
-
-from __future__ import annotations
-
-import contextlib
-import functools
-import json
-import math
-import os
-import re
-import shutil
-import sys
-import warnings
-from collections import OrderedDict
-from contextlib import contextmanager
-from functools import partial
-from types import MethodType
-from typing import Any, Callable, Union
-
-import torch
-import torch.utils.hooks as hooks
-
-from .checkpointing import load_accelerator_state, load_custom_state, save_accelerator_state, save_custom_state
-from .data_loader import DataLoaderDispatcher, prepare_data_loader, skip_first_batches
-from .hooks import AlignDevicesHook
-from .logging import get_logger
-from .optimizer import AcceleratedOptimizer
-from .scheduler import AcceleratedScheduler
-from .state import AcceleratorState, GradientState, PartialState
-from .tracking import LOGGER_TYPE_TO_CLASS, GeneralTracker, filter_trackers
-from .utils import (
-    MODEL_NAME,
-    SAFE_WEIGHTS_INDEX_NAME,
-    SAFE_WEIGHTS_NAME,
-    WEIGHTS_INDEX_NAME,
-    WEIGHTS_NAME,
-    AutocastKwargs,
-    DeepSpeedPlugin,
-    DistributedDataParallelKwargs,
-    DistributedType,
-    DynamoBackend,
-    FP8RecipeKwargs,
-    FullyShardedDataParallelPlugin,
-    GradientAccumulationPlugin,
-    GradScalerKwargs,
-    InitProcessGroupKwargs,
-    KwargsHandler,
-    LoggerType,
-    MegatronLMPlugin,
-    PrecisionType,
-    ProjectConfiguration,
-    RNGType,
-    TorchDynamoPlugin,
-    check_os_kernel,
-    clean_state_dict_for_safetensors,
-    compare_versions,
-    convert_model,
-    convert_outputs_to_fp32,
-    extract_model_from_parallel,
-    gather,
-    gather_object,
-    get_mixed_precision_context_manager,
-    get_pretty_name,
-    has_transformer_engine_layers,
-    is_bf16_available,
-    is_deepspeed_available,
-    is_fp8_available,
-    is_ipex_available,
-    is_megatron_lm_available,
-    is_msamp_available,
-    is_npu_available,
-    is_torch_version,
-    is_tpu_available,
-    is_xpu_available,
-    load_fsdp_model,
-    load_fsdp_optimizer,
-    pad_across_processes,
-    parse_choice_from_env,
-    recursively_apply,
-    reduce,
-    release_memory,
-    save,
-    save_fsdp_model,
-    save_fsdp_optimizer,
-    shard_checkpoint,
-    wait_for_everyone,
-)
-from .utils.constants import FSDP_PYTORCH_VERSION
-from .utils.modeling import get_state_dict_offloaded_model
-from .utils.other import is_compiled_module
-
-
-if is_deepspeed_available():
-    from .utils import (
-        DeepSpeedEngineWrapper,
-        DeepSpeedOptimizerWrapper,
-        DeepSpeedSchedulerWrapper,
-        DummyOptim,
-        DummyScheduler,
-    )
-
-if is_fp8_available():
-    import transformer_engine.common.recipe as te_recipe
-    from transformer_engine.pytorch import fp8_autocast
-
-
-if is_megatron_lm_available():
-    from .utils import (
-        MegatronEngine,
-        MegatronLMDummyDataLoader,
-        MegatronLMDummyScheduler,
-        MegatronLMOptimizerWrapper,
-        MegatronLMSchedulerWrapper,
-        megatron_lm_initialize,
-        megatron_lm_prepare_data_loader,
-        megatron_lm_prepare_model,
-        megatron_lm_prepare_optimizer,
-        megatron_lm_prepare_scheduler,
-    )
-
-from torch.distributed.algorithms.join import Join
-
-
-if is_tpu_available(check_device=False):
-    import torch_xla.core.xla_model as xm
-    import torch_xla.distributed.xla_multiprocessing as xmp
-
-
-if is_npu_available(check_device=False):
-    import torch_npu  # noqa: F401
-
-
-try:
-    from torch.optim.lr_scheduler import LRScheduler
-except ImportError:
-    from torch.optim.lr_scheduler import _LRScheduler as LRScheduler
-
 logger = get_logger(__name__)
 
 

src/big_modeling.py

@@ -1,38 +1,3 @@
-
-
-import logging
-import os
-from contextlib import contextmanager
-from functools import wraps
-from typing import Dict, List, Optional, Union
-
-import torch
-import torch.nn as nn
-
-from .hooks import (
-    AlignDevicesHook,
-    CpuOffload,
-    UserCpuOffloadHook,
-    add_hook_to_module,
-    attach_align_device_hook,
-    attach_align_device_hook_on_blocks,
-)
-from .utils import (
-    OffloadedWeightsLoader,
-    check_device_map,
-    extract_submodules_state_dict,
-    find_tied_parameters,
-    get_balanced_memory,
-    infer_auto_device_map,
-    is_npu_available,
-    is_torch_version,
-    load_checkpoint_in_model,
-    offload_state_dict,
-    parse_flag_from_env,
-    retie_parameters,
-)
-
-
 logger = logging.getLogger(__name__)
 
 

src/checkpointing.py

@@ -1,38 +1,3 @@
-
-
-import random
-from pathlib import Path
-from typing import List
-
-import numpy as np
-import torch
-from safetensors.torch import load_file
-from torch.cuda.amp import GradScaler
-
-from .utils import (
-    MODEL_NAME,
-    OPTIMIZER_NAME,
-    RNG_STATE_NAME,
-    SAFE_MODEL_NAME,
-    SAFE_WEIGHTS_NAME,
-    SAMPLER_NAME,
-    SCALER_NAME,
-    SCHEDULER_NAME,
-    WEIGHTS_NAME,
-    get_pretty_name,
-    is_tpu_available,
-    is_xpu_available,
-    save,
-)
-
-
-if is_tpu_available(check_device=False):
-    import torch_xla.core.xla_model as xm
-
-from .logging import get_logger
-from .state import PartialState
-
-
 logger = get_logger(__name__)
 
 

src/commands/accelerate_cli.py

@@ -1,17 +1,4 @@
 #!/usr/bin/env python
-
-
-
-from argparse import ArgumentParser
-
-from accelerate.commands.config import get_config_parser
-from accelerate.commands.env import env_command_parser
-from accelerate.commands.estimate import estimate_command_parser
-from accelerate.commands.launch import launch_command_parser
-from accelerate.commands.test import test_command_parser
-from accelerate.commands.tpu import tpu_command_parser
-
-
 def main():
     parser = ArgumentParser("Accelerate CLI tool", usage="accelerate <command> [<args>]", allow_abbrev=False)
     subparsers = parser.add_subparsers(help="accelerate command helpers")

src/commands/config/__init__.py

@@ -1,40 +0,0 @@
-#!/usr/bin/env python
-
-
-
-import argparse
-
-from .config import config_command_parser
-from .config_args import default_config_file, load_config_from_file  # noqa: F401
-from .default import default_command_parser
-from .update import update_command_parser
-
-
-def get_config_parser(subparsers=None):
-    parent_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)
-    # The main config parser
-    config_parser = config_command_parser(subparsers)
-    # The subparser to add commands to
-    subcommands = config_parser.add_subparsers(title="subcommands", dest="subcommand")
-
-    # Then add other parsers with the parent parser
-    default_command_parser(subcommands, parents=[parent_parser])
-    update_command_parser(subcommands, parents=[parent_parser])
-
-    return config_parser
-
-
-def main():
-    config_parser = get_config_parser()
-    args = config_parser.parse_args()
-
-    if not hasattr(args, "func"):
-        config_parser.print_help()
-        exit(1)
-
-    # Run
-    args.func(args)
-
-
-if __name__ == "__main__":
-    main()

src/commands/config/cluster.py

@@ -1,38 +1,4 @@
 #!/usr/bin/env python
-
-
-
-import os
-
-from ...utils import (
-    ComputeEnvironment,
-    DistributedType,
-    is_deepspeed_available,
-    is_mps_available,
-    is_npu_available,
-    is_transformers_available,
-    is_xpu_available,
-)
-from ...utils.constants import (
-    DEEPSPEED_MULTINODE_LAUNCHERS,
-    FSDP_AUTO_WRAP_POLICY,
-    FSDP_BACKWARD_PREFETCH,
-    FSDP_SHARDING_STRATEGY,
-    FSDP_STATE_DICT_TYPE,
-    TORCH_DYNAMO_MODES,
-)
-from .config_args import ClusterConfig
-from .config_utils import (
-    DYNAMO_BACKENDS,
-    _ask_field,
-    _ask_options,
-    _convert_distributed_mode,
-    _convert_dynamo_backend,
-    _convert_mixed_precision,
-    _convert_yes_no_to_bool,
-)
-
-
 def get_cluster_input():
     distributed_type = _ask_options(
         "Which type of machine are you using?",

src/commands/config/config.py

@@ -1,18 +1,4 @@
 #!/usr/bin/env python
-
-
-
-import argparse
-import os
-
-from accelerate.utils import ComputeEnvironment
-
-from .cluster import get_cluster_input
-from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file  # noqa: F401
-from .config_utils import _ask_field, _ask_options, _convert_compute_environment  # noqa: F401
-from .sagemaker import get_sagemaker_input
-
-
 description = "Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine"
 
 

src/commands/config/config_args.py

@@ -1,19 +1,4 @@
 #!/usr/bin/env python
-
-
-
-import json
-import os
-from dataclasses import dataclass
-from enum import Enum
-from typing import List, Optional, Union
-
-import yaml
-
-from ...utils import ComputeEnvironment, DistributedType, SageMakerDistributedType
-from ...utils.constants import SAGEMAKER_PYTHON_VERSION, SAGEMAKER_PYTORCH_VERSION, SAGEMAKER_TRANSFORMERS_VERSION
-
-
 hf_cache_home = os.path.expanduser(
     os.getenv("HF_HOME", os.path.join(os.getenv("XDG_CACHE_HOME", "~/.cache"), "huggingface"))
 )

src/commands/config/config_utils.py

@@ -1,19 +1,4 @@
 #!/usr/bin/env python
-
-
-
-import argparse
-
-from ...utils.dataclasses import (
-    ComputeEnvironment,
-    DistributedType,
-    DynamoBackend,
-    PrecisionType,
-    SageMakerDistributedType,
-)
-from ..menu import BulletMenu
-
-
 DYNAMO_BACKENDS = [
     "EAGER",
     "AOT_EAGER",

src/commands/config/default.py

@@ -1,16 +1,4 @@
 #!/usr/bin/env python
-
-
-
-from pathlib import Path
-
-import torch
-
-from ...utils import is_npu_available, is_xpu_available
-from .config_args import ClusterConfig, default_json_config_file
-from .config_utils import SubcommandHelpFormatter
-
-
 description = "Create a default config file for Accelerate with only a few flags set."
 
 

src/commands/config/sagemaker.py

@@ -1,28 +1,4 @@
 #!/usr/bin/env python
-
-
-import json
-import os
-
-from ...utils.constants import SAGEMAKER_PARALLEL_EC2_INSTANCES, TORCH_DYNAMO_MODES
-from ...utils.dataclasses import ComputeEnvironment, SageMakerDistributedType
-from ...utils.imports import is_boto3_available
-from .config_args import SageMakerConfig
-from .config_utils import (
-    DYNAMO_BACKENDS,
-    _ask_field,
-    _ask_options,
-    _convert_dynamo_backend,
-    _convert_mixed_precision,
-    _convert_sagemaker_distributed_mode,
-    _convert_yes_no_to_bool,
-)
-
-
-if is_boto3_available():
-    import boto3  # noqa: F401
-
-
 def _create_iam_role_for_sagemaker(role_name):
     iam_client = boto3.client("iam")
 

src/commands/config/update.py

@@ -1,13 +1,4 @@
 #!/usr/bin/env python
-
-
-
-from pathlib import Path
-
-from .config_args import default_config_file, load_config_from_file
-from .config_utils import SubcommandHelpFormatter
-
-
 description = "Update an existing config file with the latest defaults while maintaining the old configuration."
 
 

src/commands/env.py

@@ -1,21 +1,4 @@
 #!/usr/bin/env python
-
-
-
-import argparse
-import os
-import platform
-
-import numpy as np
-import psutil
-import torch
-
-from accelerate import __version__ as version
-from accelerate.commands.config import default_config_file, load_config_from_file
-
-from ..utils import is_npu_available, is_xpu_available
-
-
 def env_command_parser(subparsers=None):
     if subparsers is not None:
         parser = subparsers.add_parser("env")

src/commands/estimate.py

@@ -1,28 +1,4 @@
 #!/usr/bin/env python
-
-
-import argparse
-
-from huggingface_hub import model_info
-from huggingface_hub.utils import GatedRepoError, RepositoryNotFoundError
-
-from accelerate import init_empty_weights
-from accelerate.utils import (
-    calculate_maximum_sizes,
-    convert_bytes,
-    is_timm_available,
-    is_transformers_available,
-)
-
-
-if is_transformers_available():
-    import transformers
-    from transformers import AutoConfig, AutoModel
-
-if is_timm_available():
-    import timm
-
-
 def verify_on_hub(repo: str, token: str = None):
     "Verifies that the model is on the hub and returns the model info."
     try:

src/commands/launch.py

@@ -1,54 +1,4 @@
 #!/usr/bin/env python
-
-
-
-import argparse
-import importlib
-import logging
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-import psutil
-import torch
-
-from accelerate.commands.config import default_config_file, load_config_from_file
-from accelerate.commands.config.config_args import SageMakerConfig
-from accelerate.commands.config.config_utils import DYNAMO_BACKENDS
-from accelerate.state import get_int_from_env
-from accelerate.utils import (
-    ComputeEnvironment,
-    DistributedType,
-    PrepareForLaunch,
-    _filter_args,
-    check_cuda_p2p_ib_support,
-    is_bf16_available,
-    is_deepspeed_available,
-    is_npu_available,
-    is_rich_available,
-    is_sagemaker_available,
-    is_torch_version,
-    is_tpu_available,
-    is_xpu_available,
-    patch_environment,
-    prepare_deepspeed_cmd_env,
-    prepare_multi_gpu_env,
-    prepare_sagemager_args_inputs,
-    prepare_simple_launcher_cmd_env,
-    prepare_tpu,
-)
-from accelerate.utils.constants import DEEPSPEED_MULTINODE_LAUNCHERS, TORCH_DYNAMO_MODES
-
-
-if is_rich_available():
-    from rich import get_console
-    from rich.logging import RichHandler
-
-    FORMAT = "%(message)s"
-    logging.basicConfig(format=FORMAT, datefmt="[%X]", handlers=[RichHandler()])
-
-
 logger = logging.getLogger(__name__)
 
 options_to_group = {

src/commands/menu/__init__.py

@@ -1 +0,0 @@
-from .selection_menu import BulletMenu

src/commands/menu/cursor.py

@@ -1,53 +0,0 @@
-
-
-"""
-A utility for showing and hiding the terminal cursor on Windows and Linux, based on https://github.com/bchao1/bullet
-"""
-
-import os
-import sys
-from contextlib import contextmanager
-
-
-# Windows only
-if os.name == "nt":
-    import ctypes
-    import msvcrt  # noqa
-
-    class CursorInfo(ctypes.Structure):
-        # _fields is a specific attr expected by ctypes
-        _fields_ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
-
-
-def hide_cursor():
-    if os.name == "nt":
-        ci = CursorInfo()
-        handle = ctypes.windll.kernel32.GetStdHandle(-11)
-        ctypes.windll.kernel32.GetConsoleCursorInfo(handle, ctypes.byref(ci))
-        ci.visible = False
-        ctypes.windll.kernel32.SetConsoleCursorInfo(handle, ctypes.byref(ci))
-    elif os.name == "posix":
-        sys.stdout.write("\033[?25l")
-        sys.stdout.flush()
-
-
-def show_cursor():
-    if os.name == "nt":
-        ci = CursorInfo()
-        handle = ctypes.windll.kernel32.GetStdHandle(-11)
-        ctypes.windll.kernel32.GetConsoleCursorInfo(handle, ctypes.byref(ci))
-        ci.visible = True
-        ctypes.windll.kernel32.SetConsoleCursorInfo(handle, ctypes.byref(ci))
-    elif os.name == "posix":
-        sys.stdout.write("\033[?25h")
-        sys.stdout.flush()
-
-
-@contextmanager
-def hide():
-    "Context manager to hide the terminal cursor"
-    try:
-        hide_cursor()
-        yield
-    finally:
-        show_cursor()

src/commands/menu/helpers.py

@@ -1,47 +0,0 @@
-
-
-"""
-A variety of helper functions and constants when dealing with terminal menu choices, based on
-https://github.com/bchao1/bullet
-"""
-
-import enum
-import shutil
-import sys
-
-
-TERMINAL_WIDTH, _ = shutil.get_terminal_size()
-
-CURSOR_TO_CHAR = {"UP": "A", "DOWN": "B", "RIGHT": "C", "LEFT": "D"}
-
-
-class Direction(enum.Enum):
-    UP = 0
-    DOWN = 1
-
-
-def forceWrite(content, end=""):
-    sys.stdout.write(str(content) + end)
-    sys.stdout.flush()
-
-
-def writeColor(content, color, end=""):
-    forceWrite(f"\u001b[{color}m{content}\u001b[0m", end)
-
-
-def reset_cursor():
-    forceWrite("\r")
-
-
-def move_cursor(num_lines: int, direction: str):
-    forceWrite(f"\033[{num_lines}{CURSOR_TO_CHAR[direction.upper()]}")
-
-
-def clear_line():
-    forceWrite(" " * TERMINAL_WIDTH)
-    reset_cursor()
-
-
-def linebreak():
-    reset_cursor()
-    forceWrite("-" * TERMINAL_WIDTH)

src/commands/menu/input.py

@@ -1,74 +0,0 @@
-
-
-"""
-This file contains utilities for handling input from the user and registering specific keys to specific functions,
-based on https://github.com/bchao1/bullet
-"""
-
-from typing import List
-
-from .keymap import KEYMAP, get_character
-
-
-def mark(key: str):
-    """
-    Mark the function with the key code so it can be handled in the register
-    """
-
-    def decorator(func):
-        handle = getattr(func, "handle_key", [])
-        handle += [key]
-        setattr(func, "handle_key", handle)
-        return func
-
-    return decorator
-
-
-def mark_multiple(*keys: List[str]):
-    """
-    Mark the function with the key codes so it can be handled in the register
-    """
-
-    def decorator(func):
-        handle = getattr(func, "handle_key", [])
-        handle += keys
-        setattr(func, "handle_key", handle)
-        return func
-
-    return decorator
-
-
-class KeyHandler(type):
-    """
-    Metaclass that adds the key handlers to the class
-    """
-
-    def __new__(cls, name, bases, attrs):
-        new_cls = super().__new__(cls, name, bases, attrs)
-        if not hasattr(new_cls, "key_handler"):
-            setattr(new_cls, "key_handler", {})
-        setattr(new_cls, "handle_input", KeyHandler.handle_input)
-
-        for value in attrs.values():
-            handled_keys = getattr(value, "handle_key", [])
-            for key in handled_keys:
-                new_cls.key_handler[key] = value
-        return new_cls
-
-    @staticmethod
-    def handle_input(cls):
-        "Finds and returns the selected character if it exists in the handler"
-        char = get_character()
-        if char != KEYMAP["undefined"]:
-            char = ord(char)
-        handler = cls.key_handler.get(char)
-        if handler:
-            cls.current_selection = char
-            return handler(cls)
-        else:
-            return None
-
-
-def register(cls):
-    """Adds KeyHandler metaclass to the class"""
-    return KeyHandler(cls.__name__, cls.__bases__, cls.__dict__.copy())

src/commands/menu/keymap.py

@@ -1,122 +0,0 @@
-
-
-"""
-Utilities relating to parsing raw characters from the keyboard, based on https://github.com/bchao1/bullet
-"""
-
-
-import os
-import string
-import sys
-
-
-ARROW_KEY_FLAG = 1 << 8
-
-KEYMAP = {
-    "tab": ord("\t"),
-    "newline": ord("\r"),
-    "esc": 27,
-    "up": 65 + ARROW_KEY_FLAG,
-    "down": 66 + ARROW_KEY_FLAG,
-    "right": 67 + ARROW_KEY_FLAG,
-    "left": 68 + ARROW_KEY_FLAG,
-    "mod_int": 91,
-    "undefined": sys.maxsize,
-    "interrupt": 3,
-    "insert": 50,
-    "delete": 51,
-    "pg_up": 53,
-    "pg_down": 54,
-}
-
-KEYMAP["arrow_begin"] = KEYMAP["up"]
-KEYMAP["arrow_end"] = KEYMAP["left"]
-
-if sys.platform == "win32":
-    WIN_CH_BUFFER = []
-    WIN_KEYMAP = {
-        b"\xe0H": KEYMAP["up"] - ARROW_KEY_FLAG,
-        b"\x00H": KEYMAP["up"] - ARROW_KEY_FLAG,
-        b"\xe0P": KEYMAP["down"] - ARROW_KEY_FLAG,
-        b"\x00P": KEYMAP["down"] - ARROW_KEY_FLAG,
-        b"\xe0M": KEYMAP["right"] - ARROW_KEY_FLAG,
-        b"\x00M": KEYMAP["right"] - ARROW_KEY_FLAG,
-        b"\xe0K": KEYMAP["left"] - ARROW_KEY_FLAG,
-        b"\x00K": KEYMAP["left"] - ARROW_KEY_FLAG,
-    }
-
-for i in range(10):
-    KEYMAP[str(i)] = ord(str(i))
-
-
-def get_raw_chars():
-    "Gets raw characters from inputs"
-    if os.name == "nt":
-        import msvcrt
-
-        encoding = "mbcs"
-        # Flush the keyboard buffer
-        while msvcrt.kbhit():
-            msvcrt.getch()
-        if len(WIN_CH_BUFFER) == 0:
-            # Read the keystroke
-            ch = msvcrt.getch()
-
-            # If it is a prefix char, get second part
-            if ch in (b"\x00", b"\xe0"):
-                ch2 = ch + msvcrt.getch()
-                # Translate actual Win chars to bullet char types
-                try:
-                    chx = chr(WIN_KEYMAP[ch2])
-                    WIN_CH_BUFFER.append(chr(KEYMAP["mod_int"]))
-                    WIN_CH_BUFFER.append(chx)
-                    if ord(chx) in (
-                        KEYMAP["insert"] - 1 << 9,
-                        KEYMAP["delete"] - 1 << 9,
-                        KEYMAP["pg_up"] - 1 << 9,
-                        KEYMAP["pg_down"] - 1 << 9,
-                    ):
-                        WIN_CH_BUFFER.append(chr(126))
-                    ch = chr(KEYMAP["esc"])
-                except KeyError:
-                    ch = ch2[1]
-            else:
-                ch = ch.decode(encoding)
-        else:
-            ch = WIN_CH_BUFFER.pop(0)
-    elif os.name == "posix":
-        import termios
-        import tty
-
-        fd = sys.stdin.fileno()
-        old_settings = termios.tcgetattr(fd)
-        try:
-            tty.setraw(fd)
-            ch = sys.stdin.read(1)
-        finally:
-            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-    return ch
-
-
-def get_character():
-    "Gets a character from the keyboard and returns the key code"
-    char = get_raw_chars()
-    if ord(char) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
-        return char
-
-    elif ord(char) == KEYMAP["esc"]:
-        combo = get_raw_chars()
-        if ord(combo) == KEYMAP["mod_int"]:
-            key = get_raw_chars()
-            if ord(key) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(key) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
-                return chr(ord(key) + ARROW_KEY_FLAG)
-            else:
-                return KEYMAP["undefined"]
-        else:
-            return get_raw_chars()
-
-    else:
-        if char in string.printable:
-            return char
-        else:
-            return KEYMAP["undefined"]

src/commands/menu/selection_menu.py

@@ -1,131 +0,0 @@
-
-
-"""
-Main driver for the selection menu, based on https://github.com/bchao1/bullet
-"""
-import builtins
-import sys
-
-from ...utils.imports import _is_package_available
-from . import cursor, input
-from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor
-from .keymap import KEYMAP
-
-
-in_colab = False
-try:
-    in_colab = _is_package_available("google.colab")
-except ModuleNotFoundError:
-    pass
-
-
-@input.register
-class BulletMenu:
-    """
-    A CLI menu to select a choice from a list of choices using the keyboard.
-    """
-
-    def __init__(self, prompt: str = None, choices: list = []):
-        self.position = 0
-        self.choices = choices
-        self.prompt = prompt
-        if sys.platform == "win32":
-            self.arrow_char = "*"
-        else:
-            self.arrow_char = "➔ "
-
-    def write_choice(self, index, end: str = ""):
-        if sys.platform != "win32":
-            writeColor(self.choices[index], 32, end)
-        else:
-            forceWrite(self.choices[index], end)
-
-    def print_choice(self, index: int):
-        "Prints the choice at the given index"
-        if index == self.position:
-            forceWrite(f" {self.arrow_char} ")
-            self.write_choice(index)
-        else:
-            forceWrite(f"    {self.choices[index]}")
-        reset_cursor()
-
-    def move_direction(self, direction: Direction, num_spaces: int = 1):
-        "Should not be directly called, used to move a direction of either up or down"
-        old_position = self.position
-        if direction == Direction.DOWN:
-            if self.position + 1 >= len(self.choices):
-                return
-            self.position += num_spaces
-        else:
-            if self.position - 1 < 0:
-                return
-            self.position -= num_spaces
-        clear_line()
-        self.print_choice(old_position)
-        move_cursor(num_spaces, direction.name)
-        self.print_choice(self.position)
-
-    @input.mark(KEYMAP["up"])
-    def move_up(self):
-        self.move_direction(Direction.UP)
-
-    @input.mark(KEYMAP["down"])
-    def move_down(self):
-        self.move_direction(Direction.DOWN)
-
-    @input.mark(KEYMAP["newline"])
-    def select(self):
-        move_cursor(len(self.choices) - self.position, "DOWN")
-        return self.position
-
-    @input.mark(KEYMAP["interrupt"])
-    def interrupt(self):
-        move_cursor(len(self.choices) - self.position, "DOWN")
-        raise KeyboardInterrupt
-
-    @input.mark_multiple(*[KEYMAP[str(number)] for number in range(10)])
-    def select_row(self):
-        index = int(chr(self.current_selection))
-        movement = index - self.position
-        if index == self.position:
-            return
-        if index < len(self.choices):
-            if self.position > index:
-                self.move_direction(Direction.UP, -movement)
-            elif self.position < index:
-                self.move_direction(Direction.DOWN, movement)
-            else:
-                return
-        else:
-            return
-
-    def run(self, default_choice: int = 0):
-        "Start the menu and return the selected choice"
-        if self.prompt:
-            linebreak()
-            forceWrite(self.prompt, "\n")
-            if in_colab:
-                forceWrite("Please input a choice index (starting from 0), and press enter", "\n")
-            else:
-                forceWrite("Please select a choice using the arrow or number keys, and selecting with enter", "\n")
-        self.position = default_choice
-        for i in range(len(self.choices)):
-            self.print_choice(i)
-            forceWrite("\n")
-        move_cursor(len(self.choices) - self.position, "UP")
-        with cursor.hide():
-            while True:
-                if in_colab:
-                    try:
-                        choice = int(builtins.input())
-                    except ValueError:
-                        choice = default_choice
-                else:
-                    choice = self.handle_input()
-                if choice is not None:
-                    reset_cursor()
-                    for _ in range(len(self.choices) + 1):
-                        move_cursor(1, "UP")
-                        clear_line()
-                    self.write_choice(choice, "\n")
-                    return choice

src/commands/test.py

@@ -1,13 +1,4 @@
 #!/usr/bin/env python
-
-
-
-import argparse
-import os
-
-from accelerate.test_utils import execute_subprocess_async
-
-
 def test_command_parser(subparsers=None):
     if subparsers is not None:
         parser = subparsers.add_parser("test")

src/commands/tpu.py

@@ -1,16 +1,4 @@
 #!/usr/bin/env python
-
-
-
-import argparse
-import os
-import subprocess
-
-from packaging.version import Version, parse
-
-from accelerate.commands.config.config_args import default_config_file, load_config_from_file
-
-
 _description = "Run commands across TPU VMs for initial setup before running `accelerate launch`."
 
 

src/data_loader.py

@@ -1,29 +1,3 @@
-
-
-import math
-from contextlib import suppress
-from typing import Callable, List, Optional, Union
-
-import torch
-from torch.utils.data import BatchSampler, DataLoader, IterableDataset, RandomSampler
-
-from .logging import get_logger
-from .state import AcceleratorState, DistributedType, GradientState, is_tpu_available
-from .utils import (
-    RNGType,
-    broadcast,
-    broadcast_object_list,
-    concatenate,
-    find_batch_size,
-    get_data_structure,
-    initialize_tensors,
-    is_torch_version,
-    send_to_device,
-    slice_tensors,
-    synchronize_rng_states,
-)
-
-
 logger = get_logger(__name__)
 
 # kwargs of the DataLoader in min version 1.4.0.

src/hooks.py

@@ -1,22 +1,3 @@
-
-
-import functools
-from typing import Dict, List, Mapping, Optional, Union
-
-import torch
-import torch.nn as nn
-
-from .state import PartialState
-from .utils import (
-    PrefixedDataset,
-    find_device,
-    named_module_tensors,
-    send_to_device,
-    set_module_tensor_to_device,
-)
-from .utils.modeling import get_non_persistent_buffers
-
-
 class ModelHook:
     """
     A hook that contains callbacks to be executed just before and after the forward method of a model. The difference

src/launchers.py

@@ -1,22 +1,3 @@
-
-
-import os
-import sys
-import tempfile
-
-import torch
-
-from .state import AcceleratorState, PartialState
-from .utils import (
-    PrecisionType,
-    PrepareForLaunch,
-    are_libraries_initialized,
-    check_cuda_p2p_ib_support,
-    is_mps_available,
-    patch_environment,
-)
-
-
 def test_launch():
     "Verify a `PartialState` can be initialized."
     _ = PartialState()

src/local_sgd.py

@@ -1,9 +1,3 @@
-
-import torch
-
-from accelerate import Accelerator, DistributedType
-
-
 class LocalSGD:
     """
     A helper class to support local SGD on top of Accelerator. It simply runs a given number of updates independently

src/logging.py

@@ -1,12 +1,3 @@
-
-
-import functools
-import logging
-import os
-
-from .state import PartialState
-
-
 class MultiProcessAdapter(logging.LoggerAdapter):
     """
     An adapter to assist with logging in multiprocess.

src/memory_utils.py

@@ -1,10 +0,0 @@
-
-
-import warnings
-
-
-warnings.warn(
-    "memory_utils has been reorganized to utils.memory. Import `find_executable_batchsize` from the main `__init__`: "
-    "`from accelerate import find_executable_batch_size` to avoid this warning.",
-    FutureWarning,
-)

src/optimizer.py

@@ -1,18 +1,3 @@
-
-
-import inspect
-import warnings
-
-import torch
-
-from .state import AcceleratorState, GradientState
-from .utils import DistributedType, honor_type, is_tpu_available
-
-
-if is_tpu_available(check_device=False):
-    import torch_xla.core.xla_model as xm
-
-
 def move_to_device(state, device):
     if isinstance(state, (list, tuple)):
         return honor_type(state, (move_to_device(t, device) for t in state))

src/scheduler.py

@@ -2,14 +2,6 @@
 
 # We ignore warnings about stepping the scheduler since we step it ourselves during gradient accumulation
 
-import warnings
-
-from .state import AcceleratorState, GradientState
-
-
-warnings.filterwarnings("ignore", category=UserWarning, module="torch.optim.lr_scheduler")
-
-
 class AcceleratedScheduler:
     """
     A wrapper around a learning rate scheduler that will only step when the optimizer(s) have a training step. Useful

src/state.py

@@ -1,47 +1,3 @@
-
-
-from __future__ import annotations
-
-import logging
-import math
-import os
-import threading
-import warnings
-from contextlib import contextmanager
-from functools import partial
-from typing import Any, Callable, Optional
-
-import torch
-
-from .utils import (
-    DistributedType,
-    DynamoBackend,
-    GradientAccumulationPlugin,
-    check_cuda_p2p_ib_support,
-    check_fp8_capability,
-    get_ccl_version,
-    get_int_from_env,
-    is_ccl_available,
-    is_deepspeed_available,
-    is_fp8_available,
-    is_ipex_available,
-    is_mps_available,
-    is_npu_available,
-    is_tpu_available,
-    is_xpu_available,
-    parse_choice_from_env,
-    parse_flag_from_env,
-)
-from .utils.dataclasses import SageMakerDistributedType
-
-
-if is_tpu_available(check_device=False):
-    import torch_xla.core.xla_model as xm
-
-
-if is_npu_available(check_device=False):
-    import torch_npu  # noqa: F401
-
 logger = logging.getLogger(__name__)
 
 

src/test_utils/examples.py

@@ -1,134 +0,0 @@
-#!/usr/bin/env python
-
-
-"""
-A collection of utilities for comparing `examples/complete_*_example.py` scripts with the capabilities inside of each
-`examples/by_feature` example. `compare_against_test` is the main function that should be used when testing, while the
-others are used to either get the code that matters, or to preprocess them (such as stripping comments)
-"""
-
-import os
-from typing import List
-
-
-def get_function_contents_by_name(lines: List[str], name: str):
-    """
-    Extracts a function from `lines` of segmented source code with the name `name`.
-
-    Args:
-        lines (`List[str]`):
-            Source code of a script seperated by line.
-        name (`str`):
-            The name of the function to extract. Should be either `training_function` or `main`
-    """
-    if name != "training_function" and name != "main":
-        raise ValueError(f"Incorrect function name passed: {name}, choose either 'main' or 'training_function'")
-    good_lines, found_start = [], False
-    for line in lines:
-        if not found_start and f"def {name}" in line:
-            found_start = True
-            good_lines.append(line)
-            continue
-        if found_start:
-            if name == "training_function" and "def main" in line:
-                return good_lines
-            if name == "main" and "if __name__" in line:
-                return good_lines
-            good_lines.append(line)
-
-
-def clean_lines(lines: List[str]):
-    """
-    Filters `lines` and removes any entries that start with a comment ('#') or is just a newline ('\n')
-
-    Args:
-        lines (`List[str]`):
-            Source code of a script seperated by line.
-    """
-    return [line for line in lines if not line.lstrip().startswith("#") and line != "\n"]
-
-
-def compare_against_test(base_filename: str, feature_filename: str, parser_only: bool, secondary_filename: str = None):
-    """
-    Tests whether the additional code inside of `feature_filename` was implemented in `base_filename`. This should be
-    used when testing to see if `complete_*_.py` examples have all of the implementations from each of the
-    `examples/by_feature/*` scripts.
-
-    It utilizes `nlp_example.py` to extract out all of the repeated training code, so that only the new additional code
-    is examined and checked. If something *other* than `nlp_example.py` should be used, such as `cv_example.py` for the
-    `complete_cv_example.py` script, it should be passed in for the `secondary_filename` parameter.
-
-    Args:
-        base_filename (`str` or `os.PathLike`):
-            The filepath of a single "complete" example script to test, such as `examples/complete_cv_example.py`
-        feature_filename (`str` or `os.PathLike`):
-            The filepath of a single feature example script. The contents of this script are checked to see if they
-            exist in `base_filename`
-        parser_only (`bool`):
-            Whether to compare only the `main()` sections in both files, or to compare the contents of
-            `training_loop()`
-        secondary_filename (`str`, *optional*):
-            A potential secondary filepath that should be included in the check. This function extracts the base
-            functionalities off of "examples/nlp_example.py", so if `base_filename` is a script other than
-            `complete_nlp_example.py`, the template script should be included here. Such as `examples/cv_example.py`
-    """
-    with open(base_filename, "r") as f:
-        base_file_contents = f.readlines()
-    with open(os.path.abspath(os.path.join("examples", "nlp_example.py")), "r") as f:
-        full_file_contents = f.readlines()
-    with open(feature_filename, "r") as f:
-        feature_file_contents = f.readlines()
-    if secondary_filename is not None:
-        with open(secondary_filename, "r") as f:
-            secondary_file_contents = f.readlines()
-
-    # This is our base, we remove all the code from here in our `full_filename` and `feature_filename` to find the new content
-    if parser_only:
-        base_file_func = clean_lines(get_function_contents_by_name(base_file_contents, "main"))
-        full_file_func = clean_lines(get_function_contents_by_name(full_file_contents, "main"))
-        feature_file_func = clean_lines(get_function_contents_by_name(feature_file_contents, "main"))
-        if secondary_filename is not None:
-            secondary_file_func = clean_lines(get_function_contents_by_name(secondary_file_contents, "main"))
-    else:
-        base_file_func = clean_lines(get_function_contents_by_name(base_file_contents, "training_function"))
-        full_file_func = clean_lines(get_function_contents_by_name(full_file_contents, "training_function"))
-        feature_file_func = clean_lines(get_function_contents_by_name(feature_file_contents, "training_function"))
-        if secondary_filename is not None:
-            secondary_file_func = clean_lines(
-                get_function_contents_by_name(secondary_file_contents, "training_function")
-            )
-
-    _dl_line = "train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\n"
-
-    # Specific code in our script that differs from the full version, aka what is new
-    new_feature_code = []
-    passed_idxs = []  # We keep track of the idxs just in case it's a repeated statement
-    it = iter(feature_file_func)
-    for i in range(len(feature_file_func) - 1):
-        if i not in passed_idxs:
-            line = next(it)
-            if (line not in full_file_func) and (line.lstrip() != _dl_line):
-                if "TESTING_MOCKED_DATALOADERS" not in line:
-                    new_feature_code.append(line)
-                    passed_idxs.append(i)
-                else:
-                    # Skip over the `config['num_epochs'] = 2` statement
-                    _ = next(it)
-
-    # Extract out just the new parts from the full_file_training_func
-    new_full_example_parts = []
-    passed_idxs = []  # We keep track of the idxs just in case it's a repeated statement
-    for i, line in enumerate(base_file_func):
-        if i not in passed_idxs:
-            if (line not in full_file_func) and (line.lstrip() != _dl_line):
-                if "TESTING_MOCKED_DATALOADERS" not in line:
-                    new_full_example_parts.append(line)
-                    passed_idxs.append(i)
-
-    # Finally, get the overall diff
-    diff_from_example = [line for line in new_feature_code if line not in new_full_example_parts]
-    if secondary_filename is not None:
-        diff_from_two = [line for line in full_file_contents if line not in secondary_file_func]
-        diff_from_example = [line for line in diff_from_example if line not in diff_from_two]
-
-    return diff_from_example

src/test_utils/scripts/external_deps/test_checkpointing.py

@@ -1,257 +0,0 @@
-# coding=utf-8
-
-import argparse
-import json
-import os
-
-import evaluate
-import torch
-from datasets import load_dataset
-from torch.optim import AdamW
-from torch.utils.data import DataLoader
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed
-
-from accelerate import Accelerator, DistributedType
-from accelerate.utils.deepspeed import DummyOptim, DummyScheduler
-
-
-MAX_GPU_BATCH_SIZE = 16
-EVAL_BATCH_SIZE = 32
-
-
-def get_dataloaders(accelerator: Accelerator, batch_size: int = 16, model_name: str = "bert-base-cased"):
-    """
-    Creates a set of `DataLoader`s for the `glue` dataset.
-
-    Args:
-        accelerator (`Accelerator`):
-            An `Accelerator` object
-        batch_size (`int`, *optional*):
-            The batch size for the train and validation DataLoaders.
-        model_name (`str`, *optional*):
-    """
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    datasets = load_dataset("glue", "mrpc")
-
-    def tokenize_function(examples):
-        # max_length=None => use the model max length (it's actually the default)
-        outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
-        return outputs
-
-    # Apply the method we just defined to all the examples in all the splits of the dataset
-    tokenized_datasets = datasets.map(
-        tokenize_function, batched=True, remove_columns=["idx", "sentence1", "sentence2"], load_from_cache_file=False
-    )
-
-    # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
-    # transformers library
-    tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
-
-    def collate_fn(examples):
-        # On TPU it's best to pad everything to the same length or training will be very slow.
-        if accelerator.distributed_type == DistributedType.TPU:
-            return tokenizer.pad(examples, padding="max_length", max_length=128, return_tensors="pt")
-        return tokenizer.pad(examples, padding="longest", return_tensors="pt")
-
-    # Instantiate dataloaders.
-    train_dataloader = DataLoader(
-        tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size
-    )
-    eval_dataloader = DataLoader(
-        tokenized_datasets["validation"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE
-    )
-
-    return train_dataloader, eval_dataloader
-
-
-def evaluation_loop(accelerator, model, eval_dataloader, metric):
-    model.eval()
-    samples_seen = 0
-    for step, batch in enumerate(eval_dataloader):
-        # We could avoid this line since we set the accelerator with `device_placement=True`.
-        batch.to(accelerator.device)
-        with torch.no_grad():
-            outputs = model(**batch)
-        predictions = outputs.logits.argmax(dim=-1)
-        # It is slightly faster to call this once, than multiple times
-        predictions, references = accelerator.gather(
-            (predictions, batch["labels"])
-        )  # If we are in a multiprocess environment, the last batch has duplicates
-        if accelerator.use_distributed:
-            if step == len(eval_dataloader) - 1:
-                predictions = predictions[: len(eval_dataloader.dataset) - samples_seen]
-                references = references[: len(eval_dataloader.dataset) - samples_seen]
-            else:
-                samples_seen += references.shape[0]
-        metric.add_batch(
-            predictions=predictions,
-            references=references,
-        )
-
-    eval_metric = metric.compute()
-    return eval_metric["accuracy"]
-
-
-def training_function(config, args):
-    # Initialize accelerator
-    accelerator = Accelerator()
-
-    # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
-    lr = config["lr"]
-    num_epochs = int(config["num_epochs"])
-    seed = int(config["seed"])
-    batch_size = int(config["batch_size"])
-    model_name = args.model_name_or_path
-
-    set_seed(seed)
-    train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size, model_name)
-
-    # Instantiate the model (we build the model here so that the seed also control new weights initialization)
-    model = AutoModelForSequenceClassification.from_pretrained(model_name, return_dict=True)
-
-    # Instantiate optimizer
-    optimizer_cls = (
-        AdamW
-        if accelerator.state.deepspeed_plugin is None
-        or "optimizer" not in accelerator.state.deepspeed_plugin.deepspeed_config
-        else DummyOptim
-    )
-    optimizer = optimizer_cls(params=model.parameters(), lr=lr)
-
-    if accelerator.state.deepspeed_plugin is not None:
-        gradient_accumulation_steps = accelerator.state.deepspeed_plugin.deepspeed_config[
-            "gradient_accumulation_steps"
-        ]
-    else:
-        gradient_accumulation_steps = 1
-    max_training_steps = (len(train_dataloader) * num_epochs) // gradient_accumulation_steps
-
-    # Instantiate scheduler
-    if (
-        accelerator.state.deepspeed_plugin is None
-        or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
-    ):
-        lr_scheduler = get_linear_schedule_with_warmup(
-            optimizer=optimizer,
-            num_warmup_steps=0,
-            num_training_steps=max_training_steps,
-        )
-    else:
-        lr_scheduler = DummyScheduler(optimizer, total_num_steps=max_training_steps, warmup_num_steps=0)
-
-    # Prepare everything
-    # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
-    # prepare method.
-    model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(
-        model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
-    )
-
-    # We need to keep track of how many total steps we have iterated over
-    overall_step = 0
-    # We also need to keep track of the stating epoch so files are named properly
-    starting_epoch = 0
-    metric = evaluate.load("glue", "mrpc")
-    ending_epoch = num_epochs
-
-    if args.partial_train_epoch is not None:
-        ending_epoch = args.partial_train_epoch
-
-    if args.resume_from_checkpoint:
-        accelerator.load_state(args.resume_from_checkpoint)
-        epoch_string = args.resume_from_checkpoint.split("epoch_")[1]
-        state_epoch_num = ""
-        for char in epoch_string:
-            if char.isdigit():
-                state_epoch_num += char
-            else:
-                break
-        starting_epoch = int(state_epoch_num) + 1
-        accuracy = evaluation_loop(accelerator, model, eval_dataloader, metric)
-        accelerator.print("resumed checkpoint performance:", accuracy)
-        accelerator.print("resumed checkpoint's scheduler's lr:", lr_scheduler.get_lr()[0])
-        accelerator.print("resumed optimizers's lr:", optimizer.param_groups[0]["lr"])
-        with open(os.path.join(args.output_dir, f"state_{starting_epoch-1}.json"), "r") as f:
-            resumed_state = json.load(f)
-            assert resumed_state["accuracy"] == accuracy, "Accuracy mismatch, loading from checkpoint failed"
-            assert (
-                resumed_state["lr"] == lr_scheduler.get_lr()[0]
-            ), "Scheduler learning rate mismatch, loading from checkpoint failed"
-            assert (
-                resumed_state["optimizer_lr"] == optimizer.param_groups[0]["lr"]
-            ), "Optimizer learning rate mismatch, loading from checkpoint failed"
-            assert resumed_state["epoch"] == starting_epoch - 1, "Epoch mismatch, loading from checkpoint failed"
-            return
-
-    # Now we train the model
-    state = {}
-    for epoch in range(starting_epoch, ending_epoch):
-        model.train()
-        for step, batch in enumerate(train_dataloader):
-            outputs = model(**batch)
-            loss = outputs.loss
-            loss = loss / gradient_accumulation_steps
-            accelerator.backward(loss)
-            if step % gradient_accumulation_steps == 0:
-                optimizer.step()
-                lr_scheduler.step()
-                optimizer.zero_grad()
-
-            overall_step += 1
-        output_dir = f"epoch_{epoch}"
-        output_dir = os.path.join(args.output_dir, output_dir)
-        accelerator.save_state(output_dir)
-        accuracy = evaluation_loop(accelerator, model, eval_dataloader, metric)
-        state["accuracy"] = accuracy
-        state["lr"] = lr_scheduler.get_lr()[0]
-        state["optimizer_lr"] = optimizer.param_groups[0]["lr"]
-        state["epoch"] = epoch
-        state["step"] = overall_step
-        accelerator.print(f"epoch {epoch}:", state)
-
-        accelerator.wait_for_everyone()
-        if accelerator.is_main_process:
-            with open(os.path.join(args.output_dir, f"state_{epoch}.json"), "w") as f:
-                json.dump(state, f)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Simple example of training script tracking peak GPU memory usage.")
-    parser.add_argument(
-        "--model_name_or_path",
-        type=str,
-        default="bert-base-cased",
-        help="Path to pretrained model or model identifier from huggingface.co/models.",
-        required=False,
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default=".",
-        help="Optional save directory where all checkpoint folders will be stored. Default is the current working directory.",
-    )
-    parser.add_argument(
-        "--resume_from_checkpoint",
-        type=str,
-        default=None,
-        help="If the training should continue from a checkpoint folder.",
-    )
-    parser.add_argument(
-        "--partial_train_epoch",
-        type=int,
-        default=None,
-        help="If passed, the training will stop after this number of epochs.",
-    )
-    parser.add_argument(
-        "--num_epochs",
-        type=int,
-        default=2,
-        help="Number of train epochs.",
-    )
-    args = parser.parse_args()
-    config = {"lr": 2e-5, "num_epochs": args.num_epochs, "seed": 42, "batch_size": 16}
-
-    training_function(config, args)
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/scripts/external_deps/test_metrics.py

@@ -1,280 +0,0 @@
-
-
-import logging
-import math
-import os
-from copy import deepcopy
-
-import datasets
-import evaluate
-import torch
-import transformers
-from datasets import load_dataset
-from torch.utils.data import DataLoader, IterableDataset
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
-
-from accelerate import Accelerator
-from accelerate.data_loader import DataLoaderDispatcher
-from accelerate.test_utils import RegressionDataset, RegressionModel, torch_device
-from accelerate.utils import set_seed
-
-
-os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "true"
-
-
-class ListHandler(logging.Handler):
-    def __init__(self, *args, **kwargs):
-        super(ListHandler, self).__init__(*args, **kwargs)
-        self.logs = []
-
-    def emit(self, record):
-        self.logs.append(record)
-
-
-def get_basic_setup(accelerator, num_samples=82, batch_size=16):
-    "Returns everything needed to perform basic training"
-    set_seed(42)
-    model = RegressionModel()
-    ddp_model = deepcopy(model)
-    dset = RegressionDataset(length=num_samples)
-    dataloader = DataLoader(dset, batch_size=batch_size)
-    model.to(accelerator.device)
-    ddp_model, dataloader = accelerator.prepare(ddp_model, dataloader)
-    return model, ddp_model, dataloader
-
-
-def get_dataloader(accelerator: Accelerator, use_longest=False):
-    tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/mrpc-bert-base-cased")
-    dataset = load_dataset("glue", "mrpc", split="validation")
-
-    def tokenize_function(examples):
-        outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
-        return outputs
-
-    with accelerator.main_process_first():
-        tokenized_datasets = dataset.map(
-            tokenize_function,
-            batched=True,
-            remove_columns=["idx", "sentence1", "sentence2"],
-        )
-
-    tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
-
-    def collate_fn(examples):
-        if use_longest:
-            return tokenizer.pad(examples, padding="longest", return_tensors="pt")
-        return tokenizer.pad(examples, padding="max_length", max_length=128, return_tensors="pt")
-
-    return DataLoader(tokenized_datasets, shuffle=False, collate_fn=collate_fn, batch_size=16)
-
-
-def get_mrpc_setup(dispatch_batches, split_batches):
-    accelerator = Accelerator(dispatch_batches=dispatch_batches, split_batches=split_batches)
-    dataloader = get_dataloader(accelerator, not dispatch_batches)
-    model = AutoModelForSequenceClassification.from_pretrained(
-        "hf-internal-testing/mrpc-bert-base-cased", return_dict=True
-    )
-    ddp_model, ddp_dataloader = accelerator.prepare(model, dataloader)
-    return {
-        "ddp": [ddp_model, ddp_dataloader, torch_device],
-        "no": [model, dataloader, accelerator.device],
-    }, accelerator
-
-
-def generate_predictions(model, dataloader, accelerator):
-    logits_and_targets = []
-    for batch in dataloader:
-        input, target = batch.values()
-        with torch.no_grad():
-            logit = model(input)
-            logit, target = accelerator.gather_for_metrics((logit, target))
-            logits_and_targets.append((logit, target))
-    logits, targs = [], []
-    for logit, targ in logits_and_targets:
-        logits.append(logit)
-        targs.append(targ)
-    logits, targs = torch.cat(logits), torch.cat(targs)
-    return logits, targs
-
-
-def test_torch_metrics(
-    accelerator: Accelerator, num_samples=82, dispatch_batches=False, split_batches=False, batch_size=16
-):
-    model, ddp_model, dataloader = get_basic_setup(accelerator, num_samples, batch_size)
-    logits, targs = generate_predictions(ddp_model, dataloader, accelerator)
-    assert (
-        len(logits) == num_samples
-    ), f"Unexpected number of inputs:\n    Expected: {num_samples}\n    Actual: {len(logits)}"
-
-
-def test_mrpc(dispatch_batches: bool = False, split_batches: bool = False):
-    metric = evaluate.load("glue", "mrpc")
-    setup, accelerator = get_mrpc_setup(dispatch_batches, split_batches)
-    # First do baseline
-    model, dataloader, device = setup["no"]
-    model.to(device)
-    model.eval()
-    for batch in dataloader:
-        batch.to(device)
-        with torch.inference_mode():
-            outputs = model(**batch)
-        preds = outputs.logits.argmax(dim=-1)
-        metric.add_batch(predictions=preds, references=batch["labels"])
-    baseline = metric.compute()
-
-    # Then do distributed
-    model, dataloader, device = setup["ddp"]
-    model.eval()
-    for batch in dataloader:
-        with torch.inference_mode():
-            outputs = model(**batch)
-        preds = outputs.logits.argmax(dim=-1)
-        references = batch["labels"]
-        preds, references = accelerator.gather_for_metrics((preds, references))
-        metric.add_batch(predictions=preds, references=references)
-    distributed = metric.compute()
-
-    for key in "accuracy f1".split():
-        assert math.isclose(
-            baseline[key], distributed[key]
-        ), f"Baseline and Distributed are not the same for key {key}:\n\tBaseline: {baseline[key]}\n\tDistributed: {distributed[key]}\n"
-
-
-def test_gather_for_metrics_with_non_tensor_objects_iterable_dataset():
-    class DummyIterableDataset(IterableDataset):
-        def __init__(self, data):
-            self.data = data
-
-        def __len__(self):
-            return len(self.data)
-
-        def __iter__(self):
-            for element in self.data:
-                yield element
-
-    iterable_dataset = DummyIterableDataset([n for n in range(30)])
-    dataloader = DataLoader(iterable_dataset, batch_size=4)
-    accelerator = Accelerator()
-    prepared_dataloader = accelerator.prepare(dataloader)
-
-    if accelerator.is_main_process:
-        logger = logging.root.manager.loggerDict["accelerate.accelerator"]
-        list_handler = ListHandler()
-        logger.addHandler(list_handler)
-
-    batches_for_metrics = []
-    for batch in prepared_dataloader:
-        batches_for_metrics.append(accelerator.gather_for_metrics(batch))
-
-    assert torch.cat(batches_for_metrics).size(0) == 30
-
-    if accelerator.is_main_process:
-        assert len(list_handler.logs) == 0
-        logger.removeHandler(list_handler)
-
-
-def test_gather_for_metrics_with_iterable_dataset():
-    class DummyIterableDataset(IterableDataset):
-        def __init__(self, data):
-            self.data = data
-
-        def __len__(self):
-            return len(self.data)
-
-        def __iter__(self):
-            for element in self.data:
-                yield element
-
-    iterable_dataset = DummyIterableDataset(torch.as_tensor(range(30)))
-    dataloader = DataLoader(iterable_dataset, batch_size=4)
-
-    accelerator = Accelerator()
-    prepared_dataloader = accelerator.prepare(dataloader)
-
-    assert isinstance(prepared_dataloader, DataLoaderDispatcher)
-
-    if accelerator.is_main_process:
-        logger = logging.root.manager.loggerDict["accelerate.accelerator"]
-        list_handler = ListHandler()
-        logger.addHandler(list_handler)
-
-    batches_for_metrics = []
-    for batch in prepared_dataloader:
-        batches_for_metrics.append(accelerator.gather_for_metrics(batch))
-
-    assert torch.cat(batches_for_metrics).size(0) == 30
-
-    if accelerator.is_main_process:
-        assert len(list_handler.logs) == 0
-
-        logger.removeHandler(list_handler)
-
-
-def test_gather_for_metrics_drop_last():
-    accelerator = Accelerator()
-    per_device_batch_size = 5
-    num_items = (10 * accelerator.num_processes) + 1
-    dataloader = DataLoader(range(num_items), batch_size=per_device_batch_size, drop_last=True)
-    dataloader = accelerator.prepare(dataloader)
-
-    iterator = iter(dataloader)
-    next(iterator)  # Skip first batch tensor([0, 1, 2, 3, 4], device='cuda:0')
-    batch = next(iterator)
-    gathered_items = accelerator.gather_for_metrics(batch)
-
-    # Should return a full set of complete batches from each GPU
-    num_expected_items = per_device_batch_size * accelerator.num_processes
-    assert gathered_items.size(0) == (
-        num_expected_items
-    ), f"Expected number of items: {num_expected_items}, Actual: {gathered_items.size(0)}"
-
-
-def main():
-    accelerator = Accelerator(split_batches=False, dispatch_batches=False)
-    if accelerator.is_local_main_process:
-        datasets.utils.logging.set_verbosity_warning()
-        transformers.utils.logging.set_verbosity_warning()
-    else:
-        datasets.utils.logging.set_verbosity_error()
-        transformers.utils.logging.set_verbosity_error()
-    # These are a bit slower so they should only be ran on the GPU or TPU
-    if accelerator.device.type != "cpu":
-        if accelerator.is_local_main_process:
-            print("**Testing gather_for_metrics**")
-        for split_batches in [True, False]:
-            for dispatch_batches in [True, False]:
-                if accelerator.is_local_main_process:
-                    print(f"With: `split_batches={split_batches}`, `dispatch_batches={dispatch_batches}`")
-                test_mrpc(dispatch_batches, split_batches)
-                accelerator.state._reset_state()
-        print("test_gather_for_metrics_with_iterable_dataset")
-        test_gather_for_metrics_with_iterable_dataset()
-        print("test gather_for_metrics_with_non_tensor_objects_iterable_dataset")
-        test_gather_for_metrics_with_non_tensor_objects_iterable_dataset()
-    if accelerator.is_local_main_process:
-        print("**Test torch metrics**")
-    for split_batches in [True, False]:
-        for dispatch_batches in [True, False]:
-            accelerator = Accelerator(split_batches=split_batches, dispatch_batches=dispatch_batches)
-            if accelerator.is_local_main_process:
-                print(f"With: `split_batches={split_batches}`, `dispatch_batches={dispatch_batches}`, length=99")
-            test_torch_metrics(accelerator, 99)
-            accelerator.state._reset_state()
-    if accelerator.is_local_main_process:
-        print("**Test last batch is not dropped when perfectly divisible**")
-    accelerator = Accelerator()
-    test_torch_metrics(accelerator, 512)
-    accelerator.state._reset_state()
-    if accelerator.is_local_main_process:
-        print("**Test that `drop_last` is taken into account**")
-    test_gather_for_metrics_drop_last()
-    accelerator.state._reset_state()
-
-
-def _mp_fn(index):
-    # For xla_spawn (TPUs)
-    main()
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/scripts/external_deps/test_peak_memory_usage.py

@@ -1,265 +0,0 @@
-# coding=utf-8
-
-import argparse
-import gc
-import json
-import os
-
-import torch
-from datasets import load_dataset
-from torch.optim import AdamW
-from torch.utils.data import DataLoader
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed
-
-from accelerate import Accelerator, DistributedType
-from accelerate.utils import is_npu_available, is_xpu_available
-from accelerate.utils.deepspeed import DummyOptim, DummyScheduler
-
-
-MAX_GPU_BATCH_SIZE = 16
-EVAL_BATCH_SIZE = 32
-
-
-# Converting Bytes to Megabytes
-def b2mb(x):
-    return int(x / 2**20)
-
-
-# This context manager is used to track the peak memory usage of the process
-class TorchTracemalloc:
-    def __enter__(self):
-        gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            torch.cuda.reset_max_memory_allocated()  # reset the peak gauge to zero
-            self.begin = torch.cuda.memory_allocated()
-        elif is_npu_available():
-            torch.npu.empty_cache()
-            torch.npu.reset_max_memory_allocated()  # reset the peak gauge to zero
-            self.begin = torch.npu.memory_allocated()
-        elif is_xpu_available():
-            torch.xpu.empty_cache()
-            torch.xpu.reset_max_memory_allocated()  # reset the peak gauge to zero
-            self.begin = torch.xpu.memory_allocated()
-        return self
-
-    def __exit__(self, *exc):
-        gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            self.end = torch.cuda.memory_allocated()
-            self.peak = torch.cuda.max_memory_allocated()
-        elif is_npu_available():
-            torch.npu.empty_cache()
-            self.end = torch.npu.memory_allocated()
-            self.peak = torch.npu.max_memory_allocated()
-        elif is_xpu_available():
-            torch.xpu.empty_cache()
-            self.end = torch.xpu.memory_allocated()
-            self.peak = torch.xpu.max_memory_allocated()
-        self.used = b2mb(self.end - self.begin)
-        self.peaked = b2mb(self.peak - self.begin)
-        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
-
-
-def get_dataloaders(
-    accelerator: Accelerator,
-    batch_size: int = 16,
-    model_name: str = "bert-base-cased",
-    n_train: int = 320,
-    n_val: int = 160,
-):
-    """
-    Creates a set of `DataLoader`s for the `glue` dataset.
-
-    Args:
-        accelerator (`Accelerator`):
-            An `Accelerator` object
-        batch_size (`int`, *optional*):
-            The batch size for the train and validation DataLoaders.
-        model_name (`str`, *optional*):
-            The name of the model to use.
-        n_train (`int`, *optional*):
-            The number of training examples to use.
-        n_val (`int`, *optional*):
-            The number of validation examples to use.
-    """
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    datasets = load_dataset(
-        "glue", "mrpc", split={"train": f"train[:{n_train}]", "validation": f"validation[:{n_val}]"}
-    )
-
-    def tokenize_function(examples):
-        # max_length=None => use the model max length (it's actually the default)
-        outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
-        return outputs
-
-    # Apply the method we just defined to all the examples in all the splits of the dataset
-    tokenized_datasets = datasets.map(
-        tokenize_function, batched=True, remove_columns=["idx", "sentence1", "sentence2"], load_from_cache_file=False
-    )
-
-    # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
-    # transformers library
-    tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
-
-    def collate_fn(examples):
-        # On TPU it's best to pad everything to the same length or training will be very slow.
-        if accelerator.distributed_type == DistributedType.TPU:
-            return tokenizer.pad(examples, padding="max_length", max_length=128, return_tensors="pt")
-        return tokenizer.pad(examples, padding="longest", return_tensors="pt")
-
-    # Instantiate dataloaders.
-    train_dataloader = DataLoader(
-        tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size
-    )
-    eval_dataloader = DataLoader(
-        tokenized_datasets["validation"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE
-    )
-
-    return train_dataloader, eval_dataloader
-
-
-def training_function(config, args):
-    # Initialize accelerator
-    accelerator = Accelerator()
-
-    # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
-    lr = config["lr"]
-    num_epochs = int(config["num_epochs"])
-    seed = int(config["seed"])
-    batch_size = int(config["batch_size"])
-    model_name = args.model_name_or_path
-
-    set_seed(seed)
-    train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size, model_name, args.n_train, args.n_val)
-
-    # Instantiate the model (we build the model here so that the seed also control new weights initialization)
-    model = AutoModelForSequenceClassification.from_pretrained(model_name, return_dict=True)
-
-    # Instantiate optimizer
-    optimizer_cls = (
-        AdamW
-        if accelerator.state.deepspeed_plugin is None
-        or "optimizer" not in accelerator.state.deepspeed_plugin.deepspeed_config
-        else DummyOptim
-    )
-    optimizer = optimizer_cls(params=model.parameters(), lr=lr)
-
-    if accelerator.state.deepspeed_plugin is not None:
-        gradient_accumulation_steps = accelerator.state.deepspeed_plugin.deepspeed_config[
-            "gradient_accumulation_steps"
-        ]
-    else:
-        gradient_accumulation_steps = 1
-    max_training_steps = (len(train_dataloader) * num_epochs) // gradient_accumulation_steps
-
-    # Instantiate scheduler
-    if (
-        accelerator.state.deepspeed_plugin is None
-        or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
-    ):
-        lr_scheduler = get_linear_schedule_with_warmup(
-            optimizer=optimizer,
-            num_warmup_steps=0,
-            num_training_steps=max_training_steps,
-        )
-    else:
-        lr_scheduler = DummyScheduler(optimizer, total_num_steps=max_training_steps, warmup_num_steps=0)
-
-    # Prepare everything
-    # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
-    # prepare method.
-    model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(
-        model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
-    )
-
-    # We need to keep track of how many total steps we have iterated over
-    overall_step = 0
-    # We also need to keep track of the stating epoch so files are named properly
-    starting_epoch = 0
-
-    # Now we train the model
-    train_total_peak_memory = {}
-    for epoch in range(starting_epoch, num_epochs):
-        with TorchTracemalloc() as tracemalloc:
-            model.train()
-            for step, batch in enumerate(train_dataloader):
-                outputs = model(**batch)
-                loss = outputs.loss
-                loss = loss / gradient_accumulation_steps
-                accelerator.backward(loss)
-                if step % gradient_accumulation_steps == 0:
-                    optimizer.step()
-                    lr_scheduler.step()
-                    optimizer.zero_grad()
-
-                overall_step += 1
-
-        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
-        accelerator.print("Memory before entering the train : {}".format(b2mb(tracemalloc.begin)))
-        accelerator.print("Memory consumed at the end of the train (end-begin): {}".format(tracemalloc.used))
-        accelerator.print("Peak Memory consumed during the train (max-begin): {}".format(tracemalloc.peaked))
-        accelerator.print(
-            "Total Peak Memory consumed during the train (max): {}".format(
-                tracemalloc.peaked + b2mb(tracemalloc.begin)
-            )
-        )
-        train_total_peak_memory[f"epoch-{epoch}"] = tracemalloc.peaked + b2mb(tracemalloc.begin)
-        if args.peak_memory_upper_bound is not None:
-            assert (
-                train_total_peak_memory[f"epoch-{epoch}"] <= args.peak_memory_upper_bound
-            ), "Peak memory usage exceeded the upper bound"
-
-    accelerator.wait_for_everyone()
-    if accelerator.is_main_process:
-        with open(os.path.join(args.output_dir, "peak_memory_utilization.json"), "w") as f:
-            json.dump(train_total_peak_memory, f)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Simple example of training script tracking peak GPU memory usage.")
-    parser.add_argument(
-        "--model_name_or_path",
-        type=str,
-        default="bert-base-cased",
-        help="Path to pretrained model or model identifier from huggingface.co/models.",
-        required=False,
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default=".",
-        help="Optional save directory where all checkpoint folders will be stored. Default is the current working directory.",
-    )
-    parser.add_argument(
-        "--peak_memory_upper_bound",
-        type=float,
-        default=None,
-        help="The upper bound of peak memory usage in MB. If set, the training will throw an error if the peak memory usage exceeds this value.",
-    )
-    parser.add_argument(
-        "--n_train",
-        type=int,
-        default=320,
-        help="Number of training examples to use.",
-    )
-    parser.add_argument(
-        "--n_val",
-        type=int,
-        default=160,
-        help="Number of validation examples to use.",
-    )
-    parser.add_argument(
-        "--num_epochs",
-        type=int,
-        default=1,
-        help="Number of train epochs.",
-    )
-    args = parser.parse_args()
-    config = {"lr": 2e-5, "num_epochs": args.num_epochs, "seed": 42, "batch_size": 16}
-    training_function(config, args)
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/scripts/external_deps/test_performance.py

@@ -1,219 +0,0 @@
-# coding=utf-8
-
-import argparse
-import json
-import os
-
-import evaluate
-import torch
-from datasets import load_dataset
-from torch.optim import AdamW
-from torch.utils.data import DataLoader
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed
-
-from accelerate import Accelerator, DistributedType
-from accelerate.utils.deepspeed import DummyOptim, DummyScheduler
-
-
-MAX_GPU_BATCH_SIZE = 16
-EVAL_BATCH_SIZE = 32
-
-
-def get_dataloaders(accelerator: Accelerator, batch_size: int = 16, model_name: str = "bert-base-cased"):
-    """
-    Creates a set of `DataLoader`s for the `glue` dataset.
-
-    Args:
-        accelerator (`Accelerator`):
-            An `Accelerator` object
-        batch_size (`int`, *optional*):
-            The batch size for the train and validation DataLoaders.
-        model_name (`str`, *optional*):
-    """
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    datasets = load_dataset("glue", "mrpc")
-
-    def tokenize_function(examples):
-        # max_length=None => use the model max length (it's actually the default)
-        outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
-        return outputs
-
-    # Apply the method we just defined to all the examples in all the splits of the dataset
-    tokenized_datasets = datasets.map(
-        tokenize_function, batched=True, remove_columns=["idx", "sentence1", "sentence2"], load_from_cache_file=False
-    )
-
-    # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
-    # transformers library
-    tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
-
-    def collate_fn(examples):
-        # On TPU it's best to pad everything to the same length or training will be very slow.
-        if accelerator.distributed_type == DistributedType.TPU:
-            return tokenizer.pad(examples, padding="max_length", max_length=128, return_tensors="pt")
-        return tokenizer.pad(examples, padding="longest", return_tensors="pt")
-
-    # Instantiate dataloaders.
-    train_dataloader = DataLoader(
-        tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size
-    )
-    eval_dataloader = DataLoader(
-        tokenized_datasets["validation"], shuffle=False, collate_fn=collate_fn, batch_size=EVAL_BATCH_SIZE
-    )
-
-    return train_dataloader, eval_dataloader
-
-
-def training_function(config, args):
-    # Initialize accelerator
-    accelerator = Accelerator()
-
-    # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
-    lr = config["lr"]
-    num_epochs = int(config["num_epochs"])
-    seed = int(config["seed"])
-    batch_size = int(config["batch_size"])
-    model_name = args.model_name_or_path
-
-    set_seed(seed)
-    train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size, model_name)
-
-    # Instantiate the model (we build the model here so that the seed also control new weights initialization)
-    model = AutoModelForSequenceClassification.from_pretrained(model_name, return_dict=True)
-
-    # Instantiate optimizer
-    optimizer_cls = (
-        AdamW
-        if accelerator.state.deepspeed_plugin is None
-        or "optimizer" not in accelerator.state.deepspeed_plugin.deepspeed_config
-        else DummyOptim
-    )
-    optimizer = optimizer_cls(params=model.parameters(), lr=lr)
-
-    if accelerator.state.deepspeed_plugin is not None:
-        gradient_accumulation_steps = accelerator.state.deepspeed_plugin.deepspeed_config[
-            "gradient_accumulation_steps"
-        ]
-    else:
-        gradient_accumulation_steps = 1
-    max_training_steps = (len(train_dataloader) * num_epochs) // gradient_accumulation_steps
-
-    # Instantiate scheduler
-    if (
-        accelerator.state.deepspeed_plugin is None
-        or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
-    ):
-        lr_scheduler = get_linear_schedule_with_warmup(
-            optimizer=optimizer,
-            num_warmup_steps=0,
-            num_training_steps=max_training_steps,
-        )
-    else:
-        lr_scheduler = DummyScheduler(optimizer, total_num_steps=max_training_steps, warmup_num_steps=0)
-
-    # Prepare everything
-    # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
-    # prepare method.
-    model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(
-        model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
-    )
-
-    # We need to keep track of how many total steps we have iterated over
-    overall_step = 0
-    # We also need to keep track of the stating epoch so files are named properly
-    starting_epoch = 0
-
-    # Now we train the model
-    metric = evaluate.load("glue", "mrpc")
-    best_performance = 0
-    performance_metric = {}
-    for epoch in range(starting_epoch, num_epochs):
-        model.train()
-        for step, batch in enumerate(train_dataloader):
-            outputs = model(**batch)
-            loss = outputs.loss
-            loss = loss / gradient_accumulation_steps
-            accelerator.backward(loss)
-            if step % gradient_accumulation_steps == 0:
-                optimizer.step()
-                lr_scheduler.step()
-                optimizer.zero_grad()
-
-            overall_step += 1
-
-        model.eval()
-        samples_seen = 0
-        for step, batch in enumerate(eval_dataloader):
-            # We could avoid this line since we set the accelerator with `device_placement=True`.
-            batch.to(accelerator.device)
-            with torch.no_grad():
-                outputs = model(**batch)
-            predictions = outputs.logits.argmax(dim=-1)
-            # It is slightly faster to call this once, than multiple times
-            predictions, references = accelerator.gather(
-                (predictions, batch["labels"])
-            )  # If we are in a multiprocess environment, the last batch has duplicates
-            if accelerator.use_distributed:
-                if step == len(eval_dataloader) - 1:
-                    predictions = predictions[: len(eval_dataloader.dataset) - samples_seen]
-                    references = references[: len(eval_dataloader.dataset) - samples_seen]
-                else:
-                    samples_seen += references.shape[0]
-            metric.add_batch(
-                predictions=predictions,
-                references=references,
-            )
-
-        eval_metric = metric.compute()
-        # Use accelerator.print to print only on the main process.
-        accelerator.print(f"epoch {epoch}:", eval_metric)
-        performance_metric[f"epoch-{epoch}"] = eval_metric["accuracy"]
-
-        if best_performance < eval_metric["accuracy"]:
-            best_performance = eval_metric["accuracy"]
-
-    if args.performance_lower_bound is not None:
-        assert (
-            args.performance_lower_bound <= best_performance
-        ), f"Best performance metric {best_performance} is lower than the lower bound {args.performance_lower_bound}"
-
-    accelerator.wait_for_everyone()
-    if accelerator.is_main_process:
-        with open(os.path.join(args.output_dir, "all_results.json"), "w") as f:
-            json.dump(performance_metric, f)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Simple example of training script tracking peak GPU memory usage.")
-    parser.add_argument(
-        "--model_name_or_path",
-        type=str,
-        default="bert-base-cased",
-        help="Path to pretrained model or model identifier from huggingface.co/models.",
-        required=False,
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default=".",
-        help="Optional save directory where all checkpoint folders will be stored. Default is the current working directory.",
-    )
-    parser.add_argument(
-        "--performance_lower_bound",
-        type=float,
-        default=None,
-        help="Optional lower bound for the performance metric. If set, the training will throw error when the performance metric drops below this value.",
-    )
-    parser.add_argument(
-        "--num_epochs",
-        type=int,
-        default=3,
-        help="Number of train epochs.",
-    )
-    args = parser.parse_args()
-    config = {"lr": 2e-5, "num_epochs": args.num_epochs, "seed": 42, "batch_size": 16}
-    training_function(config, args)
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/scripts/test_cli.py

@@ -1,13 +0,0 @@
-import torch
-
-
-def main():
-    if torch.cuda.is_available():
-        num_gpus = torch.cuda.device_count()
-    else:
-        num_gpus = 0
-    print(f"Successfully ran on {num_gpus} GPUs")
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/scripts/test_distributed_data_loop.py

@@ -1,226 +0,0 @@
-#!/usr/bin/env python
-
-
-
-
-import warnings
-from typing import List
-from unittest.mock import Mock
-
-import torch
-from torch.utils.data import DataLoader, IterableDataset, TensorDataset
-
-from accelerate.accelerator import Accelerator
-from accelerate.utils.dataclasses import DistributedType
-
-
-class DummyIterableDataset(IterableDataset):
-    def __init__(self, data):
-        self.data = data
-
-    def __iter__(self):
-        for element in self.data:
-            yield element
-
-
-def create_accelerator(even_batches=True):
-    accelerator = Accelerator(even_batches=even_batches)
-    assert accelerator.num_processes == 2, "this script expects that two GPUs are available"
-    return accelerator
-
-
-def create_dataloader(accelerator: Accelerator, dataset_size: int, batch_size: int, iterable: bool = False):
-    """
-    Create a simple DataLoader to use during the test cases
-    """
-    if iterable:
-        dataset = DummyIterableDataset(torch.as_tensor(range(dataset_size)))
-    else:
-        dataset = TensorDataset(torch.as_tensor(range(dataset_size)))
-
-    dl = DataLoader(dataset, batch_size=batch_size)
-    dl = accelerator.prepare(dl)
-
-    return dl
-
-
-def verify_dataloader_batch_sizes(
-    accelerator: Accelerator,
-    dataset_size: int,
-    batch_size: int,
-    process_0_expected_batch_sizes: List[int],
-    process_1_expected_batch_sizes: List[int],
-):
-    """
-    A helper function for verifying the batch sizes coming from a prepared dataloader in each process
-    """
-    dl = create_dataloader(accelerator=accelerator, dataset_size=dataset_size, batch_size=batch_size)
-
-    batch_sizes = [len(batch[0]) for batch in dl]
-
-    if accelerator.process_index == 0:
-        assert batch_sizes == process_0_expected_batch_sizes
-    elif accelerator.process_index == 1:
-        assert batch_sizes == process_1_expected_batch_sizes
-
-
-def test_default_ensures_even_batch_sizes():
-    accelerator = create_accelerator()
-
-    # without padding, we would expect a different number of batches
-    verify_dataloader_batch_sizes(
-        accelerator,
-        dataset_size=3,
-        batch_size=1,
-        process_0_expected_batch_sizes=[1, 1],
-        process_1_expected_batch_sizes=[1, 1],
-    )
-
-    # without padding, we would expect the same number of batches, but different sizes
-    verify_dataloader_batch_sizes(
-        accelerator,
-        dataset_size=7,
-        batch_size=2,
-        process_0_expected_batch_sizes=[2, 2],
-        process_1_expected_batch_sizes=[2, 2],
-    )
-
-
-def test_can_disable_even_batches():
-    accelerator = create_accelerator(even_batches=False)
-
-    verify_dataloader_batch_sizes(
-        accelerator,
-        dataset_size=3,
-        batch_size=1,
-        process_0_expected_batch_sizes=[1, 1],
-        process_1_expected_batch_sizes=[1],
-    )
-
-    verify_dataloader_batch_sizes(
-        accelerator,
-        dataset_size=7,
-        batch_size=2,
-        process_0_expected_batch_sizes=[2, 2],
-        process_1_expected_batch_sizes=[2, 1],
-    )
-
-
-def test_can_join_uneven_inputs():
-    accelerator = create_accelerator(even_batches=False)
-
-    model = torch.nn.Linear(1, 1)
-    ddp_model = accelerator.prepare(model)
-
-    dl = create_dataloader(accelerator, dataset_size=3, batch_size=1)
-
-    batch_idxs = []
-    with accelerator.join_uneven_inputs([ddp_model]):
-        for batch_idx, batch in enumerate(dl):
-            output = ddp_model(batch[0].float())
-            loss = output.sum()
-            loss.backward()
-            batch_idxs.append(batch_idx)
-
-    accelerator.wait_for_everyone()
-
-    if accelerator.process_index == 0:
-        assert batch_idxs == [0, 1]
-    elif accelerator.process_index == 1:
-        assert batch_idxs == [0]
-
-
-def test_join_raises_warning_for_non_ddp_distributed(accelerator):
-    with warnings.catch_warnings(record=True) as w:
-        with accelerator.join_uneven_inputs([Mock()]):
-            pass
-
-        assert issubclass(w[-1].category, UserWarning)
-        assert "only supported for multi-GPU" in str(w[-1].message)
-
-
-def test_join_can_override_even_batches():
-    default_even_batches = True
-    overridden_even_batches = False
-    accelerator = create_accelerator(even_batches=default_even_batches)
-    model = torch.nn.Linear(1, 1)
-    ddp_model = accelerator.prepare(model)
-    train_dl = create_dataloader(accelerator, dataset_size=3, batch_size=1)
-    valid_dl = create_dataloader(accelerator, dataset_size=3, batch_size=1)
-
-    with accelerator.join_uneven_inputs([ddp_model], even_batches=overridden_even_batches):
-        train_dl_overridden_value = train_dl.batch_sampler.even_batches
-        valid_dl_overridden_value = valid_dl.batch_sampler.even_batches
-
-    assert train_dl_overridden_value == overridden_even_batches
-    assert valid_dl_overridden_value == overridden_even_batches
-    assert train_dl.batch_sampler.even_batches == default_even_batches
-    assert valid_dl.batch_sampler.even_batches == default_even_batches
-
-
-def test_join_can_override_for_mixed_type_dataloaders():
-    default_even_batches = True
-    overridden_even_batches = False
-    accelerator = create_accelerator(even_batches=default_even_batches)
-    model = torch.nn.Linear(1, 1)
-    ddp_model = accelerator.prepare(model)
-    create_dataloader(accelerator, dataset_size=3, batch_size=1, iterable=True)
-    batch_dl = create_dataloader(accelerator, dataset_size=3, batch_size=1)
-
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore")
-        try:
-            with accelerator.join_uneven_inputs([ddp_model], even_batches=overridden_even_batches):
-                batch_dl_overridden_value = batch_dl.batch_sampler.even_batches
-        except AttributeError:
-            # ensure attribute error is not raised when processing iterable dl
-            raise AssertionError
-
-    assert batch_dl_overridden_value == overridden_even_batches
-    assert batch_dl.batch_sampler.even_batches == default_even_batches
-
-
-def test_join_raises_warning_for_iterable_when_overriding_even_batches():
-    accelerator = create_accelerator()
-    model = torch.nn.Linear(1, 1)
-    ddp_model = accelerator.prepare(model)
-    create_dataloader(accelerator, dataset_size=3, batch_size=1, iterable=True)
-
-    with warnings.catch_warnings(record=True) as w:
-        with accelerator.join_uneven_inputs([ddp_model], even_batches=False):
-            pass
-
-        assert issubclass(w[-1].category, UserWarning)
-        assert "only supported for map-style datasets" in str(w[-1].message)
-
-
-def main():
-    accelerator = create_accelerator()
-
-    accelerator.print("Test that even_batches variable ensures uniform batches across processes")
-    test_default_ensures_even_batch_sizes()
-
-    accelerator.print("Run tests with even_batches disabled")
-    test_can_disable_even_batches()
-
-    accelerator.print("Test joining uneven inputs")
-    test_can_join_uneven_inputs()
-
-    accelerator.print("Test overriding even_batches when joining uneven inputs")
-    test_join_can_override_even_batches()
-
-    accelerator.print("Test overriding even_batches for mixed dataloader types")
-    test_join_can_override_for_mixed_type_dataloaders()
-
-    accelerator.print("Test overriding even_batches raises a warning for iterable dataloaders")
-    test_join_raises_warning_for_iterable_when_overriding_even_batches()
-
-    accelerator.print("Test join with non DDP distributed raises warning")
-    original_state = accelerator.state.distributed_type
-    accelerator.state.distributed_type = DistributedType.FSDP
-    test_join_raises_warning_for_non_ddp_distributed(accelerator)
-    accelerator.state.distributed_type = original_state
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/scripts/test_notebook.py

@@ -1,40 +0,0 @@
-# Test file to ensure that in general certain situational setups for notebooks work.
-import os
-
-from pytest import raises
-
-from accelerate import PartialState, notebook_launcher
-from accelerate.test_utils import require_bnb
-from accelerate.utils import is_bnb_available
-
-
-def basic_function():
-    # Just prints the PartialState
-    print(f"PartialState:\n{PartialState()}")
-
-
-NUM_PROCESSES = int(os.environ.get("ACCELERATE_NUM_PROCESSES", 1))
-
-
-def test_can_initialize():
-    notebook_launcher(basic_function, (), num_processes=NUM_PROCESSES)
-
-
-@require_bnb
-def test_problematic_imports():
-    with raises(RuntimeError, match="Please keep these imports"):
-        import bitsandbytes as bnb  # noqa: F401
-
-        notebook_launcher(basic_function, (), num_processes=NUM_PROCESSES)
-
-
-def main():
-    print("Test basic notebook can be ran")
-    test_can_initialize()
-    if is_bnb_available():
-        print("Test problematic imports (bnb)")
-        test_problematic_imports()
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/scripts/test_ops.py

@@ -1,147 +0,0 @@
-#!/usr/bin/env python
-
-
-
-import torch
-
-from accelerate import PartialState
-from accelerate.test_utils.testing import assert_exception
-from accelerate.utils.dataclasses import DistributedType
-from accelerate.utils.operations import (
-    DistributedOperationException,
-    broadcast,
-    gather,
-    gather_object,
-    pad_across_processes,
-    reduce,
-)
-
-
-def create_tensor(state):
-    return (torch.arange(state.num_processes) + 1.0 + (state.num_processes * state.process_index)).to(state.device)
-
-
-def test_gather(state):
-    tensor = create_tensor(state)
-    gathered_tensor = gather(tensor)
-    assert gathered_tensor.tolist() == list(range(1, state.num_processes**2 + 1))
-
-
-def test_gather_object(state):
-    obj = [state.process_index]
-    gathered_obj = gather_object(obj)
-    assert len(gathered_obj) == state.num_processes, f"{gathered_obj}, {len(gathered_obj)} != {state.num_processes}"
-    assert gathered_obj == list(range(state.num_processes)), f"{gathered_obj} != {list(range(state.num_processes))}"
-
-
-def test_gather_non_contigous(state):
-    # Create a non-contiguous tensor
-    tensor = torch.arange(12).view(4, 3).t().to(state.device)
-    assert not tensor.is_contiguous()
-    # Shouldn't error out
-    _ = gather(tensor)
-
-
-def test_broadcast(state):
-    tensor = create_tensor(state)
-    broadcasted_tensor = broadcast(tensor)
-    assert broadcasted_tensor.shape == torch.Size([state.num_processes])
-    assert broadcasted_tensor.tolist() == list(range(1, state.num_processes + 1))
-
-
-def test_pad_across_processes(state):
-    # We need to pad the tensor with one more element if we are the main process
-    # to ensure that we can pad
-    if state.is_main_process:
-        tensor = torch.arange(state.num_processes + 1).to(state.device)
-    else:
-        tensor = torch.arange(state.num_processes).to(state.device)
-    padded_tensor = pad_across_processes(tensor)
-    assert padded_tensor.shape == torch.Size([state.num_processes + 1])
-    if not state.is_main_process:
-        assert padded_tensor.tolist() == list(range(0, state.num_processes)) + [0]
-
-
-def test_reduce_sum(state):
-    # For now runs on only two processes
-    if state.num_processes != 2:
-        return
-    tensor = create_tensor(state)
-    reduced_tensor = reduce(tensor, "sum")
-    truth_tensor = torch.tensor([4.0, 6]).to(state.device)
-    assert torch.allclose(reduced_tensor, truth_tensor), f"{reduced_tensor} != {truth_tensor}"
-
-
-def test_reduce_mean(state):
-    # For now runs on only two processes
-    if state.num_processes != 2:
-        return
-    tensor = create_tensor(state)
-    reduced_tensor = reduce(tensor, "mean")
-    truth_tensor = torch.tensor([2.0, 3]).to(state.device)
-    assert torch.allclose(reduced_tensor, truth_tensor), f"{reduced_tensor} != {truth_tensor}"
-
-
-def test_op_checker(state):
-    # Must be in a distributed state
-    if state.distributed_type == DistributedType.NO:
-        return
-    state.debug = True
-    # `pad_across_processes`
-    if state.process_index == 0:
-        data = {"tensor": torch.tensor([[0.0, 1, 2, 3, 4]]).to(state.device)}
-    else:
-        data = {"tensor": torch.tensor([[[0.0, 1, 2, 3, 4, 5]]]).to(state.device)}
-
-    with assert_exception(DistributedOperationException):
-        pad_across_processes(data, dim=0)
-
-    # `reduce`
-    if state.process_index == 0:
-        data = {"tensor": torch.tensor([[0.0, 1, 2, 3, 4]]).to(state.device)}
-    else:
-        data = {"tensor": torch.tensor([[[0.0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]]).to(state.device)}
-
-    with assert_exception(DistributedOperationException):
-        reduce(data)
-
-    # `broadcast`
-    if state.process_index == 0:
-        data = {"tensor": torch.tensor([[0.0, 1, 2, 3, 4]]).to(state.device)}
-    else:
-        data = {"tensor": torch.tensor([[[0.0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]]).to(state.device)}
-
-    with assert_exception(DistributedOperationException):
-        broadcast(data)
-
-    state.debug = False
-
-
-def _mp_fn(index):
-    # For xla_spawn (TPUs)
-    main()
-
-
-def main():
-    state = PartialState()
-    state.print(f"State: {state}")
-    state.print("testing gather")
-    test_gather(state)
-    state.print("testing gather_object")
-    test_gather_object(state)
-    state.print("testing gather non-contigous")
-    test_gather_non_contigous(state)
-    state.print("testing broadcast")
-    test_broadcast(state)
-    state.print("testing pad_across_processes")
-    test_pad_across_processes(state)
-    state.print("testing reduce_sum")
-    test_reduce_sum(state)
-    state.print("testing reduce_mean")
-    test_reduce_mean(state)
-    state.print("testing op_checker")
-    test_op_checker(state)
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/scripts/test_script.py

@@ -1,660 +0,0 @@
-#!/usr/bin/env python
-
-
-
-import contextlib
-import io
-import math
-import time
-from copy import deepcopy
-from pathlib import Path
-
-import numpy as np
-import torch
-from torch.utils.data import DataLoader, Dataset
-
-from accelerate import Accelerator
-from accelerate.data_loader import SeedableRandomSampler, prepare_data_loader
-from accelerate.state import AcceleratorState
-from accelerate.test_utils import RegressionDataset, are_the_same_tensors
-from accelerate.utils import (
-    DistributedType,
-    gather,
-    is_bf16_available,
-    is_ipex_available,
-    is_npu_available,
-    is_xpu_available,
-    set_seed,
-    synchronize_rng_states,
-)
-
-
-# TODO: remove RegressionModel4XPU once ccl support empty buffer in broadcasting.
-if is_xpu_available():
-    from accelerate.test_utils import RegressionModel4XPU as RegressionModel
-else:
-    from accelerate.test_utils import RegressionModel
-
-
-def print_main(state):
-    print(f"Printing from the main process {state.process_index}")
-
-
-def print_local_main(state):
-    print(f"Printing from the local main process {state.local_process_index}")
-
-
-def print_last(state):
-    print(f"Printing from the last process {state.process_index}")
-
-
-def print_on(state, process_idx):
-    print(f"Printing from process {process_idx}: {state.process_index}")
-
-
-def process_execution_check():
-    accelerator = Accelerator()
-    num_processes = accelerator.num_processes
-    # Test main_process_first context manager
-    path = Path("check_main_process_first.txt")
-    with accelerator.main_process_first():
-        if accelerator.is_main_process:
-            time.sleep(0.1)  # ensure main process takes longest
-            with open(path, "a+") as f:
-                f.write("Currently in the main process\n")
-        else:
-            with open(path, "a+") as f:
-                f.write("Now on another process\n")
-    accelerator.wait_for_everyone()
-
-    if accelerator.is_main_process:
-        with open(path, "r") as f:
-            text = "".join(f.readlines())
-        try:
-            assert text.startswith("Currently in the main process\n"), "Main process was not first"
-            if num_processes > 1:
-                assert text.endswith("Now on another process\n"), "Main process was not first"
-            assert (
-                text.count("Now on another process\n") == accelerator.num_processes - 1
-            ), f"Only wrote to file {text.count('Now on another process') + 1} times, not {accelerator.num_processes}"
-        except AssertionError:
-            path.unlink()
-            raise
-
-    if accelerator.is_main_process and path.exists():
-        path.unlink()
-    accelerator.wait_for_everyone()
-    # Test the decorators
-    f = io.StringIO()
-    with contextlib.redirect_stdout(f):
-        accelerator.on_main_process(print_main)(accelerator.state)
-    result = f.getvalue().rstrip()
-    if accelerator.is_main_process:
-        assert result == "Printing from the main process 0", f"{result} != Printing from the main process 0"
-    else:
-        assert f.getvalue().rstrip() == "", f'{result} != ""'
-    f.truncate(0)
-    f.seek(0)
-
-    with contextlib.redirect_stdout(f):
-        accelerator.on_local_main_process(print_local_main)(accelerator.state)
-    if accelerator.is_local_main_process:
-        assert f.getvalue().rstrip() == "Printing from the local main process 0"
-    else:
-        assert f.getvalue().rstrip() == ""
-    f.truncate(0)
-    f.seek(0)
-
-    with contextlib.redirect_stdout(f):
-        accelerator.on_last_process(print_last)(accelerator.state)
-    if accelerator.is_last_process:
-        assert f.getvalue().rstrip() == f"Printing from the last process {accelerator.state.num_processes - 1}"
-    else:
-        assert f.getvalue().rstrip() == ""
-    f.truncate(0)
-    f.seek(0)
-
-    for process_idx in range(num_processes):
-        with contextlib.redirect_stdout(f):
-            accelerator.on_process(print_on, process_index=process_idx)(accelerator.state, process_idx)
-        if accelerator.process_index == process_idx:
-            assert f.getvalue().rstrip() == f"Printing from process {process_idx}: {accelerator.process_index}"
-        else:
-            assert f.getvalue().rstrip() == ""
-        f.truncate(0)
-        f.seek(0)
-
-
-def init_state_check():
-    # Test we can instantiate this twice in a row.
-    state = AcceleratorState()
-    if state.local_process_index == 0:
-        print("Testing, testing. 1, 2, 3.")
-    print(state)
-
-
-def rng_sync_check():
-    state = AcceleratorState()
-    synchronize_rng_states(["torch"])
-    assert are_the_same_tensors(torch.get_rng_state()), "RNG states improperly synchronized on CPU."
-    if state.distributed_type == DistributedType.MULTI_GPU:
-        synchronize_rng_states(["cuda"])
-        assert are_the_same_tensors(torch.cuda.get_rng_state()), "RNG states improperly synchronized on GPU."
-    elif state.distributed_type == DistributedType.MULTI_XPU:
-        synchronize_rng_states(["xpu"])
-        assert are_the_same_tensors(torch.xpu.get_rng_state()), "RNG states improperly synchronized on XPU."
-    generator = torch.Generator()
-    synchronize_rng_states(["generator"], generator=generator)
-    assert are_the_same_tensors(generator.get_state()), "RNG states improperly synchronized in generator."
-
-    if state.local_process_index == 0:
-        print("All rng are properly synched.")
-
-
-def dl_preparation_check():
-    state = AcceleratorState()
-    length = 32 * state.num_processes
-
-    dl = DataLoader(range(length), batch_size=8)
-    dl = prepare_data_loader(dl, state.device, state.num_processes, state.process_index, put_on_device=True)
-    result = []
-    for batch in dl:
-        result.append(gather(batch))
-    result = torch.cat(result)
-
-    print(state.process_index, result, type(dl))
-    assert torch.equal(result.cpu(), torch.arange(0, length).long()), "Wrong non-shuffled dataloader result."
-
-    dl = DataLoader(range(length), batch_size=8)
-    dl = prepare_data_loader(
-        dl,
-        state.device,
-        state.num_processes,
-        state.process_index,
-        put_on_device=True,
-        split_batches=True,
-    )
-    result = []
-    for batch in dl:
-        result.append(gather(batch))
-    result = torch.cat(result)
-    assert torch.equal(result.cpu(), torch.arange(0, length).long()), "Wrong non-shuffled dataloader result."
-
-    if state.process_index == 0:
-        print("Non-shuffled dataloader passing.")
-
-    dl = DataLoader(range(length), batch_size=8, shuffle=True)
-    dl = prepare_data_loader(dl, state.device, state.num_processes, state.process_index, put_on_device=True)
-    result = []
-    for batch in dl:
-        result.append(gather(batch))
-    result = torch.cat(result).tolist()
-    result.sort()
-    assert result == list(range(length)), "Wrong shuffled dataloader result."
-
-    dl = DataLoader(range(length), batch_size=8, shuffle=True)
-    dl = prepare_data_loader(
-        dl,
-        state.device,
-        state.num_processes,
-        state.process_index,
-        put_on_device=True,
-        split_batches=True,
-    )
-    result = []
-    for batch in dl:
-        result.append(gather(batch))
-    result = torch.cat(result).tolist()
-    result.sort()
-    assert result == list(range(length)), "Wrong shuffled dataloader result."
-
-    if state.local_process_index == 0:
-        print("Shuffled dataloader passing.")
-
-
-def central_dl_preparation_check():
-    state = AcceleratorState()
-    length = 32 * state.num_processes
-
-    dl = DataLoader(range(length), batch_size=8)
-    dl = prepare_data_loader(
-        dl, state.device, state.num_processes, state.process_index, put_on_device=True, dispatch_batches=True
-    )
-    result = []
-    for batch in dl:
-        result.append(gather(batch))
-    result = torch.cat(result)
-    assert torch.equal(result.cpu(), torch.arange(0, length).long()), "Wrong non-shuffled dataloader result."
-
-    dl = DataLoader(range(length), batch_size=8)
-    dl = prepare_data_loader(
-        dl,
-        state.device,
-        state.num_processes,
-        state.process_index,
-        put_on_device=True,
-        split_batches=True,
-        dispatch_batches=True,
-    )
-    result = []
-    for batch in dl:
-        result.append(gather(batch))
-    result = torch.cat(result)
-    assert torch.equal(result.cpu(), torch.arange(0, length).long()), "Wrong non-shuffled dataloader result."
-
-    if state.process_index == 0:
-        print("Non-shuffled central dataloader passing.")
-
-    dl = DataLoader(range(length), batch_size=8, shuffle=True)
-    dl = prepare_data_loader(
-        dl, state.device, state.num_processes, state.process_index, put_on_device=True, dispatch_batches=True
-    )
-    result = []
-    for batch in dl:
-        result.append(gather(batch))
-    result = torch.cat(result).tolist()
-    result.sort()
-    assert result == list(range(length)), "Wrong shuffled dataloader result."
-
-    dl = DataLoader(range(length), batch_size=8, shuffle=True)
-    dl = prepare_data_loader(
-        dl,
-        state.device,
-        state.num_processes,
-        state.process_index,
-        put_on_device=True,
-        split_batches=True,
-        dispatch_batches=True,
-    )
-    result = []
-    for batch in dl:
-        result.append(gather(batch))
-    result = torch.cat(result).tolist()
-    result.sort()
-    assert result == list(range(length)), "Wrong shuffled dataloader result."
-
-    if state.local_process_index == 0:
-        print("Shuffled central dataloader passing.")
-
-
-def custom_sampler_check():
-    state = AcceleratorState()
-
-    class CustomDataset(Dataset):
-        def __init__(self, data):
-            self.data = data
-
-        def __len__(self):
-            return len(self.data)
-
-        def __getitem__(self, index):
-            return self.data[index]
-
-    class CustomBatchSampler:
-        def __init__(self, dataset_length: int, batch_size: int, shuffle: bool = True):
-            self.batch_size = batch_size
-            self.data_index = np.arange(dataset_length)
-            self.shuffle = shuffle
-
-        def __iter__(self):
-            num_batches = len(self)
-            if self.shuffle:
-                index = np.random.permutation(self.data_index)
-            else:
-                index = self.data_index
-            output = np.array_split(index, num_batches)
-            yield from output
-
-        def __len__(self):
-            return math.ceil(len(self.data_index) / self.batch_size)
-
-    dataset = CustomDataset(range(32 * state.num_processes))
-    sampler = CustomBatchSampler(len(dataset), batch_size=8)
-    dl = DataLoader(dataset, batch_sampler=sampler)
-    dl = prepare_data_loader(dl, state.device, state.num_processes, state.process_index)
-    # We need just ensure that `dl.batch_sampler` (or `dl.batch_sampler.batch_sampler` is indeed the old batch sampler
-    if hasattr(dl.batch_sampler, "batch_sampler"):
-        assert isinstance(
-            dl.batch_sampler.batch_sampler, CustomBatchSampler
-        ), "Custom sampler was changed after calling `prepare_data_loader`"
-    else:
-        assert isinstance(
-            dl.batch_sampler, CustomBatchSampler
-        ), "Custom sampler was changed after calling `prepare_data_loader`"
-
-
-def mock_training(length, batch_size, generator):
-    set_seed(42)
-    generator.manual_seed(42)
-    train_set = RegressionDataset(length=length, seed=42)
-
-    # The SeedableRandomSampler is needed during distributed setups
-    # for full reproducability across processes with the `DataLoader`
-    sampler = SeedableRandomSampler(
-        generator=generator,
-        data_source=train_set,
-        num_samples=len(train_set),
-    )
-    train_dl = DataLoader(train_set, batch_size=batch_size, sampler=sampler)
-    model = RegressionModel()
-    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
-    for epoch in range(3):
-        for batch in train_dl:
-            model.zero_grad()
-            output = model(batch["x"])
-            loss = torch.nn.functional.mse_loss(output, batch["y"])
-            loss.backward()
-            optimizer.step()
-    return train_set, model
-
-
-def training_check():
-    state = AcceleratorState()
-    generator = torch.Generator()
-    batch_size = 8
-    length = batch_size * 4 * state.num_processes
-
-    train_set, old_model = mock_training(length, batch_size * state.num_processes, generator)
-    assert are_the_same_tensors(old_model.a), "Did not obtain the same model on both processes."
-    assert are_the_same_tensors(old_model.b), "Did not obtain the same model on both processes."
-
-    accelerator = Accelerator()
-    train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)
-    model = RegressionModel()
-    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
-
-    train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)
-    set_seed(42)
-    generator.manual_seed(42)
-    for epoch in range(3):
-        for batch in train_dl:
-            model.zero_grad()
-            output = model(batch["x"])
-            loss = torch.nn.functional.mse_loss(output, batch["y"])
-            accelerator.backward(loss)
-            optimizer.step()
-
-    model = accelerator.unwrap_model(model).cpu()
-    assert torch.allclose(old_model.a, model.a), "Did not obtain the same model on CPU or distributed training."
-    assert torch.allclose(old_model.b, model.b), "Did not obtain the same model on CPU or distributed training."
-
-    accelerator.print("Training yielded the same results on one CPU or distributed setup with no batch split.")
-
-    accelerator = Accelerator(split_batches=True)
-    train_dl = DataLoader(train_set, batch_size=batch_size * state.num_processes, shuffle=True, generator=generator)
-    model = RegressionModel()
-    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
-
-    train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)
-    set_seed(42)
-    generator.manual_seed(42)
-    for _ in range(3):
-        for batch in train_dl:
-            model.zero_grad()
-            output = model(batch["x"])
-            loss = torch.nn.functional.mse_loss(output, batch["y"])
-            accelerator.backward(loss)
-            optimizer.step()
-
-    model = accelerator.unwrap_model(model).cpu()
-    assert torch.allclose(old_model.a, model.a), "Did not obtain the same model on CPU or distributed training."
-    assert torch.allclose(old_model.b, model.b), "Did not obtain the same model on CPU or distributed training."
-
-    accelerator.print("Training yielded the same results on one CPU or distributes setup with batch split.")
-
-    if torch.cuda.is_available() or is_npu_available():
-        # Mostly a test that FP16 doesn't crash as the operation inside the model is not converted to FP16
-        print("FP16 training check.")
-        AcceleratorState._reset_state()
-        accelerator = Accelerator(mixed_precision="fp16")
-        train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)
-        model = RegressionModel()
-        optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
-
-        train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)
-        set_seed(42)
-        generator.manual_seed(42)
-        for _ in range(3):
-            for batch in train_dl:
-                model.zero_grad()
-                output = model(batch["x"])
-                loss = torch.nn.functional.mse_loss(output, batch["y"])
-                accelerator.backward(loss)
-                optimizer.step()
-
-        model = accelerator.unwrap_model(model).cpu()
-        assert torch.allclose(old_model.a, model.a), "Did not obtain the same model on CPU or distributed training."
-        assert torch.allclose(old_model.b, model.b), "Did not obtain the same model on CPU or distributed training."
-
-    if torch.cuda.is_available():
-        # Mostly a test that model.forward will have autocast when running unwrap_model(model, keep_fp32_wrapper=True)
-        print("Keep fp32 wrapper check.")
-        AcceleratorState._reset_state()
-        accelerator = Accelerator(mixed_precision="fp16")
-
-        model = torch.nn.Linear(2, 4)
-        model = accelerator.prepare(model)
-        model_with_fp32_wrapper = accelerator.unwrap_model(model, keep_fp32_wrapper=True)
-
-        # Run forward with fp16 as input.
-        # When the model is with mixed precision wrapper, no error will be raised.
-        input_tensor = torch.Tensor([1, 2]).to(dtype=torch.float16, device=accelerator.device)
-        output = model_with_fp32_wrapper(input_tensor)
-
-    # BF16 support is only for CPU + TPU, and some GPU
-    if is_bf16_available():
-        # Mostly a test that BF16 doesn't crash as the operation inside the model is not converted to BF16
-        print("BF16 training check.")
-        AcceleratorState._reset_state()
-        accelerator = Accelerator(mixed_precision="bf16")
-        train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)
-        model = RegressionModel()
-        optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
-
-        train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)
-        set_seed(42)
-        generator.manual_seed(42)
-        for _ in range(3):
-            for batch in train_dl:
-                model.zero_grad()
-                output = model(batch["x"])
-                loss = torch.nn.functional.mse_loss(output, batch["y"])
-                accelerator.backward(loss)
-                optimizer.step()
-
-        model = accelerator.unwrap_model(model).cpu()
-        assert torch.allclose(old_model.a, model.a), "Did not obtain the same model on CPU or distributed training."
-        assert torch.allclose(old_model.b, model.b), "Did not obtain the same model on CPU or distributed training."
-
-    # IPEX support is only for CPU
-    if is_ipex_available():
-        print("ipex BF16 training check.")
-        AcceleratorState._reset_state()
-        accelerator = Accelerator(mixed_precision="bf16", cpu=True)
-        train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)
-        model = RegressionModel()
-        optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
-
-        train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)
-        set_seed(42)
-        generator.manual_seed(42)
-        for _ in range(3):
-            for batch in train_dl:
-                model.zero_grad()
-                output = model(batch["x"])
-                loss = torch.nn.functional.mse_loss(output, batch["y"])
-                accelerator.backward(loss)
-                optimizer.step()
-
-        model = accelerator.unwrap_model(model).cpu()
-        assert torch.allclose(old_model.a, model.a), "Did not obtain the same model on CPU or distributed training."
-        assert torch.allclose(old_model.b, model.b), "Did not obtain the same model on CPU or distributed training."
-
-    # XPU support is only for XPU
-    if is_xpu_available():
-        print("xpu BF16 training check.")
-        AcceleratorState._reset_state()
-        accelerator = Accelerator(mixed_precision="bf16", cpu=False)
-        train_dl = DataLoader(train_set, batch_size=batch_size, shuffle=True, generator=generator)
-        model = RegressionModel()
-        optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
-
-        train_dl, model, optimizer = accelerator.prepare(train_dl, model, optimizer)
-        set_seed(42)
-        generator.manual_seed(42)
-        for _ in range(3):
-            for batch in train_dl:
-                model.zero_grad()
-                output = model(batch["x"])
-                loss = torch.nn.functional.mse_loss(output, batch["y"])
-                accelerator.backward(loss)
-                optimizer.step()
-
-        model = accelerator.unwrap_model(model).cpu()
-        assert torch.allclose(old_model.a, model.a), "Did not obtain the same model on XPU or distributed training."
-        assert torch.allclose(old_model.b, model.b), "Did not obtain the same model on XPU or distributed training."
-
-
-def test_split_between_processes_list():
-    state = AcceleratorState()
-    data = list(range(0, 2 * state.num_processes))
-    with state.split_between_processes(data) as results:
-        assert (
-            len(results) == 2
-        ), f"Each process did not have two items. Process index: {state.process_index}; Length: {len(results)}"
-
-    data = list(range(0, (3 * state.num_processes) - 1))
-    with state.split_between_processes(data, apply_padding=True) as results:
-        if state.is_last_process:
-            # Test that the last process gets the extra item(s)
-            num_samples_per_device = math.ceil(len(data) / state.num_processes)
-            assert (
-                len(results) == num_samples_per_device
-            ), f"Last process did not get the extra item(s). Process index: {state.process_index}; Length: {len(results)}"
-    state.wait_for_everyone()
-
-
-def test_split_between_processes_nested_dict():
-    state = AcceleratorState()
-    a = [1, 2, 3, 4, 5, 6, 7, 8]
-    b = ["a", "b", "c", "d", "e", "f", "g", "h"]
-    c = torch.tensor([1, 2, 3, 4, 5, 6, 7, 8])
-    if state.num_processes in (1, 2, 4):
-        data = {"a": a, "b": b, "c": c}
-        data_copy = deepcopy(data)
-        with state.split_between_processes(data) as results:
-            if state.process_index == 0:
-                assert results["a"] == data_copy["a"][: 8 // state.num_processes]
-            elif state.num_processes == 2:
-                assert results["a"] == data_copy["a"][4:]
-            elif state.process_index == 3:
-                # We return a list each time
-                assert results["a"] == data_copy["a"][-2:], f'Expected: {data_copy["a"][-2]}, Actual: {results["a"]}'
-            if state.process_index == 0:
-                assert results["b"] == data_copy["b"][: 8 // state.num_processes]
-            elif state.num_processes == 2:
-                assert results["b"] == data_copy["b"][4:]
-            elif state.process_index == 3:
-                assert results["b"] == data_copy["b"][-2:]
-            if state.process_index == 0:
-                assert torch.allclose(
-                    results["c"], data_copy["c"][: 8 // state.num_processes]
-                ), f"Did not obtain expected values on process 0, expected `{data['c'][:8 // state.num_processes]}`, received: {results['c']}"
-            elif state.num_processes == 2:
-                assert torch.allclose(
-                    results["c"], data_copy["c"][4:]
-                ), f"Did not obtain expected values on process 2, expected `{data['c'][4:]}`, received: {results['c']}"
-            elif state.process_index == 3:
-                assert torch.allclose(
-                    results["c"], data_copy["c"][-2:]
-                ), f"Did not obtain expected values on process 4, expected `{data['c'][-2:]}`, received: {results['c']}"
-
-    state.wait_for_everyone()
-
-
-def test_split_between_processes_tensor():
-    state = AcceleratorState()
-    if state.num_processes > 1:
-        data = torch.tensor([[0, 1, 2, 3], [4, 5, 6, 7]]).to(state.device)
-        with state.split_between_processes(data) as results:
-            if state.process_index == 0:
-                assert torch.allclose(results, torch.tensor([0, 1, 2, 3]).to(state.device))
-            else:
-                assert torch.allclose(results, torch.tensor([4, 5, 6, 7]).to(state.device))
-    state.wait_for_everyone()
-
-
-def test_trigger():
-    accelerator = Accelerator()
-    # should start with being false
-    assert accelerator.check_trigger() is False
-
-    # set a breakpoint on the main process
-    if accelerator.is_main_process:
-        accelerator.set_trigger()
-
-    # check it's been activated across all processes
-    # calls `all_reduce` and triggers a sync
-    assert accelerator.check_trigger() is True
-
-    # check it's been reset after the sync
-    assert accelerator.check_trigger() is False
-
-
-def main():
-    accelerator = Accelerator()
-    state = accelerator.state
-    if state.local_process_index == 0:
-        print("**Initialization**")
-    init_state_check()
-    state.wait_for_everyone()
-
-    if state.distributed_type == DistributedType.MULTI_GPU:
-        num_processes_per_node = torch.cuda.device_count()
-    else:
-        num_processes_per_node = state.num_processes
-
-    # We only run this test on non-multinode
-    if num_processes_per_node == state.num_processes:
-        if state.process_index == 0:
-            print("\n**Test process execution**")
-        process_execution_check()
-
-        if state.process_index == 0:
-            print("\n**Test split between processes as a list**")
-        test_split_between_processes_list()
-
-        if state.process_index == 0:
-            print("\n**Test split between processes as a dict**")
-        test_split_between_processes_nested_dict()
-
-        if state.process_index == 0:
-            print("\n**Test split between processes as a tensor**")
-        test_split_between_processes_tensor()
-
-    if state.local_process_index == 0:
-        print("\n**Test random number generator synchronization**")
-    rng_sync_check()
-
-    if state.local_process_index == 0:
-        print("\n**DataLoader integration test**")
-    dl_preparation_check()
-    if state.distributed_type != DistributedType.TPU:
-        central_dl_preparation_check()
-    custom_sampler_check()
-
-    # Trainings are not exactly the same in DeepSpeed and CPU mode
-    if state.distributed_type == DistributedType.DEEPSPEED:
-        return
-
-    if state.local_process_index == 0:
-        print("\n**Training integration test**")
-    training_check()
-
-    if state.local_process_index == 0:
-        print("\n**Breakpoint trigger test**")
-    test_trigger()
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/scripts/test_sync.py

@@ -1,355 +0,0 @@
-
-
-from copy import deepcopy
-
-import torch
-import torch.nn.functional as F
-from torch.optim import AdamW
-from torch.optim.lr_scheduler import LambdaLR
-from torch.utils.data import DataLoader
-
-from accelerate.accelerator import Accelerator
-from accelerate.state import GradientState
-from accelerate.test_utils import RegressionDataset, RegressionModel
-from accelerate.utils import DistributedType, is_torch_version, set_seed
-
-
-def check_model_parameters(model_a, model_b, did_step, iteration):
-    for param, grad_param in zip(model_a.parameters(), model_b.parameters()):
-        if not param.requires_grad:
-            continue
-        if not did_step:
-            # Grads should not be in sync
-            assert (
-                torch.allclose(param.grad, grad_param.grad) is False
-            ), f"Gradients in sync when they should not be at iteration {iteration}:\nmodel_a grad ({param.grad}) == model_b grad ({grad_param.grad})"
-        else:
-            # Grads should be in sync
-            assert (
-                torch.allclose(param.grad, grad_param.grad) is True
-            ), f"Gradients not in sync when they should be at iteration {iteration}:\nmodel_a grad ({param.grad}) != model_b grad ({grad_param.grad})"
-
-
-def step_model(model, input, target, accelerator, do_backward=True):
-    model.train()
-    output = model(input)
-    loss = F.mse_loss(output, target.to(output.device))
-    if not do_backward:
-        loss /= accelerator.gradient_accumulation_steps
-        loss.backward()
-    else:
-        accelerator.backward(loss)
-
-
-def get_training_setup(accelerator, sched=False):
-    "Returns everything needed to perform basic training"
-    set_seed(42)
-    model = RegressionModel()
-    ddp_model = deepcopy(model)
-    dset = RegressionDataset(length=80)
-    dataloader = DataLoader(dset, batch_size=16)
-    model.to(accelerator.device)
-    if sched:
-        opt = AdamW(params=model.parameters(), lr=1e-3)
-        ddp_opt = AdamW(params=ddp_model.parameters(), lr=1e-3)
-        sched = LambdaLR(opt, lr_lambda=lambda epoch: epoch**0.65)
-        ddp_sched = LambdaLR(ddp_opt, lr_lambda=lambda epoch: epoch**0.65)
-    # Make a copy of `model`
-    if sched:
-        ddp_model, ddp_opt, ddp_sched, dataloader = accelerator.prepare(ddp_model, ddp_opt, ddp_sched, dataloader)
-    else:
-        ddp_model, dataloader = accelerator.prepare(ddp_model, dataloader)
-    if sched:
-        return (model, opt, sched, dataloader, ddp_model, ddp_opt, ddp_sched)
-    return model, ddp_model, dataloader
-
-
-def test_noop_sync(accelerator):
-    # Test when on a single CPU or GPU that the context manager does nothing
-    model, ddp_model, dataloader = get_training_setup(accelerator)
-    # Use a single batch
-    ddp_input, ddp_target = next(iter(dataloader)).values()
-    for iteration in range(3):
-        # Gather the distributed inputs and targs for the base model
-        input, target = accelerator.gather((ddp_input, ddp_target))
-        input, target = input.to(accelerator.device), target.to(accelerator.device)
-        # Perform our initial ground truth step in non "DDP"
-        step_model(model, input, target, accelerator)
-        # Do "gradient accumulation" (noop)
-        if iteration % 2 == 0:
-            # Accumulate grads locally
-            with accelerator.no_sync(ddp_model):
-                step_model(ddp_model, ddp_input, ddp_target, accelerator)
-        else:
-            # Sync grads
-            step_model(ddp_model, ddp_input, ddp_target, accelerator)
-
-        # Since `no_sync` is a noop, `ddp_model` and `model` grads should always be in sync
-        check_model_parameters(model, ddp_model, True, iteration)
-        for param, ddp_param in zip(model.parameters(), ddp_model.parameters()):
-            if not param.requires_grad:
-                continue
-            assert torch.allclose(
-                param.grad, ddp_param.grad
-            ), f"Gradients not in sync when they should be:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})"
-
-        # Shuffle ddp_input on each iteration
-        torch.manual_seed(1337 + iteration)
-        ddp_input = ddp_input[torch.randperm(len(ddp_input))]
-
-
-def test_distributed_sync(accelerator):
-    # Test on distributed setup that context manager behaves properly
-    model, ddp_model, dataloader = get_training_setup(accelerator)
-    # Use a single batch
-    ddp_input, ddp_target = next(iter(dataloader)).values()
-    for iteration in range(3):
-        # Gather the distributed inputs and targs for the base model
-        input, target = accelerator.gather((ddp_input, ddp_target))
-        input, target = input.to(accelerator.device), target.to(accelerator.device)
-        # Perform our initial ground truth step in non "DDP"
-        step_model(model, input, target, accelerator)
-        # Do "gradient accumulation" (noop)
-        if iteration % 2 == 0:
-            # Accumulate grads locally
-            with accelerator.no_sync(ddp_model):
-                step_model(ddp_model, ddp_input, ddp_target, accelerator)
-        else:
-            # Sync grads
-            step_model(ddp_model, ddp_input, ddp_target, accelerator)
-
-        # DDP model and model should only be in sync when not (iteration % 2 == 0)
-        for param, ddp_param in zip(model.parameters(), ddp_model.parameters()):
-            if not param.requires_grad:
-                continue
-            if iteration % 2 == 0:
-                # Grads should not be in sync
-                assert (
-                    torch.allclose(param.grad, ddp_param.grad) is False
-                ), f"Gradients in sync when they should not be:\nModel grad ({param.grad}) == DDP grad ({ddp_param.grad})"
-            else:
-                # Grads should be in sync
-                assert (
-                    torch.allclose(param.grad, ddp_param.grad) is True
-                ), f"Gradients not in sync when they should be:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})"
-
-        # Shuffle ddp_input on each iteration
-        torch.manual_seed(1337 + iteration)
-        ddp_input = ddp_input[torch.randperm(len(ddp_input))]
-
-
-def test_distributed_sync_multiple_fwd(accelerator):
-    # Test on distributed setup that context manager behaves properly when used with multiple forwards followed by multiple backwards
-    model, ddp_model, dataloader = get_training_setup(accelerator)
-    # Do multiple forwards
-    losses = []
-    num_iterations = 3
-    for iteration in range(num_iterations):
-        ddp_input, ddp_target = next(iter(dataloader)).values()
-
-        # Gather the distributed inputs and targs for the base model
-        input, target = accelerator.gather((ddp_input, ddp_target))
-        input, target = input.to(accelerator.device), target.to(accelerator.device)
-
-        # Perform our initial ground truth step in non "DDP"
-        step_model(model, input, target, accelerator)
-
-        # Accumulate grads locally
-        with accelerator.no_sync(ddp_model):
-            ddp_output = ddp_model(ddp_input)
-            loss = F.mse_loss(ddp_output, ddp_target.to(ddp_output.device))
-            losses.append(loss)
-
-    # Do multiple backwards and sync only at the last backward
-    for iteration in range(num_iterations):
-        loss = losses[iteration]
-
-        if iteration < num_iterations - 1:
-            # Accumulate grads locally
-            accelerator.backward(loss)
-
-            # DDP model and model should only be in sync after last backward
-            for param, ddp_param in zip(model.parameters(), ddp_model.parameters()):
-                if not param.requires_grad:
-                    continue
-                # Grads should not be in sync
-                assert (
-                    torch.allclose(param.grad, ddp_param.grad) is False
-                ), f"Gradients in sync when they should not be:\nModel grad ({param.grad}) == DDP grad ({ddp_param.grad})"
-
-        else:
-            # Sync grads if last backward
-            with accelerator.trigger_sync_in_backward(ddp_model):
-                accelerator.backward(loss)
-
-            # DDP model and model should only be in sync after last backward
-            for param, ddp_param in zip(model.parameters(), ddp_model.parameters()):
-                if not param.requires_grad:
-                    continue
-                # Grads should be in sync
-                assert (
-                    torch.allclose(param.grad, ddp_param.grad) is True
-                ), f"Gradients not in sync when they should be:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})"
-
-
-def test_gradient_accumulation(split_batches=False, dispatch_batches=False):
-    accelerator = Accelerator(
-        split_batches=split_batches, dispatch_batches=dispatch_batches, gradient_accumulation_steps=2
-    )
-    # Test that context manager behaves properly
-    model, ddp_model, dataloader = get_training_setup(accelerator)
-    for iteration, batch in enumerate(dataloader):
-        ddp_input, ddp_target = batch.values()
-        # Gather the distributed inputs and targs for the base model
-        input, target = accelerator.gather((ddp_input, ddp_target))
-        input, target = input.to(accelerator.device), target.to(accelerator.device)
-        # Perform our initial ground truth step in non "DDP"
-        step_model(model, input, target, accelerator, False)
-        # Do "gradient accumulation" (noop)
-        with accelerator.accumulate(ddp_model):
-            step_model(ddp_model, ddp_input, ddp_target, accelerator)
-
-        # DDP model and model should only be in sync when not (iteration % 2 == 0)
-        for param, ddp_param in zip(model.parameters(), ddp_model.parameters()):
-            if not param.requires_grad:
-                continue
-            if ((iteration + 1) % 2 == 0) or (iteration == len(dataloader) - 1):
-                # Grads should be in sync
-                assert (
-                    torch.allclose(param.grad, ddp_param.grad) is True
-                ), f"Gradients not in sync when they should be at iteration {iteration}:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})"
-            else:
-                # Grads should not be in sync
-                assert (
-                    torch.allclose(param.grad, ddp_param.grad) is False
-                ), f"Gradients in sync when they should not be at iteration {iteration}:\nModel grad ({param.grad}) == DDP grad ({ddp_param.grad})"
-
-        # Shuffle ddp_input on each iteration
-        torch.manual_seed(1337 + iteration)
-        ddp_input = ddp_input[torch.randperm(len(ddp_input))]
-    GradientState._reset_state()
-
-
-def test_gradient_accumulation_with_opt_and_scheduler(split_batches=False, dispatch_batches=False):
-    accelerator = Accelerator(
-        split_batches=split_batches, dispatch_batches=dispatch_batches, gradient_accumulation_steps=2
-    )
-    # Test that context manager behaves properly
-    model, opt, sched, dataloader, ddp_model, ddp_opt, ddp_sched = get_training_setup(accelerator, True)
-    for iteration, batch in enumerate(dataloader):
-        ddp_input, ddp_target = batch.values()
-        # Gather the distributed inputs and targs for the base model
-        input, target = accelerator.gather((ddp_input, ddp_target))
-        input, target = input.to(accelerator.device), target.to(accelerator.device)
-        # Perform our initial ground truth step in non "DDP"
-        model.train()
-        ddp_model.train()
-        step_model(model, input, target, accelerator, False)
-        opt.step()
-
-        if ((iteration + 1) % 2 == 0) or ((iteration + 1) == len(dataloader)):
-            if split_batches:
-                sched.step()
-            else:
-                for _ in range(accelerator.num_processes):
-                    sched.step()
-        opt.zero_grad()
-        # Perform gradient accumulation under wrapper
-        with accelerator.accumulate(ddp_model):
-            step_model(ddp_model, ddp_input, ddp_target, accelerator)
-            ddp_opt.step()
-            ddp_sched.step()
-            ddp_opt.zero_grad()
-
-        # Learning rates should be the same
-        assert (
-            opt.param_groups[0]["lr"] == ddp_opt.param_groups[0]["lr"]
-        ), f'Learning rates found in each optimizer did not align\nopt: {opt.param_groups[0]["lr"]}\nDDP opt: {ddp_opt.param_groups[0]["lr"]}\n'
-        did_step = (((iteration + 1) % 2) == 0) or ((iteration + 1) == len(dataloader))
-        if accelerator.num_processes > 1:
-            check_model_parameters(model, ddp_model, did_step, iteration)
-        # Shuffle ddp_input on each iteration
-        torch.manual_seed(1337 + iteration)
-    GradientState._reset_state()
-
-
-def test_dataloader_break():
-    accelerator = Accelerator()
-
-    first_dset = RegressionDataset(length=80)
-    first_dataloader = DataLoader(first_dset, batch_size=16)
-    second_dset = RegressionDataset(length=96)
-    second_dataloader = DataLoader(second_dset, batch_size=16)
-    first_dataloader, second_dataloader = accelerator.prepare(first_dataloader, second_dataloader)
-    assert accelerator.gradient_state.active_dataloader is None
-    for iteration, _ in enumerate(first_dataloader):
-        assert id(accelerator.gradient_state.active_dataloader) == id(first_dataloader)
-        if iteration < len(first_dataloader) - 1:
-            assert not accelerator.gradient_state.end_of_dataloader
-            if iteration == 1:
-                for batch_num, _ in enumerate(second_dataloader):
-                    assert id(accelerator.gradient_state.active_dataloader) == id(second_dataloader)
-                    if batch_num < len(second_dataloader) - 1:
-                        assert not accelerator.gradient_state.end_of_dataloader
-                    else:
-                        assert accelerator.gradient_state.end_of_dataloader
-        else:
-            assert accelerator.gradient_state.end_of_dataloader
-    assert accelerator.gradient_state.active_dataloader is None
-
-
-def main():
-    accelerator = Accelerator()
-    state = accelerator.state
-    if state.local_process_index == 0:
-        print("**Test `accumulate` gradient accumulation with dataloader break**")
-    test_dataloader_break()
-    if state.distributed_type == DistributedType.NO:
-        if state.local_process_index == 0:
-            print("**Test NOOP `no_sync` context manager**")
-        test_noop_sync(accelerator)
-    if state.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_NPU, DistributedType.MULTI_CPU):
-        if state.local_process_index == 0:
-            print("**Test Distributed `no_sync` context manager**")
-        test_distributed_sync(accelerator)
-        if state.local_process_index == 0:
-            print("**Test Distributed `no_sync` context manager with multiple forwards**")
-        test_distributed_sync_multiple_fwd(accelerator)
-    if state.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_NPU):
-        for split_batch in [True, False]:
-            for dispatch_batches in [True, False]:
-                if state.local_process_index == 0:
-                    print(
-                        "**Test `accumulate` gradient accumulation, ",
-                        f"`split_batches={split_batch}` and `dispatch_batches={dispatch_batches}`**",
-                    )
-                test_gradient_accumulation(split_batch, dispatch_batches)
-
-    # Currently will break on torch 2.0 +, need to investigate why
-    if is_torch_version("<", "2.0") or state.distributed_type == DistributedType.NO:
-        if state.local_process_index == 0:
-            print(
-                "**Test `accumulate` gradient accumulation with optimizer and scheduler, ",
-                "`split_batches=False`, `dispatch_batches=False`**",
-            )
-        test_gradient_accumulation_with_opt_and_scheduler()
-        if state.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_NPU):
-            for split_batch in [True, False]:
-                for dispatch_batches in [True, False]:
-                    if not split_batch and not dispatch_batches:
-                        continue
-                    if state.local_process_index == 0:
-                        print(
-                            "**Test `accumulate` gradient accumulation with optimizer and scheduler, ",
-                            f"`split_batches={split_batch}` and `dispatch_batches={dispatch_batches}`**",
-                        )
-                    test_gradient_accumulation_with_opt_and_scheduler(split_batch, dispatch_batches)
-
-
-def _mp_fn(index):
-    # For xla_spawn (TPUs)
-    main()
-
-
-if __name__ == "__main__":
-    main()

src/test_utils/testing.py

@@ -1,501 +0,0 @@
-
-
-import asyncio
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-import unittest
-from contextlib import contextmanager
-from functools import partial
-from pathlib import Path
-from typing import List, Union
-from unittest import mock
-
-import torch
-
-from ..state import AcceleratorState, PartialState
-from ..utils import (
-    gather,
-    is_bnb_available,
-    is_clearml_available,
-    is_comet_ml_available,
-    is_cuda_available,
-    is_datasets_available,
-    is_deepspeed_available,
-    is_dvclive_available,
-    is_mps_available,
-    is_npu_available,
-    is_pandas_available,
-    is_tensorboard_available,
-    is_timm_available,
-    is_torch_version,
-    is_tpu_available,
-    is_transformers_available,
-    is_wandb_available,
-    is_xpu_available,
-    str_to_bool,
-)
-
-
-def get_backend():
-    if is_cuda_available():
-        return "cuda", torch.cuda.device_count()
-    elif is_mps_available():
-        return "mps", 1
-    elif is_npu_available():
-        return "npu", torch.npu.device_count()
-    elif is_xpu_available():
-        return "xpu", torch.xpu.device_count()
-    else:
-        return "cpu", 1
-
-
-torch_device, device_count = get_backend()
-
-
-def parse_flag_from_env(key, default=False):
-    try:
-        value = os.environ[key]
-    except KeyError:
-        # KEY isn't set, default to `default`.
-        _value = default
-    else:
-        # KEY is set, convert it to True or False.
-        try:
-            _value = str_to_bool(value)
-        except ValueError:
-            # More values are supported, but let's keep the message simple.
-            raise ValueError(f"If set, {key} must be yes or no.")
-    return _value
-
-
-_run_slow_tests = parse_flag_from_env("RUN_SLOW", default=False)
-
-
-def skip(test_case):
-    "Decorator that skips a test unconditionally"
-    return unittest.skip("Test was skipped")(test_case)
-
-
-def slow(test_case):
-    """
-    Decorator marking a test as slow. Slow tests are skipped by default. Set the RUN_SLOW environment variable to a
-    truthy value to run them.
-    """
-    return unittest.skipUnless(_run_slow_tests, "test is slow")(test_case)
-
-
-def require_cpu(test_case):
-    """
-    Decorator marking a test that must be only ran on the CPU. These tests are skipped when a GPU is available.
-    """
-    return unittest.skipUnless(torch_device == "cpu", "test requires only a CPU")(test_case)
-
-
-def require_non_cpu(test_case):
-    """
-    Decorator marking a test that requires a hardware accelerator backend. These tests are skipped when there are no
-    hardware accelerator available.
-    """
-    return unittest.skipUnless(torch_device != "cpu", "test requires a GPU")(test_case)
-
-
-def require_cuda(test_case):
-    """
-    Decorator marking a test that requires CUDA. These tests are skipped when there are no GPU available.
-    """
-    return unittest.skipUnless(is_cuda_available(), "test requires a GPU")(test_case)
-
-
-def require_xpu(test_case):
-    """
-    Decorator marking a test that requires XPU. These tests are skipped when there are no XPU available.
-    """
-    return unittest.skipUnless(is_xpu_available(), "test requires a XPU")(test_case)
-
-
-def require_mps(test_case):
-    """
-    Decorator marking a test that requires MPS backend. These tests are skipped when torch doesn't support `mps`
-    backend.
-    """
-    return unittest.skipUnless(is_mps_available(), "test requires a `mps` backend support in `torch`")(test_case)
-
-
-def require_huggingface_suite(test_case):
-    """
-    Decorator marking a test that requires transformers and datasets. These tests are skipped when they are not.
-    """
-    return unittest.skipUnless(
-        is_transformers_available() and is_datasets_available(), "test requires the Hugging Face suite"
-    )(test_case)
-
-
-def require_transformers(test_case):
-    """
-    Decorator marking a test that requires transformers. These tests are skipped when they are not.
-    """
-    return unittest.skipUnless(is_transformers_available(), "test requires the transformers library")(test_case)
-
-
-def require_timm(test_case):
-    """
-    Decorator marking a test that requires transformers. These tests are skipped when they are not.
-    """
-    return unittest.skipUnless(is_timm_available(), "test requires the timm library")(test_case)
-
-
-def require_bnb(test_case):
-    """
-    Decorator marking a test that requires bitsandbytes. These tests are skipped when they are not.
-    """
-    return unittest.skipUnless(is_bnb_available(), "test requires the bitsandbytes library")(test_case)
-
-
-def require_tpu(test_case):
-    """
-    Decorator marking a test that requires TPUs. These tests are skipped when there are no TPUs available.
-    """
-    return unittest.skipUnless(is_tpu_available(), "test requires TPU")(test_case)
-
-
-def require_single_device(test_case):
-    """
-    Decorator marking a test that requires a single device. These tests are skipped when there is no hardware
-    accelerator available or number of devices is more than one.
-    """
-    return unittest.skipUnless(torch_device != "cpu" and device_count == 1, "test requires a hardware accelerator")(
-        test_case
-    )
-
-
-def require_single_gpu(test_case):
-    """
-    Decorator marking a test that requires CUDA on a single GPU. These tests are skipped when there are no GPU
-    available or number of GPUs is more than one.
-    """
-    return unittest.skipUnless(torch.cuda.device_count() == 1, "test requires a GPU")(test_case)
-
-
-def require_single_xpu(test_case):
-    """
-    Decorator marking a test that requires CUDA on a single XPU. These tests are skipped when there are no XPU
-    available or number of xPUs is more than one.
-    """
-    return unittest.skipUnless(torch.xpu.device_count() == 1, "test requires a XPU")(test_case)
-
-
-def require_multi_device(test_case):
-    """
-    Decorator marking a test that requires a multi-device setup. These tests are skipped on a machine without multiple
-    devices.
-    """
-    return unittest.skipUnless(device_count > 1, "test requires multiple hardware accelerators")(test_case)
-
-
-def require_multi_gpu(test_case):
-    """
-    Decorator marking a test that requires a multi-GPU setup. These tests are skipped on a machine without multiple
-    GPUs.
-    """
-    return unittest.skipUnless(torch.cuda.device_count() > 1, "test requires multiple GPUs")(test_case)
-
-
-def require_multi_xpu(test_case):
-    """
-    Decorator marking a test that requires a multi-XPU setup. These tests are skipped on a machine without multiple
-    XPUs.
-    """
-    return unittest.skipUnless(torch.xpu.device_count() > 1, "test requires multiple XPUs")(test_case)
-
-
-def require_deepspeed(test_case):
-    """
-    Decorator marking a test that requires DeepSpeed installed. These tests are skipped when DeepSpeed isn't installed
-    """
-    return unittest.skipUnless(is_deepspeed_available(), "test requires DeepSpeed")(test_case)
-
-
-def require_fsdp(test_case):
-    """
-    Decorator marking a test that requires FSDP installed. These tests are skipped when FSDP isn't installed
-    """
-    return unittest.skipUnless(is_torch_version(">=", "1.12.0"), "test requires torch version >= 1.12.0")(test_case)
-
-
-def require_torch_min_version(test_case=None, version=None):
-    """
-    Decorator marking that a test requires a particular torch version to be tested. These tests are skipped when an
-    installed torch version is less than the required one.
-    """
-    if test_case is None:
-        return partial(require_torch_min_version, version=version)
-    return unittest.skipUnless(is_torch_version(">=", version), f"test requires torch version >= {version}")(test_case)
-
-
-def require_tensorboard(test_case):
-    """
-    Decorator marking a test that requires tensorboard installed. These tests are skipped when tensorboard isn't
-    installed
-    """
-    return unittest.skipUnless(is_tensorboard_available(), "test requires Tensorboard")(test_case)
-
-
-def require_wandb(test_case):
-    """
-    Decorator marking a test that requires wandb installed. These tests are skipped when wandb isn't installed
-    """
-    return unittest.skipUnless(is_wandb_available(), "test requires wandb")(test_case)
-
-
-def require_comet_ml(test_case):
-    """
-    Decorator marking a test that requires comet_ml installed. These tests are skipped when comet_ml isn't installed
-    """
-    return unittest.skipUnless(is_comet_ml_available(), "test requires comet_ml")(test_case)
-
-
-def require_clearml(test_case):
-    """
-    Decorator marking a test that requires clearml installed. These tests are skipped when clearml isn't installed
-    """
-    return unittest.skipUnless(is_clearml_available(), "test requires clearml")(test_case)
-
-
-def require_dvclive(test_case):
-    """
-    Decorator marking a test that requires dvclive installed. These tests are skipped when dvclive isn't installed
-    """
-    return unittest.skipUnless(is_dvclive_available(), "test requires dvclive")(test_case)
-
-
-def require_pandas(test_case):
-    """
-    Decorator marking a test that requires pandas installed. These tests are skipped when pandas isn't installed
-    """
-    return unittest.skipUnless(is_pandas_available(), "test requires pandas")(test_case)
-
-
-_atleast_one_tracker_available = (
-    any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available()
-)
-
-
-def require_trackers(test_case):
-    """
-    Decorator marking that a test requires at least one tracking library installed. These tests are skipped when none
-    are installed
-    """
-    return unittest.skipUnless(
-        _atleast_one_tracker_available,
-        "test requires at least one tracker to be available and for `comet_ml` to not be installed",
-    )(test_case)
-
-
-class TempDirTestCase(unittest.TestCase):
-    """
-    A TestCase class that keeps a single `tempfile.TemporaryDirectory` open for the duration of the class, wipes its
-    data at the start of a test, and then destroyes it at the end of the TestCase.
-
-    Useful for when a class or API requires a single constant folder throughout it's use, such as Weights and Biases
-
-    The temporary directory location will be stored in `self.tmpdir`
-    """
-
-    clear_on_setup = True
-
-    @classmethod
-    def setUpClass(cls):
-        "Creates a `tempfile.TemporaryDirectory` and stores it in `cls.tmpdir`"
-        cls.tmpdir = tempfile.mkdtemp()
-
-    @classmethod
-    def tearDownClass(cls):
-        "Remove `cls.tmpdir` after test suite has finished"
-        if os.path.exists(cls.tmpdir):
-            shutil.rmtree(cls.tmpdir)
-
-    def setUp(self):
-        "Destroy all contents in `self.tmpdir`, but not `self.tmpdir`"
-        if self.clear_on_setup:
-            for path in Path(self.tmpdir).glob("**/*"):
-                if path.is_file():
-                    path.unlink()
-                elif path.is_dir():
-                    shutil.rmtree(path)
-
-
-class AccelerateTestCase(unittest.TestCase):
-    """
-    A TestCase class that will reset the accelerator state at the end of every test. Every test that checks or utilizes
-    the `AcceleratorState` class should inherit from this to avoid silent failures due to state being shared between
-    tests.
-    """
-
-    def tearDown(self):
-        super().tearDown()
-        # Reset the state of the AcceleratorState singleton.
-        AcceleratorState._reset_state()
-        PartialState._reset_state()
-
-
-class MockingTestCase(unittest.TestCase):
-    """
-    A TestCase class designed to dynamically add various mockers that should be used in every test, mimicking the
-    behavior of a class-wide mock when defining one normally will not do.
-
-    Useful when a mock requires specific information available only initialized after `TestCase.setUpClass`, such as
-    setting an environment variable with that information.
-
-    The `add_mocks` function should be ran at the end of a `TestCase`'s `setUp` function, after a call to
-    `super().setUp()` such as:
-    ```python
-    def setUp(self):
-        super().setUp()
-        mocks = mock.patch.dict(os.environ, {"SOME_ENV_VAR", "SOME_VALUE"})
-        self.add_mocks(mocks)
-    ```
-    """
-
-    def add_mocks(self, mocks: Union[mock.Mock, List[mock.Mock]]):
-        """
-        Add custom mocks for tests that should be repeated on each test. Should be called during
-        `MockingTestCase.setUp`, after `super().setUp()`.
-
-        Args:
-            mocks (`mock.Mock` or list of `mock.Mock`):
-                Mocks that should be added to the `TestCase` after `TestCase.setUpClass` has been run
-        """
-        self.mocks = mocks if isinstance(mocks, (tuple, list)) else [mocks]
-        for m in self.mocks:
-            m.start()
-            self.addCleanup(m.stop)
-
-
-def are_the_same_tensors(tensor):
-    state = AcceleratorState()
-    tensor = tensor[None].clone().to(state.device)
-    tensors = gather(tensor).cpu()
-    tensor = tensor[0].cpu()
-    for i in range(tensors.shape[0]):
-        if not torch.equal(tensors[i], tensor):
-            return False
-    return True
-
-
-class _RunOutput:
-    def __init__(self, returncode, stdout, stderr):
-        self.returncode = returncode
-        self.stdout = stdout
-        self.stderr = stderr
-
-
-async def _read_stream(stream, callback):
-    while True:
-        line = await stream.readline()
-        if line:
-            callback(line)
-        else:
-            break
-
-
-async def _stream_subprocess(cmd, env=None, stdin=None, timeout=None, quiet=False, echo=False) -> _RunOutput:
-    if echo:
-        print("\nRunning: ", " ".join(cmd))
-
-    p = await asyncio.create_subprocess_exec(
-        cmd[0],
-        *cmd[1:],
-        stdin=stdin,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-        env=env,
-    )
-
-    # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe
-    # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait
-    #
-    # If it starts hanging, will need to switch to the following code. The problem is that no data
-    # will be seen until it's done and if it hangs for example there will be no debug info.
-    # out, err = await p.communicate()
-    # return _RunOutput(p.returncode, out, err)
-
-    out = []
-    err = []
-
-    def tee(line, sink, pipe, label=""):
-        line = line.decode("utf-8").rstrip()
-        sink.append(line)
-        if not quiet:
-            print(label, line, file=pipe)
-
-    # XXX: the timeout doesn't seem to make any difference here
-    await asyncio.wait(
-        [
-            asyncio.create_task(_read_stream(p.stdout, lambda l: tee(l, out, sys.stdout, label="stdout:"))),
-            asyncio.create_task(_read_stream(p.stderr, lambda l: tee(l, err, sys.stderr, label="stderr:"))),
-        ],
-        timeout=timeout,
-    )
-    return _RunOutput(await p.wait(), out, err)
-
-
-def execute_subprocess_async(cmd, env=None, stdin=None, timeout=180, quiet=False, echo=True) -> _RunOutput:
-    loop = asyncio.get_event_loop()
-    result = loop.run_until_complete(
-        _stream_subprocess(cmd, env=env, stdin=stdin, timeout=timeout, quiet=quiet, echo=echo)
-    )
-
-    cmd_str = " ".join(cmd)
-    if result.returncode > 0:
-        stderr = "\n".join(result.stderr)
-        raise RuntimeError(
-            f"'{cmd_str}' failed with returncode {result.returncode}\n\n"
-            f"The combined stderr from workers follows:\n{stderr}"
-        )
-
-    return result
-
-
-class SubprocessCallException(Exception):
-    pass
-
-
-def run_command(command: List[str], return_stdout=False, env=None):
-    """
-    Runs `command` with `subprocess.check_output` and will potentially return the `stdout`. Will also properly capture
-    if an error occured while running `command`
-    """
-    if env is None:
-        env = os.environ.copy()
-    try:
-        output = subprocess.check_output(command, stderr=subprocess.STDOUT, env=env)
-        if return_stdout:
-            if hasattr(output, "decode"):
-                output = output.decode("utf-8")
-            return output
-    except subprocess.CalledProcessError as e:
-        raise SubprocessCallException(
-            f"Command `{' '.join(command)}` failed with the following error:\n\n{e.output.decode()}"
-        ) from e
-
-
-@contextmanager
-def assert_exception(exception_class: Exception, msg: str = None) -> bool:
-    """
-    Context manager to assert that the right `Exception` class was raised.
-
-    If `msg` is provided, will check that the message is contained in the raised exception.
-    """
-    was_ran = False
-    try:
-        yield
-        was_ran = True
-    except Exception as e:
-        assert isinstance(e, exception_class), f"Expected exception of type {exception_class} but got {type(e)}"
-        if msg is not None:
-            assert msg in str(e), f"Expected message '{msg}' to be in exception but got '{str(e)}'"
-    if was_ran:
-        raise AssertionError(f"Expected exception of type {exception_class} but ran without issue.")

src/test_utils/training.py

@@ -1,89 +0,0 @@
-
-
-import numpy as np
-import torch
-from torch.utils.data import DataLoader
-
-from accelerate.utils.dataclasses import DistributedType
-
-
-class RegressionDataset:
-    def __init__(self, a=2, b=3, length=64, seed=None):
-        rng = np.random.default_rng(seed)
-        self.length = length
-        self.x = rng.normal(size=(length,)).astype(np.float32)
-        self.y = a * self.x + b + rng.normal(scale=0.1, size=(length,)).astype(np.float32)
-
-    def __len__(self):
-        return self.length
-
-    def __getitem__(self, i):
-        return {"x": self.x[i], "y": self.y[i]}
-
-
-class RegressionModel4XPU(torch.nn.Module):
-    def __init__(self, a=0, b=0, double_output=False):
-        super().__init__()
-        self.a = torch.nn.Parameter(torch.tensor([2, 3]).float())
-        self.b = torch.nn.Parameter(torch.tensor([2, 3]).float())
-        self.first_batch = True
-
-    def forward(self, x=None):
-        if self.first_batch:
-            print(f"Model dtype: {self.a.dtype}, {self.b.dtype}. Input dtype: {x.dtype}")
-            self.first_batch = False
-        return x * self.a[0] + self.b[0]
-
-
-class RegressionModel(torch.nn.Module):
-    def __init__(self, a=0, b=0, double_output=False):
-        super().__init__()
-        self.a = torch.nn.Parameter(torch.tensor(a).float())
-        self.b = torch.nn.Parameter(torch.tensor(b).float())
-        self.first_batch = True
-
-    def forward(self, x=None):
-        if self.first_batch:
-            print(f"Model dtype: {self.a.dtype}, {self.b.dtype}. Input dtype: {x.dtype}")
-            self.first_batch = False
-        return x * self.a + self.b
-
-
-def mocked_dataloaders(accelerator, batch_size: int = 16):
-    from datasets import load_dataset
-    from transformers import AutoTokenizer
-
-    tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
-    data_files = {"train": "tests/test_samples/MRPC/train.csv", "validation": "tests/test_samples/MRPC/dev.csv"}
-    datasets = load_dataset("csv", data_files=data_files)
-    label_list = datasets["train"].unique("label")
-
-    label_to_id = {v: i for i, v in enumerate(label_list)}
-
-    def tokenize_function(examples):
-        # max_length=None => use the model max length (it's actually the default)
-        outputs = tokenizer(
-            examples["sentence1"], examples["sentence2"], truncation=True, max_length=None, padding="max_length"
-        )
-        if "label" in examples:
-            outputs["labels"] = [label_to_id[l] for l in examples["label"]]
-        return outputs
-
-    # Apply the method we just defined to all the examples in all the splits of the dataset
-    tokenized_datasets = datasets.map(
-        tokenize_function,
-        batched=True,
-        remove_columns=["sentence1", "sentence2", "label"],
-    )
-
-    def collate_fn(examples):
-        # On TPU it's best to pad everything to the same length or training will be very slow.
-        if accelerator.distributed_type == DistributedType.TPU:
-            return tokenizer.pad(examples, padding="max_length", max_length=128, return_tensors="pt")
-        return tokenizer.pad(examples, padding="longest", return_tensors="pt")
-
-    # Instantiate dataloaders.
-    train_dataloader = DataLoader(tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=2)
-    eval_dataloader = DataLoader(tokenized_datasets["validation"], shuffle=False, collate_fn=collate_fn, batch_size=1)
-
-    return train_dataloader, eval_dataloader

src/tracking.py

@@ -3,29 +3,6 @@
 # Expectation:
 # Provide a project dir name, then each type of logger gets stored in project/{`logging_dir`}
 
-import json
-import os
-import time
-from functools import wraps
-from typing import Any, Dict, List, Optional, Union
-
-import yaml
-
-from .logging import get_logger
-from .state import PartialState
-from .utils import (
-    LoggerType,
-    is_aim_available,
-    is_clearml_available,
-    is_comet_ml_available,
-    is_dvclive_available,
-    is_mlflow_available,
-    is_tensorboard_available,
-    is_wandb_available,
-    listify,
-)
-
-
 _available_trackers = []
 
 if is_tensorboard_available():

src/utils/bnb.py

@@ -1,31 +1,3 @@
-
-
-
-import logging
-import os
-from copy import deepcopy
-from typing import Dict, List, Optional, Union
-
-import torch
-import torch.nn as nn
-
-from accelerate.utils.imports import (
-    is_4bit_bnb_available,
-    is_8bit_bnb_available,
-)
-
-from ..big_modeling import dispatch_model, init_empty_weights
-from .dataclasses import BnbQuantizationConfig
-from .modeling import (
-    find_tied_parameters,
-    get_balanced_memory,
-    infer_auto_device_map,
-    load_checkpoint_in_model,
-    offload_weight,
-    set_module_tensor_to_device,
-)
-
-
 logger = logging.getLogger(__name__)
 
 

src/utils/constants.py

@@ -1,8 +1,3 @@
-
-
-import operator as op
-
-
 SCALER_NAME = "scaler.pt"
 MODEL_NAME = "pytorch_model"
 SAFE_MODEL_NAME = "model"