| |
| import torch |
| import torch.distributed as dist |
| from transformers import TrainerControl, TrainerState, TrainingArguments |
|
|
| from swift.utils import ShutdownManager, get_device |
| from .base import TrainerCallback |
|
|
|
|
| class DeepspeedElasticCallback(TrainerCallback): |
|
|
| def __init__(self, args=None, trainer=None): |
| if args is not None and trainer is not None: |
| super().__init__(args, trainer) |
|
|
| def on_init_end(self, args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs): |
| """ |
| Event called at the beginning of training. |
| """ |
|
|
| if args.deepspeed: |
| from deepspeed.elasticity import compute_elastic_config |
| from deepspeed.git_version_info import version as __version__ |
| args.deepspeed['checkpoint'] = {'load_universal': True} |
| if 'elasticity' not in args.deepspeed: |
| args.deepspeed['elasticity'] = { |
| 'ignore_non_elastic_batch_info': True, |
| 'enabled': True, |
| 'max_train_batch_size': 8, |
| 'micro_batch_sizes': [2], |
| 'min_gpus': 1, |
| 'max_gpus': 4, |
| 'min_time': 20, |
| 'version': 0.1 |
| } |
| world_size = dist.get_world_size() if dist.is_available() and dist.is_initialized() else 1 |
| final_batch_size, _, micro_batch_size = compute_elastic_config( |
| ds_config=args.deepspeed, |
| target_deepspeed_version=__version__, |
| world_size=world_size, |
| ) |
| denom = micro_batch_size * world_size |
| gradient_accu_steps = max(1, final_batch_size // denom) |
| args.per_device_train_batch_size = micro_batch_size |
| args.gradient_accumulation_steps = gradient_accu_steps |
| state.train_batch_size = args.per_device_train_batch_size * max(1, args.n_gpu) |
|
|
|
|
| class GracefulExitCallback(TrainerCallback): |
|
|
| def __init__(self, args=None, trainer=None): |
| if args is not None and trainer is not None: |
| super().__init__(args, trainer) |
| shutdown_manager = ShutdownManager() |
| shutdown_manager.register() |
| self.shutdown_manager = shutdown_manager |
| self._pending_stop = False |
|
|
| def on_step_end(self, args, state, control, **kwargs): |
| device_type = get_device() |
|
|
| local_req = 1 if self.shutdown_manager.should_shutdown() else 0 |
| if dist.is_available() and dist.is_initialized(): |
|
|
| t = torch.tensor([local_req], dtype=torch.uint8, device=device_type) |
| |
| dist.all_reduce(t, op=dist.ReduceOp.MAX) |
| any_req = bool(int(t.item())) |
| else: |
| any_req = bool(local_req) |
|
|
| if any_req: |
| control.should_save = True |
| self._pending_stop = True |
| return control |
|
|
| def on_save(self, args, state, control, **kwargs): |
| if self._pending_stop: |
| control.should_training_stop = True |
| self._pending_stop = False |
| return control |
|
|
