trainer.py 76.5 KB
Newer Older
Sylvain Gugger's avatar
Sylvain Gugger committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# coding=utf-8
# Copyright 2020-present the HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
The Trainer class, to easily train a 馃 Transformers from scratch or finetune it on a new task.
"""

19
import collections
20
import inspect
21
import math
Julien Chaumond's avatar
Julien Chaumond committed
22
23
24
import os
import re
import shutil
25
import time
26
import warnings
Julien Chaumond's avatar
Julien Chaumond committed
27
from pathlib import Path
28
from typing import Any, Callable, Dict, List, Optional, Tuple, Union
Julien Chaumond's avatar
Julien Chaumond committed
29
30


31
32
# Integrations must be imported before ML frameworks:
from .integrations import (  # isort: split
33
    default_hp_search_backend,
34
    hp_params,
35
    is_azureml_available,
36
    is_comet_available,
37
    is_fairscale_available,
38
    is_mlflow_available,
39
    is_optuna_available,
40
    is_ray_tune_available,
41
42
    is_tensorboard_available,
    is_wandb_available,
43
44
    run_hp_search_optuna,
    run_hp_search_ray,
45
)
46
47
48
49
50
51
52
53
54
55
56

import numpy as np
import torch
from packaging import version
from torch import nn
from torch.utils.data.dataloader import DataLoader
from torch.utils.data.dataset import Dataset
from torch.utils.data.distributed import DistributedSampler
from torch.utils.data.sampler import RandomSampler, SequentialSampler

from .data.data_collator import DataCollator, DataCollatorWithPadding, default_data_collator
57
from .file_utils import WEIGHTS_NAME, is_apex_available, is_datasets_available, is_in_notebook, is_torch_tpu_available
Julien Chaumond's avatar
Julien Chaumond committed
58
from .modeling_utils import PreTrainedModel
Sylvain Gugger's avatar
Sylvain Gugger committed
59
from .models.auto.modeling_auto import MODEL_FOR_QUESTION_ANSWERING_MAPPING
Sylvain Gugger's avatar
Sylvain Gugger committed
60
from .optimization import Adafactor, AdamW, get_scheduler
61
from .tokenization_utils_base import PreTrainedTokenizerBase
Sylvain Gugger's avatar
Sylvain Gugger committed
62
63
64
65
66
67
68
69
70
71
from .trainer_callback import (
    CallbackHandler,
    DefaultFlowCallback,
    PrinterCallback,
    ProgressCallback,
    TrainerCallback,
    TrainerControl,
    TrainerState,
)
from .trainer_pt_utils import (
72
    DistributedTensorGatherer,
Sylvain Gugger's avatar
Sylvain Gugger committed
73
    LabelSmoother,
Sylvain Gugger's avatar
Sylvain Gugger committed
74
75
76
77
78
79
80
81
82
83
    SequentialDistributedSampler,
    distributed_broadcast_scalars,
    distributed_concat,
    get_tpu_sampler,
    nested_concat,
    nested_detach,
    nested_numpify,
    nested_xla_mesh_reduce,
    reissue_pt_warnings,
)
84
85
86
87
88
89
90
91
92
93
from .trainer_utils import (
    PREFIX_CHECKPOINT_DIR,
    BestRun,
    EvalPrediction,
    HPSearchBackend,
    PredictionOutput,
    TrainOutput,
    default_compute_objective,
    default_hp_space,
    set_seed,
94
    speed_metrics,
95
)
Patrick von Platen's avatar
Patrick von Platen committed
96
from .training_args import TrainingArguments
Lysandre Debut's avatar
Lysandre Debut committed
97
from .utils import logging
Julien Chaumond's avatar
Julien Chaumond committed
98
99


100
_is_native_amp_available = False
101

Sylvain Gugger's avatar
Sylvain Gugger committed
102
DEFAULT_CALLBACKS = [DefaultFlowCallback]
103
DEFAULT_PROGRESS_CALLBACK = ProgressCallback
Sylvain Gugger's avatar
Sylvain Gugger committed
104

105
106
107
108
if is_in_notebook():
    from .utils.notebook import NotebookProgressCallback

    DEFAULT_PROGRESS_CALLBACK = NotebookProgressCallback
109

110
111
if is_apex_available():
    from apex import amp
112

113
if version.parse(torch.__version__) >= version.parse("1.6"):
114
    _is_native_amp_available = True
115
    from torch.cuda.amp import autocast
Julien Chaumond's avatar
Julien Chaumond committed
116

117
118
if is_datasets_available():
    import datasets
Julien Chaumond's avatar
Julien Chaumond committed
119

120
if is_torch_tpu_available():
Lysandre Debut's avatar
Lysandre Debut committed
121
122
123
124
    import torch_xla.core.xla_model as xm
    import torch_xla.debug.metrics as met
    import torch_xla.distributed.parallel_loader as pl

125
if is_tensorboard_available():
Sylvain Gugger's avatar
Sylvain Gugger committed
126
127
128
129
    from .integrations import TensorBoardCallback

    DEFAULT_CALLBACKS.append(TensorBoardCallback)

Julien Chaumond's avatar
Julien Chaumond committed
130

131
if is_wandb_available():
Sylvain Gugger's avatar
Sylvain Gugger committed
132
133
134
    from .integrations import WandbCallback

    DEFAULT_CALLBACKS.append(WandbCallback)
135

136
if is_comet_available():
Sylvain Gugger's avatar
Sylvain Gugger committed
137
138
139
    from .integrations import CometCallback

    DEFAULT_CALLBACKS.append(CometCallback)
140

141
142
143
144
145
if is_mlflow_available():
    from .integrations import MLflowCallback

    DEFAULT_CALLBACKS.append(MLflowCallback)

146
147
148
if is_optuna_available():
    import optuna

149
if is_ray_tune_available():
150
151
    from ray import tune

152
153
154
155
156
if is_azureml_available():
    from .integrations import AzureMLCallback

    DEFAULT_CALLBACKS.append(AzureMLCallback)

157
158
159
160
161
if is_fairscale_available():
    from fairscale.nn.data_parallel import ShardedDataParallel as ShardedDDP
    from fairscale.optim import OSS
    from fairscale.optim.grad_scaler import ShardedGradScaler

Lysandre Debut's avatar
Lysandre Debut committed
162
logger = logging.get_logger(__name__)
Julien Chaumond's avatar
Julien Chaumond committed
163
164


165
166
167
168
169
170
171
172
def _model_unwrap(model: nn.Module) -> nn.Module:
    # since there could be multiple levels of wrapping, unwrap recursively
    if hasattr(model, "module"):
        return _model_unwrap(model.module)
    else:
        return model


Julien Chaumond's avatar
Julien Chaumond committed
173
174
class Trainer:
    """
Sylvain Gugger's avatar
Sylvain Gugger committed
175
    Trainer is a simple but feature-complete training and eval loop for PyTorch, optimized for 馃 Transformers.
176
177

    Args:
Sylvain Gugger's avatar
Sylvain Gugger committed
178
        model (:class:`~transformers.PreTrainedModel` or :obj:`torch.nn.Module`, `optional`):
179
            The model to train, evaluate or use for predictions. If not provided, a ``model_init`` must be passed.
Sylvain Gugger's avatar
Sylvain Gugger committed
180
181
182
183
184
185

            .. note::

                :class:`~transformers.Trainer` is optimized to work with the :class:`~transformers.PreTrainedModel`
                provided by the library. You can still use your own models defined as :obj:`torch.nn.Module` as long as
                they work the same way as the 馃 Transformers models.
186
        args (:class:`~transformers.TrainingArguments`, `optional`):
Sylvain Gugger's avatar
Sylvain Gugger committed
187
188
189
            The arguments to tweak for training. Will default to a basic instance of
            :class:`~transformers.TrainingArguments` with the ``output_dir`` set to a directory named `tmp_trainer` in
            the current directory if not provided.
190
        data_collator (:obj:`DataCollator`, `optional`):
Sylvain Gugger's avatar
Sylvain Gugger committed
191
192
193
            The function to use to form a batch from a list of elements of :obj:`train_dataset` or :obj:`eval_dataset`.
            Will default to :func:`~transformers.default_data_collator` if no ``tokenizer`` is provided, an instance of
            :func:`~transformers.DataCollatorWithPadding` otherwise.
Sylvain Gugger's avatar
Sylvain Gugger committed
194
        train_dataset (:obj:`torch.utils.data.dataset.Dataset`, `optional`):
195
            The dataset to use for training. If it is an :obj:`datasets.Dataset`, columns not accepted by the
196
            ``model.forward()`` method are automatically removed.
Sylvain Gugger's avatar
Sylvain Gugger committed
197
        eval_dataset (:obj:`torch.utils.data.dataset.Dataset`, `optional`):
198
             The dataset to use for evaluation. If it is an :obj:`datasets.Dataset`, columns not accepted by the
Sylvain Gugger's avatar
Sylvain Gugger committed
199
             ``model.forward()`` method are automatically removed.
200
201
202
203
        tokenizer (:class:`PreTrainedTokenizerBase`, `optional`):
            The tokenizer used to preprocess the data. If provided, will be used to automatically pad the inputs the
            maximum length when batching inputs, and it will be saved along the model to make it easier to rerun an
            interrupted training or reuse the fine-tuned model.
204
205
206
        model_init (:obj:`Callable[[], PreTrainedModel]`, `optional`):
            A function that instantiates the model to be used. If provided, each call to
            :meth:`~transformers.Trainer.train` will start from a new instance of the model as given by this function.
207

Sylvain Gugger's avatar
Sylvain Gugger committed
208
209
            The function may have zero argument, or a single one containing the optuna/Ray Tune trial object, to be
            able to choose different architectures according to hyper parameters (such as layer count, sizes of inner
Sylvain Gugger's avatar
Sylvain Gugger committed
210
211
            layers, dropout probabilities etc).
        compute_metrics (:obj:`Callable[[EvalPrediction], Dict]`, `optional`):
212
            The function that will be used to compute metrics at evaluation. Must take a
Sylvain Gugger's avatar
Sylvain Gugger committed
213
214
215
216
            :class:`~transformers.EvalPrediction` and return a dictionary string to metric values.
        callbacks (List of :obj:`~transformers.TrainerCallback`, `optional`):
            A list of callbacks to customize the training loop. Will add those to the list of default callbacks
            detailed in :doc:`here <callback>`.
Sylvain Gugger's avatar
Sylvain Gugger committed
217
218

            If you want to remove one of the default callbacks used, use the :meth:`Trainer.remove_callback` method.
Sylvain Gugger's avatar
Sylvain Gugger committed
219
        optimizers (:obj:`Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR`, `optional`): A tuple
Sylvain Gugger's avatar
Sylvain Gugger committed
220
            containing the optimizer and the scheduler to use. Will default to an instance of
221
            :class:`~transformers.AdamW` on your model and a scheduler given by
Sylvain Gugger's avatar
Sylvain Gugger committed
222
            :func:`~transformers.get_linear_schedule_with_warmup` controlled by :obj:`args`.
223
224
225
226
227
228
229
230
231
232

    Important accessors:

        ``self.model`` - always points to the core model. If using a transformers model, it will be a
        :class:`PreTrainedModel` subclass.

        ``self.model_wrapped`` - always points to the most external model in case one or more other modules wrap the
        original model. This is the model that should be used for the forward pass. For example, under ``DeepSpeed``,
        the inner model is wrapped in ``DeepSpeed`` and then again in ``DistributedDataParallel``. If the inner model
        hasn't been wrapped, then ``self.model_wrapped`` is the same as ``self.model``.
Julien Chaumond's avatar
Julien Chaumond committed
233
234
235
236
    """

    def __init__(
        self,
Sylvain Gugger's avatar
Sylvain Gugger committed
237
        model: Union[PreTrainedModel, torch.nn.Module] = None,
238
        args: TrainingArguments = None,
Julien Chaumond's avatar
Julien Chaumond committed
239
240
241
        data_collator: Optional[DataCollator] = None,
        train_dataset: Optional[Dataset] = None,
        eval_dataset: Optional[Dataset] = None,
242
        tokenizer: Optional["PreTrainedTokenizerBase"] = None,
243
        model_init: Callable[[], PreTrainedModel] = None,
Julien Chaumond's avatar
Julien Chaumond committed
244
        compute_metrics: Optional[Callable[[EvalPrediction], Dict]] = None,
Sylvain Gugger's avatar
Sylvain Gugger committed
245
        callbacks: Optional[List[TrainerCallback]] = None,
246
        optimizers: Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None),
Julien Chaumond's avatar
Julien Chaumond committed
247
    ):
Sylvain Gugger's avatar
Sylvain Gugger committed
248
        if args is None:
249
250
251
            output_dir = "tmp_trainer"
            logger.info(f"No `TrainingArguments` passed, using `output_dir={output_dir}`.")
            args = TrainingArguments(output_dir=output_dir)
Sylvain Gugger's avatar
Sylvain Gugger committed
252
253
254
        self.args = args
        # Seed must be set before instantiating the model when using model
        set_seed(self.args.seed)
255
        self.hp_name = None
256

257
258
259
260
261
262
263
264
265
266
267
268
269
270
        if model is None:
            if model_init is not None:
                self.model_init = model_init
                model = self.call_model_init()
            else:
                raise RuntimeError("`Trainer` requires either a `model` or `model_init` argument")
        else:
            if model_init is not None:
                warnings.warn(
                    "`Trainer` requires either a `model` or `model_init` argument, but not both. "
                    "`model_init` will overwrite your model when calling the `train` method. This will become a fatal error in the next release.",
                    FutureWarning,
                )
            self.model_init = model_init
271

272
273
        default_collator = default_data_collator if tokenizer is None else DataCollatorWithPadding(tokenizer)
        self.data_collator = data_collator if data_collator is not None else default_collator
Julien Chaumond's avatar
Julien Chaumond committed
274
275
        self.train_dataset = train_dataset
        self.eval_dataset = eval_dataset
276
        self.tokenizer = tokenizer
277

278
279
280
281
282
283
284
285
        # Model parallel
        if not self.args.model_parallel:
            model = model.to(args.device)

        # later use `self.model is self.model_wrapped` to check if it's wrapped or not
        self.model_wrapped = model
        self.model = model

Julien Chaumond's avatar
Julien Chaumond committed
286
        self.compute_metrics = compute_metrics
287
        self.optimizer, self.lr_scheduler = optimizers
Sylvain Gugger's avatar
Sylvain Gugger committed
288
289
290
291
292
        if model_init is not None and (self.optimizer is not None or self.lr_scheduler is not None):
            raise RuntimeError(
                "Passing a `model_init` is incompatible with providing the `optimizers` argument."
                "You should subclass `Trainer` and override the `create_optimizer_and_scheduler` method."
            )
Sylvain Gugger's avatar
Sylvain Gugger committed
293
        callbacks = DEFAULT_CALLBACKS if callbacks is None else DEFAULT_CALLBACKS + callbacks
294
295
296
        self.callback_handler = CallbackHandler(
            callbacks, self.model, self.tokenizer, self.optimizer, self.lr_scheduler
        )
297
        self.add_callback(PrinterCallback if self.args.disable_tqdm else DEFAULT_PROGRESS_CALLBACK)
Sylvain Gugger's avatar
Sylvain Gugger committed
298

299
300
301
        # Will be set to True by `self._setup_loggers()` on first call to `self.log()`.
        self._loggers_initialized = False

Julien Chaumond's avatar
Julien Chaumond committed
302
        # Create output directory if needed
303
        if self.is_world_process_zero():
Julien Chaumond's avatar
Julien Chaumond committed
304
            os.makedirs(self.args.output_dir, exist_ok=True)
305
        if is_torch_tpu_available() and isinstance(self.model, PreTrainedModel):
Lysandre Debut's avatar
Lysandre Debut committed
306
307
308
            # Set an xla_device flag on the model's config.
            # We'll find a more elegant and not need to do this in the future.
            self.model.config.xla_device = True
309
        if not callable(self.data_collator) and callable(getattr(self.data_collator, "collate_batch", None)):
Sylvain Gugger's avatar
Sylvain Gugger committed
310
            raise ValueError("The `data_collator` should be a simple callable (function, class with `__call__`).")
311

312
313
314
315
316
317
318
319
320
        if args.max_steps > 0:
            logger.info("max_steps is given, it will override any value given in num_train_epochs")

        # Enforce rules on using datasets with no __len__
        if train_dataset is not None and not isinstance(train_dataset, collections.abc.Sized) and args.max_steps <= 0:
            raise ValueError("train_dataset does not implement __len__, max_steps has to be specified")
        if eval_dataset is not None and not isinstance(eval_dataset, collections.abc.Sized):
            raise ValueError("eval_dataset must implement __len__")

321
322
        if is_datasets_available():
            if isinstance(train_dataset, datasets.Dataset):
323
                self._remove_unused_columns(self.train_dataset, description="training")
324
            if isinstance(eval_dataset, datasets.Dataset):
325
326
                self._remove_unused_columns(self.eval_dataset, description="evaluation")

327
328
329
330
331
332
333
334
335
336
        # Setup Sharded DDP training
        self.sharded_dpp = False
        if args.sharded_ddp:
            if args.local_rank == -1:
                raise ValueError("Using sharded DDP only works in distributed training.")
            elif not is_fairscale_available():
                raise ImportError("Sharded DDP training requires fairscale: `pip install fairscale`.")
            else:
                self.sharded_dpp = True

337
338
339
340
341
342
343
344
        # Mixed precision setup
        self.use_apex = False
        self.use_amp = False
        if args.fp16:
            if args.fp16_backend == "auto":
                backend = "amp" if _is_native_amp_available else "apex"
            else:
                backend = args.fp16_backend
345
            logger.info(f"Using {backend} fp16 backend")
346
347
348

            if backend == "amp":
                self.use_amp = True
349
                self.scaler = ShardedGradScaler() if self.sharded_dpp else torch.cuda.amp.GradScaler()
350
351
352
353
354
355
356
            else:
                if not is_apex_available():
                    raise ImportError(
                        "Using FP16 with APEX but APEX is not installed, please refer to https://www.github.com/nvidia/apex."
                    )
                self.use_apex = True

Sylvain Gugger's avatar
Sylvain Gugger committed
357
358
359
360
361
362
        # Label smoothing
        if self.args.label_smoothing_factor != 0:
            self.label_smoother = LabelSmoother(epsilon=self.args.label_smoothing_factor)
        else:
            self.label_smoother = None

363
        self.state = TrainerState()
Sylvain Gugger's avatar
Sylvain Gugger committed
364
        self.control = TrainerControl()
365
366
367
        # Internal variable for total_flos used to count as tensors (for distributed + TPU), will be sent in the
        # state at each call to self.log.
        self._total_flos = None
368
        self.hp_search_backend = None
369
        self.use_tune_checkpoints = False
370
        default_label_names = (
371
            ["start_positions", "end_positions"]
372
373
374
375
            if type(self.model) in MODEL_FOR_QUESTION_ANSWERING_MAPPING.values()
            else ["labels"]
        )
        self.label_names = default_label_names if self.args.label_names is None else self.args.label_names
Sylvain Gugger's avatar
Sylvain Gugger committed
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
        self.control = self.callback_handler.on_init_end(self.args, self.state, self.control)

    def add_callback(self, callback):
        """
        Add a callback to the current list of :class:`~transformer.TrainerCallback`.

        Args:
           callback (:obj:`type` or :class:`~transformer.TrainerCallback`):
               A :class:`~transformer.TrainerCallback` class or an instance of a :class:`~transformer.TrainerCallback`.
               In the first case, will instantiate a member of that class.
        """
        self.callback_handler.add_callback(callback)

    def pop_callback(self, callback):
        """
        Remove a callback from the current list of :class:`~transformer.TrainerCallback` and returns it.

        If the callback is not found, returns :obj:`None` (and no error is raised).

        Args:
           callback (:obj:`type` or :class:`~transformer.TrainerCallback`):
               A :class:`~transformer.TrainerCallback` class or an instance of a :class:`~transformer.TrainerCallback`.
               In the first case, will pop the first member of that class found in the list of callbacks.

        Returns:
            :class:`~transformer.TrainerCallback`: The callback removed, if found.
        """
        return self.callback_handler.pop_callback(callback)

    def remove_callback(self, callback):
        """
        Remove a callback from the current list of :class:`~transformer.TrainerCallback`.

        Args:
           callback (:obj:`type` or :class:`~transformer.TrainerCallback`):
               A :class:`~transformer.TrainerCallback` class or an instance of a :class:`~transformer.TrainerCallback`.
               In the first case, will remove the first member of that class found in the list of callbacks.
        """
        self.callback_handler.remove_callback(callback)
Julien Chaumond's avatar
Julien Chaumond committed
415

416
    def _remove_unused_columns(self, dataset: "datasets.Dataset", description: Optional[str] = None):
417
418
        if not self.args.remove_unused_columns:
            return
419
420
421
422
423
424
425
426
427
428
429
        # Inspect model forward signature to keep only the arguments it accepts.
        signature = inspect.signature(self.model.forward)
        signature_columns = list(signature.parameters.keys())
        # Labels may be named label or label_ids, the default data collator handles that.
        signature_columns += ["label", "label_ids"]
        columns = [k for k in signature_columns if k in dataset.column_names]
        ignored_columns = list(set(dataset.column_names) - set(signature_columns))
        dset_description = "" if description is None else f"in the {description} set "
        logger.info(
            f"The following columns {dset_description}don't have a corresponding argument in `{self.model.__class__.__name__}.forward` and have been ignored: {', '.join(ignored_columns)}."
        )
sgugger's avatar
sgugger committed
430
        dataset.set_format(type=dataset.format["type"], columns=columns)
431

432
    def _get_train_sampler(self) -> Optional[torch.utils.data.sampler.Sampler]:
433
434
435
        if isinstance(self.train_dataset, torch.utils.data.IterableDataset) or not isinstance(
            self.train_dataset, collections.abc.Sized
        ):
436
            return None
437
        elif is_torch_tpu_available():
438
            return get_tpu_sampler(self.train_dataset)
Lysandre Debut's avatar
Lysandre Debut committed
439
        else:
440
            return (
Lysandre Debut's avatar
Lysandre Debut committed
441
442
443
444
                RandomSampler(self.train_dataset)
                if self.args.local_rank == -1
                else DistributedSampler(self.train_dataset)
            )
445
446
447
448
449

    def get_train_dataloader(self) -> DataLoader:
        """
        Returns the training :class:`~torch.utils.data.DataLoader`.

Sylvain Gugger's avatar
Sylvain Gugger committed
450
451
        Will use no sampler if :obj:`self.train_dataset` does not implement :obj:`__len__`, a random sampler (adapted
        to distributed training if necessary) otherwise.
452
453
454
455
456
457
458
459

        Subclass and override this method if you want to inject some custom behavior.
        """
        if self.train_dataset is None:
            raise ValueError("Trainer: training requires a train_dataset.")
        train_sampler = self._get_train_sampler()

        return DataLoader(
Julien Chaumond's avatar
Julien Chaumond committed
460
461
462
            self.train_dataset,
            batch_size=self.args.train_batch_size,
            sampler=train_sampler,
463
            collate_fn=self.data_collator,
Setu Shah's avatar
Setu Shah committed
464
            drop_last=self.args.dataloader_drop_last,
Chady Kamar's avatar
Chady Kamar committed
465
            num_workers=self.args.dataloader_num_workers,
Julien Chaumond's avatar
Julien Chaumond committed
466
467
        )

468
    def _get_eval_sampler(self, eval_dataset: Dataset) -> Optional[torch.utils.data.sampler.Sampler]:
469
        if is_torch_tpu_available():
470
471
472
473
474
            return SequentialDistributedSampler(eval_dataset, num_replicas=xm.xrt_world_size(), rank=xm.get_ordinal())
        elif self.args.local_rank != -1:
            return SequentialDistributedSampler(eval_dataset)
        else:
            return SequentialSampler(eval_dataset)
Lysandre Debut's avatar
Lysandre Debut committed
475

Julien Chaumond's avatar
Julien Chaumond committed
476
    def get_eval_dataloader(self, eval_dataset: Optional[Dataset] = None) -> DataLoader:
477
478
479
        """
        Returns the evaluation :class:`~torch.utils.data.DataLoader`.

480
481
        Subclass and override this method if you want to inject some custom behavior.

482
        Args:
483
            eval_dataset (:obj:`torch.utils.data.dataset.Dataset`, `optional`):
484
                If provided, will override :obj:`self.eval_dataset`. If it is an :obj:`datasets.Dataset`, columns not
485
                accepted by the ``model.forward()`` method are automatically removed. It must implement :obj:`__len__`.
486
        """
Julien Chaumond's avatar
Julien Chaumond committed
487
488
        if eval_dataset is None and self.eval_dataset is None:
            raise ValueError("Trainer: evaluation requires an eval_dataset.")
489
490
491
        elif eval_dataset is not None and not isinstance(eval_dataset, collections.abc.Sized):
            raise ValueError("eval_dataset must implement __len__")
        elif is_datasets_available() and isinstance(eval_dataset, datasets.Dataset):
492
            self._remove_unused_columns(eval_dataset, description="evaluation")
493
        eval_dataset = eval_dataset if eval_dataset is not None else self.eval_dataset
494
        eval_sampler = self._get_eval_sampler(eval_dataset)
495

496
        return DataLoader(
497
            eval_dataset,
498
            sampler=eval_sampler,
Julien Chaumond's avatar
Julien Chaumond committed
499
            batch_size=self.args.eval_batch_size,
500
            collate_fn=self.data_collator,
Setu Shah's avatar
Setu Shah committed
501
            drop_last=self.args.dataloader_drop_last,
Chady Kamar's avatar
Chady Kamar committed
502
            num_workers=self.args.dataloader_num_workers,
Julien Chaumond's avatar
Julien Chaumond committed
503
504
505
        )

    def get_test_dataloader(self, test_dataset: Dataset) -> DataLoader:
506
507
508
        """
        Returns the test :class:`~torch.utils.data.DataLoader`.

509
510
        Subclass and override this method if you want to inject some custom behavior.

511
        Args:
512
            test_dataset (:obj:`torch.utils.data.dataset.Dataset`, `optional`):
513
                The test dataset to use. If it is an :obj:`datasets.Dataset`, columns not accepted by the
514
                ``model.forward()`` method are automatically removed. It must implement :obj:`__len__`.
515
        """
516
517
518
        if not isinstance(test_dataset, collections.abc.Sized):
            raise ValueError("test_dataset must implement __len__")
        elif is_datasets_available() and isinstance(test_dataset, datasets.Dataset):
519
            self._remove_unused_columns(test_dataset, description="test")
520
        test_sampler = self._get_eval_sampler(test_dataset)
Lysandre Debut's avatar
Lysandre Debut committed
521

522
523
        # We use the same batch_size as for eval.
        return DataLoader(
Julien Chaumond's avatar
Julien Chaumond committed
524
            test_dataset,
525
            sampler=test_sampler,
Julien Chaumond's avatar
Julien Chaumond committed
526
            batch_size=self.args.eval_batch_size,
527
            collate_fn=self.data_collator,
528
            drop_last=self.args.dataloader_drop_last,
Julien Chaumond's avatar
Julien Chaumond committed
529
        )
Lysandre Debut's avatar
Lysandre Debut committed
530

531
    def create_optimizer_and_scheduler(self, num_training_steps: int):
532
533
534
        """
        Setup the optimizer and the learning rate scheduler.

535
        We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the
536
        Trainer's init through :obj:`optimizers`, or subclass and override this method in a subclass.
537
        """
538
539
540
541
542
543
544
545
546
547
548
549
        if self.optimizer is None:
            no_decay = ["bias", "LayerNorm.weight"]
            optimizer_grouped_parameters = [
                {
                    "params": [p for n, p in self.model.named_parameters() if not any(nd in n for nd in no_decay)],
                    "weight_decay": self.args.weight_decay,
                },
                {
                    "params": [p for n, p in self.model.named_parameters() if any(nd in n for nd in no_decay)],
                    "weight_decay": 0.0,
                },
            ]
Sylvain Gugger's avatar
Sylvain Gugger committed
550
551
552
553
554
555
556
557
558
559
560
            optimizer_cls = Adafactor if self.args.adafactor else AdamW
            if self.args.adafactor:
                optimizer_cls = Adafactor
                optimizer_kwargs = {"scale_parameter": False, "relative_step": False}
            else:
                optimizer_cls = AdamW
                optimizer_kwargs = {
                    "betas": (self.args.adam_beta1, self.args.adam_beta2),
                    "eps": self.args.adam_epsilon,
                }
            optimizer_kwargs["lr"] = self.args.learning_rate
561
562
563
            if self.sharded_dpp:
                self.optimizer = OSS(
                    params=optimizer_grouped_parameters,
Sylvain Gugger's avatar
Sylvain Gugger committed
564
565
                    optim=optimizer_cls,
                    **optimizer_kwargs,
566
567
                )
            else:
Sylvain Gugger's avatar
Sylvain Gugger committed
568
569
                self.optimizer = optimizer_cls(optimizer_grouped_parameters, **optimizer_kwargs)

570
        if self.lr_scheduler is None:
Sylvain Gugger's avatar
Sylvain Gugger committed
571
572
573
574
575
            self.lr_scheduler = get_scheduler(
                self.args.lr_scheduler_type,
                self.optimizer,
                num_warmup_steps=self.args.warmup_steps,
                num_training_steps=num_training_steps,
576
            )
Julien Chaumond's avatar
Julien Chaumond committed
577

578
    def num_examples(self, dataloader: DataLoader) -> int:
579
        """
580
        Helper to get number of samples in a :class:`~torch.utils.data.DataLoader` by accessing its dataset.
581
582

        Will raise an exception if the underlying dataset dese not implement method :obj:`__len__`
583
        """
584
        return len(dataloader.dataset)
585

586
587
    def _hp_search_setup(self, trial: Union["optuna.Trial", Dict[str, Any]]):
        """ HP search setup code """
588
589
        self._trial = trial

590
591
        if self.hp_search_backend is None or trial is None:
            return
592

593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
        params = self.hp_space(trial) if self.hp_search_backend == HPSearchBackend.OPTUNA else trial
        for key, value in params.items():
            if not hasattr(self.args, key):
                raise AttributeError(
                    f"Trying to set {key} in the hyperparameter search but there is no corresponding field in `TrainingArguments`."
                )
            old_attr = getattr(self.args, key, None)
            # Casting value to the proper type
            if old_attr is not None:
                value = type(old_attr)(value)
            setattr(self.args, key, value)
        if self.hp_search_backend == HPSearchBackend.OPTUNA:
            logger.info("Trial:", trial.params)

    def _report_to_hp_search(
        self, trial: Union["optuna.Trial", Dict[str, Any]], epoch: int, metrics: Dict[str, float]
    ):
        if self.hp_search_backend is None or trial is None:
            return
612
        self.objective = self.compute_objective(metrics.copy())
613
614
615
616
617
        if self.hp_search_backend == HPSearchBackend.OPTUNA:
            trial.report(self.objective, epoch)
            if trial.should_prune():
                raise optuna.TrialPruned()
        elif self.hp_search_backend == HPSearchBackend.RAY:
618
            if self.state.global_step % self.args.save_steps == 0:
619
                self._tune_save_checkpoint()
620
621
            tune.report(objective=self.objective, **metrics)

622
623
624
    def _tune_save_checkpoint(self):
        if not self.use_tune_checkpoints:
            return
625
        with tune.checkpoint_dir(step=self.state.global_step) as checkpoint_dir:
626
            self.args.output_dir = checkpoint_dir
627
            output_dir = os.path.join(self.args.output_dir, f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}")
628
            self.save_model(output_dir)
629
            if self.is_world_process_zero():
630
                self.state.save_to_json(os.path.join(output_dir, "trainer_state.json"))
631
632
633
                torch.save(self.optimizer.state_dict(), os.path.join(output_dir, "optimizer.pt"))
                torch.save(self.lr_scheduler.state_dict(), os.path.join(output_dir, "scheduler.pt"))

634
635
636
637
638
639
640
    def call_model_init(self, trial=None):
        model_init_argcount = len(inspect.signature(self.model_init).parameters)
        if model_init_argcount == 0:
            model = self.model_init()
        elif model_init_argcount == 1:
            model = self.model_init(trial)
        else:
641
642
643
644
            raise RuntimeError("model_init should have 0 or 1 argument.")

        if model is None:
            raise RuntimeError("model_init should not return None.")
645
646
647

        return model

648
    def train(self, model_path: Optional[str] = None, trial: Union["optuna.Trial", Dict[str, Any]] = None):
Julien Chaumond's avatar
Julien Chaumond committed
649
650
651
652
        """
        Main training entry point.

        Args:
653
654
655
            model_path (:obj:`str`, `optional`):
                Local path to the model if the model to train has been instantiated from a local path. If present,
                training will resume from the optimizer/scheduler states loaded here.
656
657
            trial (:obj:`optuna.Trial` or :obj:`Dict[str, Any]`, `optional`):
                The trial run or the hyperparameter dictionary for hyperparameter search.
Julien Chaumond's avatar
Julien Chaumond committed
658
        """
Sylvain Gugger's avatar
Sylvain Gugger committed
659
660
661
        # This might change the seed so needs to run first.
        self._hp_search_setup(trial)

662
663
        # Model re-init
        if self.model_init is not None:
Sylvain Gugger's avatar
Sylvain Gugger committed
664
665
            # Seed must be set before instantiating the model when using model_init.
            set_seed(self.args.seed)
666
667

            model = self.call_model_init(trial)
668
            if not self.args.model_parallel:
669
670
671
672
                model = model.to(self.args.device)

            self.model = model
            self.model_wrapped = model
673

Sylvain Gugger's avatar
Sylvain Gugger committed
674
675
            # Reinitializes optimizer and scheduler
            self.optimizer, self.lr_scheduler = None, None
676

677
678
679
        # Keeping track whether we can can len() on the dataset or not
        train_dataset_is_sized = isinstance(self.train_dataset, collections.abc.Sized)

680
        # Data loader and number of training steps
Julien Chaumond's avatar
Julien Chaumond committed
681
        train_dataloader = self.get_train_dataloader()
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697

        # Setting up training control variables:
        # number of training epochs: num_train_epochs
        # number of training steps per epoch: num_update_steps_per_epoch
        # total number of training steps to execute: max_steps
        if train_dataset_is_sized:
            num_update_steps_per_epoch = len(train_dataloader) // self.args.gradient_accumulation_steps
            num_update_steps_per_epoch = max(num_update_steps_per_epoch, 1)
            if self.args.max_steps > 0:
                max_steps = self.args.max_steps
                num_train_epochs = self.args.max_steps // num_update_steps_per_epoch + int(
                    self.args.max_steps % num_update_steps_per_epoch > 0
                )
            else:
                max_steps = math.ceil(self.args.num_train_epochs * num_update_steps_per_epoch)
                num_train_epochs = math.ceil(self.args.num_train_epochs)
Julien Chaumond's avatar
Julien Chaumond committed
698
        else:
699
700
701
702
            # see __init__. max_steps is set when the dataset has no __len__
            max_steps = self.args.max_steps
            num_train_epochs = 1
            num_update_steps_per_epoch = max_steps
Julien Chaumond's avatar
Julien Chaumond committed
703

704
        self.create_optimizer_and_scheduler(num_training_steps=max_steps)
705
        self.state = TrainerState()
706
        self.state.is_hyper_param_search = trial is not None
Julien Chaumond's avatar
Julien Chaumond committed
707
708

        # Check if saved optimizer or scheduler states exist
Sylvain Gugger's avatar
Sylvain Gugger committed
709
        self._load_optimizer_and_scheduler(model_path)
Julien Chaumond's avatar
Julien Chaumond committed
710

711
712
        model = self.model_wrapped

Sylvain Gugger's avatar
Sylvain Gugger committed
713
        # Mixed precision training with apex (torch < 1.6)
714
        if self.use_apex:
715
            model, self.optimizer = amp.initialize(model, self.optimizer, opt_level=self.args.fp16_opt_level)
Julien Chaumond's avatar
Julien Chaumond committed
716

717
        # Multi-gpu training (should be after apex fp16 initialization)
718
        if self.args.n_gpu > 1 and not self.args.model_parallel:
Julien Chaumond's avatar
Julien Chaumond committed
719
720
721
            model = torch.nn.DataParallel(model)

        # Distributed training (should be after apex fp16 initialization)
722
723
724
        if self.sharded_dpp:
            model = ShardedDDP(model, self.optimizer)
        elif self.args.local_rank != -1:
Julien Chaumond's avatar
Julien Chaumond committed
725
726
727
728
            model = torch.nn.parallel.DistributedDataParallel(
                model,
                device_ids=[self.args.local_rank],
                output_device=self.args.local_rank,
729
730
731
732
733
                find_unused_parameters=(
                    not getattr(model.config, "gradient_checkpointing", False)
                    if isinstance(model, PreTrainedModel)
                    else True
                ),
Julien Chaumond's avatar
Julien Chaumond committed
734
            )
735
736
            # find_unused_parameters breaks checkpointing as per
            # https://github.com/huggingface/transformers/pull/4659#issuecomment-643356021
Julien Chaumond's avatar
Julien Chaumond committed
737

738
739
740
741
742
743
744
745
        # for the rest of this function `model` is the outside model, whether it was wrapped or not
        if model is not self.model:
            self.model_wrapped = model

        # important: at this point:
        # self.model         is the Transformers Model
        # self.model_wrapped is DDP(Transformers Model), DDP(Deepspeed(Transformers Model)), etc.

Julien Chaumond's avatar
Julien Chaumond committed
746
        # Train!
747
        if is_torch_tpu_available():
Lysandre Debut's avatar
Lysandre Debut committed
748
749
750
751
752
            total_train_batch_size = self.args.train_batch_size * xm.xrt_world_size()
        else:
            total_train_batch_size = (
                self.args.train_batch_size
                * self.args.gradient_accumulation_steps
753
                * (torch.distributed.get_world_size() if self.args.local_rank != -1 else 1)
Lysandre Debut's avatar
Lysandre Debut committed
754
            )
755
756
757
758
759
760
761

        num_examples = (
            self.num_examples(train_dataloader)
            if train_dataset_is_sized
            else total_train_batch_size * self.args.max_steps
        )

Julien Chaumond's avatar
Julien Chaumond committed
762
        logger.info("***** Running training *****")
763
764
765
766
767
768
        logger.info(f"  Num examples = {num_examples}")
        logger.info(f"  Num Epochs = {num_train_epochs}")
        logger.info(f"  Instantaneous batch size per device = {self.args.per_device_train_batch_size}")
        logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_train_batch_size}")
        logger.info(f"  Gradient Accumulation steps = {self.args.gradient_accumulation_steps}")
        logger.info(f"  Total optimization steps = {max_steps}")
Julien Chaumond's avatar
Julien Chaumond committed
769

770
        self.state.epoch = 0
771
        start_time = time.time()
Julien Chaumond's avatar
Julien Chaumond committed
772
773
        epochs_trained = 0
        steps_trained_in_current_epoch = 0
774

Julien Chaumond's avatar
Julien Chaumond committed
775
        # Check if continuing training from a checkpoint
776
777
778
        if model_path and os.path.isfile(os.path.join(model_path, "trainer_state.json")):
            self.state = TrainerState.load_from_json(os.path.join(model_path, "trainer_state.json"))
            epochs_trained = self.state.global_step // num_update_steps_per_epoch
779
780
781
782
783
            if not self.args.ignore_data_skip:
                steps_trained_in_current_epoch = self.state.global_step % (num_update_steps_per_epoch)
                steps_trained_in_current_epoch *= self.args.gradient_accumulation_steps
            else:
                steps_trained_in_current_epoch = 0
784
785

            logger.info("  Continuing training from checkpoint, will skip to saved global_step")
786
787
788
789
790
791
792
            logger.info(f"  Continuing training from epoch {epochs_trained}")
            logger.info(f"  Continuing training from global step {self.state.global_step}")
            if not self.args.ignore_data_skip:
                logger.info(
                    f"  Will skip the first {epochs_trained} epochs then the first {steps_trained_in_current_epoch} "
                    "batches in the first epoch."
                )
793

Sylvain Gugger's avatar
Sylvain Gugger committed
794
795
796
797
798
        # Update the references
        self.callback_handler.model = self.model
        self.callback_handler.optimizer = self.optimizer
        self.callback_handler.lr_scheduler = self.lr_scheduler
        self.callback_handler.train_dataloader = train_dataloader
799
800
        self.state.trial_name = self.hp_name(trial) if self.hp_name is not None else None
        self.state.trial_params = hp_params(trial) if trial is not None else None
801
802
803
804
        # This should be the same if the state has been saved but in case the training arguments changed, it's safer
        # to set this after the load.
        self.state.max_steps = max_steps
        self.state.num_train_epochs = num_train_epochs
Sylvain Gugger's avatar
Sylvain Gugger committed
805
806
        self.state.is_local_process_zero = self.is_local_process_zero()
        self.state.is_world_process_zero = self.is_world_process_zero()
Julien Chaumond's avatar
Julien Chaumond committed
807

808
        # tr_loss is a tensor to avoid synchronization of TPUs through .item()
809
        tr_loss = torch.tensor(0.0).to(self.args.device)
810
811
        # _total_loss_scalar is updated everytime .item() has to be called on tr_loss and stores the sum of all losses
        self._total_loss_scalar = 0.0
812
        self._globalstep_last_logged = 0
813
        self._total_flos = self.state.total_flos
Julien Chaumond's avatar
Julien Chaumond committed
814
        model.zero_grad()
Sylvain Gugger's avatar
Sylvain Gugger committed
815
816
817

        self.control = self.callback_handler.on_train_begin(self.args, self.state, self.control)

818
819
820
821
822
823
824
        # Skip the first epochs_trained epochs to get the random state of the dataloader at the right point.
        if not self.args.ignore_data_skip:
            for epoch in range(epochs_trained):
                # We just need to begin an iteration to create the randomization of the sampler.
                for _ in train_dataloader:
                    break

825
        for epoch in range(epochs_trained, num_train_epochs):
826
827
828
            if isinstance(train_dataloader, DataLoader) and isinstance(train_dataloader.sampler, DistributedSampler):
                train_dataloader.sampler.set_epoch(epoch)

829
            if is_torch_tpu_available():
830
831
832
                parallel_loader = pl.ParallelLoader(train_dataloader, [self.args.device]).per_device_loader(
                    self.args.device
                )
833
                epoch_iterator = parallel_loader
834
            else:
835
                epoch_iterator = train_dataloader
836

837
838
839
840
            # Reset the past mems state at the beginning of each epoch if necessary.
            if self.args.past_index >= 0:
                self._past = None

841
            steps_in_epoch = len(epoch_iterator) if train_dataset_is_sized else self.args.max_steps
Sylvain Gugger's avatar
Sylvain Gugger committed
842
843
            self.control = self.callback_handler.on_epoch_begin(self.args, self.state, self.control)

Julien Chaumond's avatar
Julien Chaumond committed
844
845
846
847
848
849
850
            for step, inputs in enumerate(epoch_iterator):

                # Skip past any already trained steps if resuming training
                if steps_trained_in_current_epoch > 0:
                    steps_trained_in_current_epoch -= 1
                    continue

Sylvain Gugger's avatar
Sylvain Gugger committed
851
852
853
                if (step + 1) % self.args.gradient_accumulation_steps == 0:
                    self.control = self.callback_handler.on_step_begin(self.args, self.state, self.control)

854
855
                if ((step + 1) % self.args.gradient_accumulation_steps != 0) and self.args.local_rank != -1:
                    # Avoid unnecessary DDP synchronization since there will be no backward pass on this example.
856
857
858
859
                    with model.no_sync():
                        tr_loss += self.training_step(model, inputs)
                else:
                    tr_loss += self.training_step(model, inputs)
860
                self._total_flos += self.floating_point_ops(inputs)
Julien Chaumond's avatar
Julien Chaumond committed
861
862
863

                if (step + 1) % self.args.gradient_accumulation_steps == 0 or (
                    # last step in epoch but step is always smaller than gradient_accumulation_steps
864
865
                    steps_in_epoch <= self.args.gradient_accumulation_steps
                    and (step + 1) == steps_in_epoch
Julien Chaumond's avatar
Julien Chaumond committed
866
                ):
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
                    # Gradient clipping
                    if self.args.max_grad_norm is not None and self.args.max_grad_norm > 0:
                        if self.use_amp:
                            # AMP: gradients need unscaling
                            self.scaler.unscale_(self.optimizer)

                        if hasattr(self.optimizer, "clip_grad_norm"):
                            # Some optimizers (like the sharded optimizer) have a specific way to do gradient clipping
                            self.optimizer.clip_grad_norm(self.args.max_grad_norm)
                        else:
                            # Revert to normal clipping otherwise, handling Apex or full precision
                            torch.nn.utils.clip_grad_norm_(
                                amp.master_params(self.optimizer) if self.use_apex else model.parameters(),
                                self.args.max_grad_norm,
                            )

                    # Optimizer step
884
                    if is_torch_tpu_available():
885
                        xm.optimizer_step(self.optimizer)
886
                    elif self.use_amp:
887
                        self.scaler.step(self.optimizer)
888
                        self.scaler.update()
Lysandre Debut's avatar
Lysandre Debut committed
889
                    else:
890
                        self.optimizer.step()
Lysandre Debut's avatar
Lysandre Debut committed
891

892
                    self.lr_scheduler.step()
Julien Chaumond's avatar
Julien Chaumond committed
893
                    model.zero_grad()
894
                    self.state.global_step += 1
895
                    self.state.epoch = epoch + (step + 1) / steps_in_epoch
Sylvain Gugger's avatar
Sylvain Gugger committed
896
897
                    self.control = self.callback_handler.on_step_end(self.args, self.state, self.control)

898
                    self._maybe_log_save_evaluate(tr_loss, model, trial, epoch)
Julien Chaumond's avatar
Julien Chaumond committed
899

Sylvain Gugger's avatar
Sylvain Gugger committed
900
                if self.control.should_epoch_stop or self.control.should_training_stop:
Julien Chaumond's avatar
Julien Chaumond committed
901
                    break
902

Sylvain Gugger's avatar
Sylvain Gugger committed
903
            self.control = self.callback_handler.on_epoch_end(self.args, self.state, self.control)
904
            self._maybe_log_save_evaluate(tr_loss, model, trial, epoch)
905

906
            if self.args.tpu_metrics_debug or self.args.debug:
907
908
909
910
911
912
913
914
                if is_torch_tpu_available():
                    # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
                    xm.master_print(met.metrics_report())
                else:
                    logger.warning(
                        "You enabled PyTorch/XLA debug metrics but you don't have a TPU "
                        "configured. Check your training configuration if this is unexpected."
                    )
Sylvain Gugger's avatar
Sylvain Gugger committed
915
            if self.control.should_training_stop:
916
                break
Julien Chaumond's avatar
Julien Chaumond committed
917

918
919
920
        if self.args.past_index and hasattr(self, "_past"):
            # Clean the state at the end of training
            delattr(self, "_past")
Julien Chaumond's avatar
Julien Chaumond committed
921
922

        logger.info("\n\nTraining completed. Do not forget to share your model on huggingface.co/models =)\n\n")
923
924
925
926
        if self.args.load_best_model_at_end and self.state.best_model_checkpoint is not None:
            logger.info(
                f"Loading best model from {self.state.best_model_checkpoint} (score: {self.state.best_metric})."
            )
927
928
            if isinstance(self.model, PreTrainedModel):
                self.model = self.model.from_pretrained(self.state.best_model_checkpoint)
929
930
                if not self.args.model_parallel:
                    self.model = self.model.to(self.args.device)
931
932
933
934
            else:
                state_dict = torch.load(os.path.join(self.state.best_model_checkpoint, WEIGHTS_NAME))
                self.model.load_state_dict(state_dict)

935
        metrics = speed_metrics("train", start_time, self.state.max_steps)
936
937
        if self._total_flos is not None:
            self.store_flos()
938
939
            metrics["total_flos"] = self.state.total_flos
        self.log(metrics)
940

Sylvain Gugger's avatar
Sylvain Gugger committed
941
        self.control = self.callback_handler.on_train_end(self.args, self.state, self.control)
942
943
        # add remaining tr_loss
        self._total_loss_scalar += tr_loss.item()
Sylvain Gugger's avatar
Sylvain Gugger committed
944

945
        return TrainOutput(self.state.global_step, self._total_loss_scalar / self.state.global_step, metrics)
946

947
    def _maybe_log_save_evaluate(self, tr_loss, model, trial, epoch):
Sylvain Gugger's avatar
Sylvain Gugger committed
948
949
950
        if self.control.should_log:
            logs: Dict[str, float] = {}
            tr_loss_scalar = tr_loss.item()
951
952
953
954
            # reset tr_loss to zero
            tr_loss -= tr_loss

            logs["loss"] = tr_loss_scalar / (self.state.global_step - self._globalstep_last_logged)
Sylvain Gugger's avatar
Sylvain Gugger committed
955
956
957
958
959
960
            # backward compatibility for pytorch schedulers
            logs["learning_rate"] = (
                self.lr_scheduler.get_last_lr()[0]
                if version.parse(torch.__version__) >= version.parse("1.4")
                else self.lr_scheduler.get_lr()[0]
            )
961
            self._total_loss_scalar += tr_loss_scalar
962
            self._globalstep_last_logged = self.state.global_step
Sylvain Gugger's avatar
Sylvain Gugger committed
963
964
965
966
967
968
969

            self.log(logs)

        metrics = None
        if self.control.should_evaluate:
            metrics = self.evaluate()
            self._report_to_hp_search(trial, epoch, metrics)
970

Sylvain Gugger's avatar
Sylvain Gugger committed
971
972
973
974
975
        if self.control.should_save:
            self._save_checkpoint(model, trial, metrics=metrics)
            self.control = self.callback_handler.on_save(self.args, self.state, self.control)

    def _save_checkpoint(self, model, trial, metrics=None):
976
977
978
979
        # In all cases, including ddp/dp/deepspeed, self.model is always a reference to the model we
        # want to save.
        assert _model_unwrap(model) is self.model, "internal model should be a reference to self.model"

980
        # Save model checkpoint
981
        checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}"
982

983
984
        if self.hp_search_backend is not None and trial is not None:
            run_id = trial.number if self.hp_search_backend == HPSearchBackend.OPTUNA else tune.get_trial_id()
985
986
987
988
            run_name = self.hp_name(trial) if self.hp_name is not None else f"run-{run_id}"
            output_dir = os.path.join(self.args.output_dir, run_name, checkpoint_folder)
        else:
            output_dir = os.path.join(self.args.output_dir, checkpoint_folder)
989

990
            self.store_flos()
991
992
993
        self.save_model(output_dir)

        # Save optimizer and scheduler
994
995
        if self.sharded_dpp:
            self.optimizer.consolidate_state_dict()
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
        if is_torch_tpu_available():
            xm.rendezvous("saving_optimizer_states")
            xm.save(self.optimizer.state_dict(), os.path.join(output_dir, "optimizer.pt"))
            with warnings.catch_warnings(record=True) as caught_warnings:
                xm.save(self.lr_scheduler.state_dict(), os.path.join(output_dir, "scheduler.pt"))
                reissue_pt_warnings(caught_warnings)
        elif self.is_world_process_zero():
            torch.save(self.optimizer.state_dict(), os.path.join(output_dir, "optimizer.pt"))
            with warnings.catch_warnings(record=True) as caught_warnings:
                torch.save(self.lr_scheduler.state_dict(), os.path.join(output_dir, "scheduler.pt"))
            reissue_pt_warnings(caught_warnings)

        # Determine the new best metric / best model checkpoint
Sylvain Gugger's avatar
Sylvain Gugger committed
1009
        if metrics is not None and self.args.metric_for_best_model is not None:
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
            metric_to_check = self.args.metric_for_best_model
            if not metric_to_check.startswith("eval_"):
                metric_to_check = f"eval_{metric_to_check}"
            metric_value = metrics[metric_to_check]

            operator = np.greater if self.args.greater_is_better else np.less
            if (
                self.state.best_metric is None
                or self.state.best_model_checkpoint is None
                or operator(metric_value, self.state.best_metric)
            ):
                self.state.best_metric = metric_value
                self.state.best_model_checkpoint = output_dir

        # Save the Trainer state
        if self.is_world_process_zero():
            self.state.save_to_json(os.path.join(output_dir, "trainer_state.json"))

        # Maybe delete some older checkpoints.
        if self.is_world_process_zero():
            self._rotate_checkpoints(use_mtime=True)

Sylvain Gugger's avatar
Sylvain Gugger committed
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
    def _load_optimizer_and_scheduler(self, model_path):
        """If optimizer and scheduler states exist, load them."""
        if (
            model_path is not None
            and os.path.isfile(os.path.join(model_path, "optimizer.pt"))
            and os.path.isfile(os.path.join(model_path, "scheduler.pt"))
        ):
            # Load in optimizer and scheduler states
            if is_torch_tpu_available():
                # On TPU we have to take some extra precautions to properly load the states on the right device.
                optimizer_state = torch.load(os.path.join(model_path, "optimizer.pt"), map_location="cpu")
                with warnings.catch_warnings(record=True) as caught_warnings:
                    lr_scheduler_state = torch.load(os.path.join(model_path, "scheduler.pt"), map_location="cpu")
                reissue_pt_warnings(caught_warnings)

                xm.send_cpu_data_to_device(optimizer_state, self.args.device)
                xm.send_cpu_data_to_device(lr_scheduler_state, self.args.device)

                self.optimizer.load_state_dict(optimizer_state)
                self.lr_scheduler.load_state_dict(lr_scheduler_state)
            else:
                self.optimizer.load_state_dict(
                    torch.load(os.path.join(model_path, "optimizer.pt"), map_location=self.args.device)
                )
                with warnings.catch_warnings(record=True) as caught_warnings:
                    self.lr_scheduler.load_state_dict(torch.load(os.path.join(model_path, "scheduler.pt")))
                reissue_pt_warnings(caught_warnings)

1060
1061
1062
1063
1064
1065
1066
    def hyperparameter_search(
        self,
        hp_space: Optional[Callable[["optuna.Trial"], Dict[str, float]]] = None,
        compute_objective: Optional[Callable[[Dict[str, float]], float]] = None,
        n_trials: int = 20,
        direction: str = "minimize",
        backend: Optional[Union["str", HPSearchBackend]] = None,
1067
        hp_name: Optional[Callable[["optuna.Trial"], str]] = None,
1068
1069
1070
        **kwargs
    ) -> BestRun:
        """
1071
1072
1073
        Launch an hyperparameter search using ``optuna`` or ``Ray Tune``. The optimized quantity is determined by
        :obj:`compute_objectie`, which defaults to a function returning the evaluation loss when no metric is provided,
        the sum of all metrics otherwise.
1074

Sylvain Gugger's avatar
Sylvain Gugger committed
1075
1076
1077
1078
1079
1080
1081
        .. warning::

            To use this method, you need to have provided a ``model_init`` when initializing your
            :class:`~transformers.Trainer`: we need to reinitialize the model at each new run. This is incompatible
            with the ``optimizers`` argument, so you need to subclass :class:`~transformers.Trainer` and override the
            method :meth:`~transformers.Trainer.create_optimizer_and_scheduler` for custom optimizer/scheduler.

1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
        Args:
            hp_space (:obj:`Callable[["optuna.Trial"], Dict[str, float]]`, `optional`):
                A function that defines the hyperparameter search space. Will default to
                :func:`~transformers.trainer_utils.default_hp_space_optuna` or
                :func:`~transformers.trainer_utils.default_hp_space_ray` depending on your backend.
            compute_objective (:obj:`Callable[[Dict[str, float]], float]`, `optional`):
                A function computing the objective to minimize or maximize from the metrics returned by the
                :obj:`evaluate` method. Will default to :func:`~transformers.trainer_utils.default_compute_objective`.
            n_trials (:obj:`int`, `optional`, defaults to 100):
                The number of trial runs to test.
            direction(:obj:`str`, `optional`, defaults to :obj:`"minimize"`):
                Whether to optimize greater or lower objects. Can be :obj:`"minimize"` or :obj:`"maximize"`, you should
                pick :obj:`"minimize"` when optimizing the validation loss, :obj:`"maximize"` when optimizing one or
                several metrics.
            backend(:obj:`str` or :class:`~transformers.training_utils.HPSearchBackend`, `optional`):
                The backend to use for hyperparameter search. Will default to optuna or Ray Tune, depending on which
                one is installed. If both are installed, will default to optuna.
            kwargs:
                Additional keyword arguments passed along to :obj:`optuna.create_study` or :obj:`ray.tune.run`. For
                more information see:

Sylvain Gugger's avatar
Sylvain Gugger committed
1103
1104
1105
1106
                - the documentation of `optuna.create_study
                  <https://optuna.readthedocs.io/en/stable/reference/alias_generated/optuna.create_study.html#optuna.create_study>`__
                - the documentation of `tune.run
                  <https://docs.ray.io/en/latest/tune/api_docs/execution.html#tune-run>`__
1107
1108

        Returns:
Tiger's avatar
Tiger committed
1109
            :class:`transformers.trainer_utils.BestRun`: All the information about the best run.
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
        """
        if backend is None:
            backend = default_hp_search_backend()
            if backend is None:
                raise RuntimeError(
                    "At least one of optuna or ray should be installed. "
                    "To install optuna run `pip install optuna`."
                    "To install ray run `pip install ray[tune]`."
                )
        backend = HPSearchBackend(backend)
        if backend == HPSearchBackend.OPTUNA and not is_optuna_available():
Sylvain Gugger's avatar
Sylvain Gugger committed
1121
            raise RuntimeError("You picked the optuna backend, but it is not installed. Use `pip install optuna`.")
1122
        if backend == HPSearchBackend.RAY and not is_ray_tune_available():
1123
            raise RuntimeError(
Sylvain Gugger's avatar
Sylvain Gugger committed
1124
                "You picked the Ray Tune backend, but it is not installed. Use `pip install 'ray[tune]'`."
1125
1126
            )
        self.hp_search_backend = backend
Sylvain Gugger's avatar
Sylvain Gugger committed
1127
1128
1129
1130
1131
        if self.model_init is None:
            raise RuntimeError(
                "To use hyperparameter search, you need to pass your model through a model_init function."
            )

1132
        self.hp_space = default_hp_space[backend] if hp_space is None else hp_space
1133
        self.hp_name = hp_name
1134
1135
        self.compute_objective = default_compute_objective if compute_objective is None else compute_objective

1136
1137
        run_hp_search = run_hp_search_optuna if backend == HPSearchBackend.OPTUNA else run_hp_search_ray
        best_run = run_hp_search(self, n_trials, direction, **kwargs)
1138
1139
1140
1141

        self.hp_search_backend = None
        return best_run

Sylvain Gugger's avatar
Sylvain Gugger committed
1142
    def log(self, logs: Dict[str, float]) -> None:
1143
1144
1145
1146
1147
1148
1149
1150
1151
        """
        Log :obj:`logs` on the various objects watching training.

        Subclass and override this method to inject custom behavior.

        Args:
            logs (:obj:`Dict[str, float]`):
                The values to log.
        """
1152
1153
        if self.state.epoch is not None:
            logs["epoch"] = self.state.epoch
1154

Sylvain Gugger's avatar
Sylvain Gugger committed
1155
        self.control = self.callback_handler.on_log(self.args, self.state, self.control, logs)
1156
1157
        output = {**logs, **{"step": self.state.global_step}}
        self.state.log_history.append(output)
Julien Chaumond's avatar
Julien Chaumond committed
1158

sgugger's avatar
Fix CI  
sgugger committed
1159
    def _prepare_inputs(self, inputs: Dict[str, Union[torch.Tensor, Any]]) -> Dict[str, Union[torch.Tensor, Any]]:
1160
1161
1162
1163
        """
        Prepare :obj:`inputs` before feeding them to the model, converting them to tensors if they are not already and
        handling potential state.
        """
Julien Chaumond's avatar
Julien Chaumond committed
1164
        for k, v in inputs.items():
1165
1166
            if isinstance(v, torch.Tensor):
                inputs[k] = v.to(self.args.device)
Julien Chaumond's avatar
Julien Chaumond committed
1167

1168
1169
        if self.args.past_index >= 0 and self._past is not None:
            inputs["mems"] = self._past
1170

1171
1172
        return inputs

1173
    def training_step(self, model: nn.Module, inputs: Dict[str, Union[torch.Tensor, Any]]) -> torch.Tensor:
1174
        """
1175
        Perform a training step on a batch of inputs.
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188

        Subclass and override to inject custom behavior.

        Args:
            model (:obj:`nn.Module`):
                The model to train.
            inputs (:obj:`Dict[str, Union[torch.Tensor, Any]]`):
                The inputs and targets of the model.

                The dictionary will be unpacked before being fed to the model. Most models expect the targets under the
                argument :obj:`labels`. Check your model's documentation for all accepted arguments.

        Return:
1189
            :obj:`torch.Tensor`: The tensor with training loss on this batch.
1190
1191
1192
        """

        model.train()
1193
        inputs = self._prepare_inputs(inputs)
1194

1195
        if self.use_amp:
1196
            with autocast():
Sylvain Gugger's avatar
Sylvain Gugger committed
1197
                loss = self.compute_loss(model, inputs)
1198
        else:
Sylvain Gugger's avatar
Sylvain Gugger committed
1199
            loss = self.compute_loss(model, inputs)
1200

Julien Chaumond's avatar
Julien Chaumond committed
1201
1202
        if self.args.n_gpu > 1:
            loss = loss.mean()  # mean() to average on multi-gpu parallel training
1203

Julien Chaumond's avatar
Julien Chaumond committed
1204
1205
1206
        if self.args.gradient_accumulation_steps > 1:
            loss = loss / self.args.gradient_accumulation_steps

1207
        if self.use_amp:
1208
            self.scaler.scale(loss).backward()
1209
        elif self.use_apex:
1210
            with amp.scale_loss(loss, self.optimizer) as scaled_loss:
Julien Chaumond's avatar
Julien Chaumond committed
1211
1212
1213
1214
                scaled_loss.backward()
        else:
            loss.backward()

1215
        return loss.detach()
Julien Chaumond's avatar
Julien Chaumond committed
1216

Sylvain Gugger's avatar
Sylvain Gugger committed
1217
1218
1219
1220
1221
1222
1223
1224
    def compute_loss(self, model, inputs):
        """
        How the loss is computed by Trainer. By default, all models return the loss in the first element.

        Subclass and override for custom behavior.
        """
        outputs = model(**inputs)
        # Save past state if it exists
1225
        # TODO: this needs to be fixed and made cleaner later.
Sylvain Gugger's avatar
Sylvain Gugger committed
1226
1227
        if self.args.past_index >= 0:
            self._past = outputs[self.args.past_index]
Sylvain Gugger's avatar
Sylvain Gugger committed
1228
1229
1230
1231
1232
1233

        if self.label_smoother is not None and "labels" in inputs:
            return self.label_smoother(outputs, inputs["labels"])
        else:
            # We don't use .loss here since the model may return tuples instead of ModelOutput.
            return outputs["loss"] if isinstance(outputs, dict) else outputs[0]
Sylvain Gugger's avatar
Sylvain Gugger committed
1234

1235
1236
    def is_local_process_zero(self) -> bool:
        """
Sylvain Gugger's avatar
Sylvain Gugger committed
1237
1238
        Whether or not this process is the local (e.g., on one machine if training in a distributed fashion on several
        machines) main process.
1239
        """
1240
        if is_torch_tpu_available():
Lysandre Debut's avatar
Lysandre Debut committed
1241
1242
1243
1244
            return xm.is_master_ordinal(local=True)
        else:
            return self.args.local_rank in [-1, 0]

1245
1246
    def is_world_process_zero(self) -> bool:
        """
Sylvain Gugger's avatar
Sylvain Gugger committed
1247
1248
        Whether or not this process is the global main process (when training in a distributed fashion on several
        machines, this is only going to be :obj:`True` for one process).
Julien Chaumond's avatar
Julien Chaumond committed
1249
        """
1250
        if is_torch_tpu_available():
Lysandre Debut's avatar
Lysandre Debut committed
1251
1252
1253
            return xm.is_master_ordinal(local=False)
        else:
            return self.args.local_rank == -1 or torch.distributed.get_rank() == 0
Julien Chaumond's avatar
Julien Chaumond committed
1254
1255
1256

    def save_model(self, output_dir: Optional[str] = None):
        """
1257
        Will save the model, so you can reload it using :obj:`from_pretrained()`.
Julien Chaumond's avatar
Julien Chaumond committed
1258

1259
        Will only save from the world_master process (unless in TPUs).
Julien Chaumond's avatar
Julien Chaumond committed
1260
        """
1261

1262
        if is_torch_tpu_available():
1263
            self._save_tpu(output_dir)
1264
        elif self.is_world_process_zero():
Julien Chaumond's avatar
Julien Chaumond committed
1265
1266
            self._save(output_dir)

1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
    def _save_tpu(self, output_dir: Optional[str] = None):
        output_dir = output_dir if output_dir is not None else self.args.output_dir
        logger.info("Saving model checkpoint to %s", output_dir)

        if xm.is_master_ordinal():
            os.makedirs(output_dir, exist_ok=True)
            torch.save(self.args, os.path.join(output_dir, "training_args.bin"))

        # Save a trained model and configuration using `save_pretrained()`.
        # They can then be reloaded using `from_pretrained()`
        xm.rendezvous("saving_checkpoint")
1278
1279
1280
1281
1282
1283
        if not isinstance(self.model, PreTrainedModel):
            logger.info("Trainer.model is not a `PreTrainedModel`, only saving its state dict.")
            state_dict = self.model.state_dict()
            xm.save(state_dict, os.path.join(output_dir, WEIGHTS_NAME))
        else:
            self.model.save_pretrained(output_dir)
Sylvain Gugger's avatar
Sylvain Gugger committed
1284
        if self.tokenizer is not None and self.is_world_process_zero():
1285
            self.tokenizer.save_pretrained(output_dir)
1286

Julien Chaumond's avatar
Julien Chaumond committed
1287
1288
1289
1290
1291
1292
1293
    def _save(self, output_dir: Optional[str] = None):
        output_dir = output_dir if output_dir is not None else self.args.output_dir
        os.makedirs(output_dir, exist_ok=True)
        logger.info("Saving model checkpoint to %s", output_dir)
        # Save a trained model and configuration using `save_pretrained()`.
        # They can then be reloaded using `from_pretrained()`
        if not isinstance(self.model, PreTrainedModel):
1294
1295
1296
1297
1298
            logger.info("Trainer.model is not a `PreTrainedModel`, only saving its state dict.")
            state_dict = self.model.state_dict()
            torch.save(state_dict, os.path.join(output_dir, WEIGHTS_NAME))
        else:
            self.model.save_pretrained(output_dir)
Sylvain Gugger's avatar
Sylvain Gugger committed
1299
        if self.tokenizer is not None and self.is_world_process_zero():
1300
            self.tokenizer.save_pretrained(output_dir)
Julien Chaumond's avatar
Julien Chaumond committed
1301
1302
1303

        # Good practice: save your training arguments together with the trained model
        torch.save(self.args, os.path.join(output_dir, "training_args.bin"))
1304

1305
    def store_flos(self):
1306
        # Storing the number of floating-point operations that went into the model
1307
        if self._total_flos is not None:
1308
            if self.args.local_rank != -1:
1309
                self.state.total_flos = distributed_broadcast_scalars([self._total_flos]).sum().item()
1310
            else:
1311
                self.state.total_flos = self._total_flos
Julien Chaumond's avatar
Julien Chaumond committed
1312
1313
1314
1315

    def _sorted_checkpoints(self, checkpoint_prefix=PREFIX_CHECKPOINT_DIR, use_mtime=False) -> List[str]:
        ordering_and_checkpoint_path = []

1316
        glob_checkpoints = [str(x) for x in Path(self.args.output_dir).glob(f"{checkpoint_prefix}-*")]
Julien Chaumond's avatar
Julien Chaumond committed
1317
1318
1319
1320
1321

        for path in glob_checkpoints:
            if use_mtime:
                ordering_and_checkpoint_path.append((os.path.getmtime(path), path))
            else:
1322
                regex_match = re.match(f".*{checkpoint_prefix}-([0-9]+)", path)
Julien Chaumond's avatar
Julien Chaumond committed
1323
1324
1325
1326
1327
                if regex_match and regex_match.groups():
                    ordering_and_checkpoint_path.append((int(regex_match.groups()[0]), path))

        checkpoints_sorted = sorted(ordering_and_checkpoint_path)
        checkpoints_sorted = [checkpoint[1] for checkpoint in checkpoints_sorted]
1328
1329
        # Make sure we don't delete the best model.
        if self.state.best_model_checkpoint is not None:
1330
            best_model_index = checkpoints_sorted.index(str(Path(self.state.best_model_checkpoint)))
1331
            checkpoints_sorted[best_model_index], checkpoints_sorted[-1] = (
1332
1333
1334
                checkpoints_sorted[-1],
                checkpoints_sorted[best_model_index],
            )
Julien Chaumond's avatar
Julien Chaumond committed
1335
1336
1337
        return checkpoints_sorted

    def _rotate_checkpoints(self, use_mtime=False) -> None:
1338
        if self.args.save_total_limit is None or self.args.save_total_limit <= 0:
Julien Chaumond's avatar
Julien Chaumond committed
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
            return

        # Check if we should delete older checkpoint(s)
        checkpoints_sorted = self._sorted_checkpoints(use_mtime=use_mtime)
        if len(checkpoints_sorted) <= self.args.save_total_limit:
            return

        number_of_checkpoints_to_delete = max(0, len(checkpoints_sorted) - self.args.save_total_limit)
        checkpoints_to_be_deleted = checkpoints_sorted[:number_of_checkpoints_to_delete]
        for checkpoint in checkpoints_to_be_deleted:
            logger.info("Deleting older checkpoint [{}] due to args.save_total_limit".format(checkpoint))
            shutil.rmtree(checkpoint)

1352
    def evaluate(
1353
1354
1355
1356
        self,
        eval_dataset: Optional[Dataset] = None,
        ignore_keys: Optional[List[str]] = None,
        metric_key_prefix: str = "eval",
1357
    ) -> Dict[str, float]:
Julien Chaumond's avatar
Julien Chaumond committed
1358
        """
1359
        Run evaluation and returns metrics.
Julien Chaumond's avatar
Julien Chaumond committed
1360

Sylvain Gugger's avatar
Sylvain Gugger committed
1361
1362
        The calling script will be responsible for providing a method to compute metrics, as they are task-dependent
        (pass it to the init :obj:`compute_metrics` argument).
Julien Chaumond's avatar
Julien Chaumond committed
1363

1364
1365
        You can also subclass and override this method to inject custom behavior.

Julien Chaumond's avatar
Julien Chaumond committed
1366
        Args:
1367
            eval_dataset (:obj:`Dataset`, `optional`):
1368
                Pass a dataset if you wish to override :obj:`self.eval_dataset`. If it is an :obj:`datasets.Dataset`,
Sylvain Gugger's avatar
Sylvain Gugger committed
1369
1370
                columns not accepted by the ``model.forward()`` method are automatically removed. It must implement the
                :obj:`__len__` method.
1371
1372
1373
            ignore_keys (:obj:`Lst[str]`, `optional`):
                A list of keys in the output of your model (if it is a dictionary) that should be ignored when
                gathering predictions.
1374
1375
1376
            metric_key_prefix (:obj:`str`, `optional`, defaults to :obj:`"eval"`):
                An optional prefix to be used as the metrics key prefix. For example the metrics "bleu" will be named
                "eval_bleu" if the prefix is "eval" (default)
1377

Julien Chaumond's avatar
Julien Chaumond committed
1378
        Returns:
1379
1380
            A dictionary containing the evaluation loss and the potential metrics computed from the predictions. The
            dictionary also contains the epoch number which comes from the training state.
Julien Chaumond's avatar
Julien Chaumond committed
1381
        """
1382
1383
1384
        if eval_dataset is not None and not isinstance(eval_dataset, collections.abc.Sized):
            raise ValueError("eval_dataset must implement __len__")

Julien Chaumond's avatar
Julien Chaumond committed
1385
        eval_dataloader = self.get_eval_dataloader(eval_dataset)
1386
        start_time = time.time()
Julien Chaumond's avatar
Julien Chaumond committed
1387

1388
1389
1390
1391
1392
1393
        output = self.prediction_loop(
            eval_dataloader,
            description="Evaluation",
            # No point gathering the predictions if there are no metrics, otherwise we defer to
            # self.args.prediction_loss_only
            prediction_loss_only=True if self.compute_metrics is None else None,
1394
            ignore_keys=ignore_keys,
1395
            metric_key_prefix=metric_key_prefix,
1396
        )
Lysandre Debut's avatar
Lysandre Debut committed
1397

1398
1399
        n_samples = len(eval_dataset if eval_dataset is not None else self.eval_dataset)
        output.metrics.update(speed_metrics(metric_key_prefix, start_time, n_samples))
1400
        self.log(output.metrics)
1401

1402
        if self.args.tpu_metrics_debug or self.args.debug:
Lysandre Debut's avatar
Lysandre Debut committed
1403
1404
1405
            # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
            xm.master_print(met.metrics_report())

Sylvain Gugger's avatar
Sylvain Gugger committed
1406
        self.control = self.callback_handler.on_evaluate(self.args, self.state, self.control, output.metrics)
Julien Chaumond's avatar
Julien Chaumond committed
1407
1408
        return output.metrics

1409
1410
1411
    def predict(
        self, test_dataset: Dataset, ignore_keys: Optional[List[str]] = None, metric_key_prefix: str = "eval"
    ) -> PredictionOutput:
Julien Chaumond's avatar
Julien Chaumond committed
1412
        """
1413
        Run prediction and returns predictions and potential metrics.
Julien Chaumond's avatar
Julien Chaumond committed
1414

Sylvain Gugger's avatar
Sylvain Gugger committed
1415
1416
        Depending on the dataset and your use case, your test dataset may contain labels. In that case, this method
        will also return metrics, like in :obj:`evaluate()`.
1417
1418
1419

        Args:
            test_dataset (:obj:`Dataset`):
1420
                Dataset to run the predictions on. If it is an :obj:`datasets.Dataset`, columns not accepted by the
1421
                ``model.forward()`` method are automatically removed. Has to implement the method :obj:`__len__`
1422
1423
1424
            ignore_keys (:obj:`Lst[str]`, `optional`):
                A list of keys in the output of your model (if it is a dictionary) that should be ignored when
                gathering predictions.
1425
1426
1427
            metric_key_prefix (:obj:`str`, `optional`, defaults to :obj:`"eval"`):
                An optional prefix to be used as the metrics key prefix. For example the metrics "bleu" will be named
                "eval_bleu" if the prefix is "eval" (default)
1428

1429
1430
1431
1432
1433
1434
        .. note::

            If your predictions or labels have different sequence length (for instance because you're doing dynamic
            padding in a token classification task) the predictions will be padded (on the right) to allow for
            concatenation into one array. The padding index is -100.

Sylvain Gugger's avatar
Sylvain Gugger committed
1435
1436
1437
1438
1439
1440
        Returns: `NamedTuple` A namedtuple with the following keys:

            - predictions (:obj:`np.ndarray`): The predictions on :obj:`test_dataset`.
            - label_ids (:obj:`np.ndarray`, `optional`): The labels (if the dataset contained some).
            - metrics (:obj:`Dict[str, float]`, `optional`): The potential dictionary of metrics (if the dataset
              contained labels).
Julien Chaumond's avatar
Julien Chaumond committed
1441
        """
1442
1443
1444
        if test_dataset is not None and not isinstance(test_dataset, collections.abc.Sized):
            raise ValueError("test_dataset must implement __len__")

Julien Chaumond's avatar
Julien Chaumond committed
1445
        test_dataloader = self.get_test_dataloader(test_dataset)
1446
        start_time = time.time()
1447

1448
        output = self.prediction_loop(
1449
1450
            test_dataloader, description="Prediction", ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix
        )
1451
1452
        output.metrics.update(speed_metrics(metric_key_prefix, start_time, len(test_dataset)))
        return output
Julien Chaumond's avatar
Julien Chaumond committed
1453

1454
    def prediction_loop(
1455
1456
1457
1458
1459
        self,
        dataloader: DataLoader,
        description: str,
        prediction_loss_only: Optional[bool] = None,
        ignore_keys: Optional[List[str]] = None,
1460
        metric_key_prefix: str = "eval",
Julien Chaumond's avatar
Julien Chaumond committed
1461
1462
    ) -> PredictionOutput:
        """
1463
        Prediction/evaluation loop, shared by :obj:`Trainer.evaluate()` and :obj:`Trainer.predict()`.
Julien Chaumond's avatar
Julien Chaumond committed
1464
1465
1466

        Works both with or without labels.
        """
1467
1468
        if not isinstance(dataloader.dataset, collections.abc.Sized):
            raise ValueError("dataset must implement __len__")
1469
1470
1471
        prediction_loss_only = (
            prediction_loss_only if prediction_loss_only is not None else self.args.prediction_loss_only
        )
Julien Chaumond's avatar
Julien Chaumond committed
1472

1473
        model = self.model
Julien Chaumond's avatar
Julien Chaumond committed
1474
        # multi-gpu eval
1475
        if self.args.n_gpu > 1 and not self.args.model_parallel:
1476
1477
1478
            model = torch.nn.DataParallel(model)
        # Note: in torch.distributed mode, there's no point in wrapping the model
        # inside a DistributedDataParallel as we'll be under `no_grad` anyways.
Julien Chaumond's avatar
Julien Chaumond committed
1479

1480
        batch_size = dataloader.batch_size
1481
        num_examples = self.num_examples(dataloader)
Julien Chaumond's avatar
Julien Chaumond committed
1482
        logger.info("***** Running %s *****", description)
1483
        logger.info("  Num examples = %d", num_examples)
1484
        logger.info("  Batch size = %d", batch_size)
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
        losses_host: torch.Tensor = None
        preds_host: Union[torch.Tensor, List[torch.Tensor]] = None
        labels_host: Union[torch.Tensor, List[torch.Tensor]] = None

        world_size = 1
        if is_torch_tpu_available():
            world_size = xm.xrt_world_size()
        elif self.args.local_rank != -1:
            world_size = torch.distributed.get_world_size()
        world_size = max(1, world_size)

        eval_losses_gatherer = DistributedTensorGatherer(world_size, num_examples, make_multiple_of=batch_size)
1497
1498
1499
        if not prediction_loss_only:
            preds_gatherer = DistributedTensorGatherer(world_size, num_examples)
            labels_gatherer = DistributedTensorGatherer(world_size, num_examples)
1500

Julien Chaumond's avatar
Julien Chaumond committed
1501
1502
        model.eval()

1503
        if is_torch_tpu_available():
1504
1505
            dataloader = pl.ParallelLoader(dataloader, [self.args.device]).per_device_loader(self.args.device)

1506
        if self.args.past_index >= 0:
1507
            self._past = None
1508

Sylvain Gugger's avatar
Sylvain Gugger committed
1509
1510
        self.callback_handler.eval_dataloader = dataloader

1511
        for step, inputs in enumerate(dataloader):
1512
            loss, logits, labels = self.prediction_step(model, inputs, prediction_loss_only, ignore_keys=ignore_keys)
1513
            if loss is not None:
1514
1515
                losses = loss.repeat(batch_size)
                losses_host = losses if losses_host is None else torch.cat((losses_host, losses), dim=0)
1516
            if logits is not None:
1517
                preds_host = logits if preds_host is None else nested_concat(preds_host, logits, padding_index=-100)
1518
            if labels is not None:
1519
                labels_host = labels if labels_host is None else nested_concat(labels_host, labels, padding_index=-100)
Sylvain Gugger's avatar
Sylvain Gugger committed
1520
            self.control = self.callback_handler.on_prediction_step(self.args, self.state, self.control)
Julien Chaumond's avatar
Julien Chaumond committed
1521

1522
1523
1524
            # Gather all tensors and put them back on the CPU if we have done enough accumulation steps.
            if self.args.eval_accumulation_steps is not None and (step + 1) % self.args.eval_accumulation_steps == 0:
                eval_losses_gatherer.add_arrays(self._gather_and_numpify(losses_host, "eval_losses"))
1525
1526
1527
                if not prediction_loss_only:
                    preds_gatherer.add_arrays(self._gather_and_numpify(preds_host, "eval_preds"))
                    labels_gatherer.add_arrays(self._gather_and_numpify(labels_host, "eval_label_ids"))
1528
1529
1530
1531

                # Set back to None to begin a new accumulation
                losses_host, preds_host, labels_host = None, None, None

1532
1533
1534
        if self.args.past_index and hasattr(self, "_past"):
            # Clean the state at the end of the evaluation loop
            delattr(self, "_past")
Julien Chaumond's avatar
Julien Chaumond committed
1535

1536
1537
        # Gather all remaining tensors and put them back on the CPU
        eval_losses_gatherer.add_arrays(self._gather_and_numpify(losses_host, "eval_losses"))
1538
1539
1540
        if not prediction_loss_only:
            preds_gatherer.add_arrays(self._gather_and_numpify(preds_host, "eval_preds"))
            labels_gatherer.add_arrays(self._gather_and_numpify(labels_host, "eval_label_ids"))
1541
1542

        eval_loss = eval_losses_gatherer.finalize()
1543
1544
        preds = preds_gatherer.finalize() if not prediction_loss_only else None
        label_ids = labels_gatherer.finalize() if not prediction_loss_only else None
Lysandre Debut's avatar
Lysandre Debut committed
1545

Julien Chaumond's avatar
Julien Chaumond committed
1546
1547
1548
1549
        if self.compute_metrics is not None and preds is not None and label_ids is not None:
            metrics = self.compute_metrics(EvalPrediction(predictions=preds, label_ids=label_ids))
        else:
            metrics = {}
1550
1551

        if eval_loss is not None:
1552
            metrics[f"{metric_key_prefix}_loss"] = eval_loss.mean().item()
1553

1554
        # Prefix all keys with metric_key_prefix + '_'
1555
        for key in list(metrics.keys()):
1556
1557
            if not key.startswith(f"{metric_key_prefix}_"):
                metrics[f"{metric_key_prefix}_{key}"] = metrics.pop(key)
Julien Chaumond's avatar
Julien Chaumond committed
1558
1559

        return PredictionOutput(predictions=preds, label_ids=label_ids, metrics=metrics)
1560

1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
    def _gather_and_numpify(self, tensors, name):
        """
        Gather value of `tensors` (tensor or list/tuple of nested tensors) and convert them to numpy before
        concatenating them to `gathered`
        """
        if tensors is None:
            return
        if is_torch_tpu_available():
            tensors = nested_xla_mesh_reduce(tensors, name)
        elif self.args.local_rank != -1:
            tensors = distributed_concat(tensors)

        return nested_numpify(tensors)

1575
    def prediction_step(
1576
1577
1578
1579
1580
        self,
        model: nn.Module,
        inputs: Dict[str, Union[torch.Tensor, Any]],
        prediction_loss_only: bool,
        ignore_keys: Optional[List[str]] = None,
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
    ) -> Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:
        """
        Perform an evaluation step on :obj:`model` using obj:`inputs`.

        Subclass and override to inject custom behavior.

        Args:
            model (:obj:`nn.Module`):
                The model to evaluate.
            inputs (:obj:`Dict[str, Union[torch.Tensor, Any]]`):
                The inputs and targets of the model.

                The dictionary will be unpacked before being fed to the model. Most models expect the targets under the
                argument :obj:`labels`. Check your model's documentation for all accepted arguments.
            prediction_loss_only (:obj:`bool`):
                Whether or not to return the loss only.
1597
1598
1599
            ignore_keys (:obj:`Lst[str]`, `optional`):
                A list of keys in the output of your model (if it is a dictionary) that should be ignored when
                gathering predictions.
1600
1601

        Return:
Sylvain Gugger's avatar
Sylvain Gugger committed
1602
1603
            Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]: A tuple with the loss, logits and
            labels (each being optional).
1604
        """
1605
        has_labels = all(inputs.get(k) is not None for k in self.label_names)
1606
        inputs = self._prepare_inputs(inputs)
1607
1608
1609
1610
1611
        if ignore_keys is None:
            if hasattr(self.model, "config"):
                ignore_keys = getattr(self.model.config, "keys_to_ignore_at_inference", [])
            else:
                ignore_keys = []
1612
1613

        with torch.no_grad():
1614
            if self.use_amp:
luyug's avatar
luyug committed
1615
1616
1617
1618
                with autocast():
                    outputs = model(**inputs)
            else:
                outputs = model(**inputs)
1619
            if has_labels:
Sylvain Gugger's avatar
Sylvain Gugger committed
1620
1621
1622
1623
                if self.label_smoother is not None and "labels" in inputs:
                    loss = self.label_smoother(outputs, inputs["labels"]).mean().detach()
                else:
                    loss = (outputs["loss"] if isinstance(outputs, dict) else outputs[0]).mean().detach()
1624
1625
1626
1627
                if isinstance(outputs, dict):
                    logits = tuple(v for k, v in outputs.items() if k not in ignore_keys + ["loss"])
                else:
                    logits = outputs[1:]
1628
1629
            else:
                loss = None
1630
1631
1632
1633
1634
                if isinstance(outputs, dict):
                    logits = tuple(v for k, v in outputs.items() if k not in ignore_keys)
                else:
                    logits = outputs
            # TODO: this needs to be fixed and made cleaner later.
1635
1636
1637
1638
1639
1640
            if self.args.past_index >= 0:
                self._past = outputs[self.args.past_index if has_labels else self.args.past_index - 1]

        if prediction_loss_only:
            return (loss, None, None)

1641
        logits = nested_detach(logits)
Sylvain Gugger's avatar
Sylvain Gugger committed
1642
1643
1644
1645
        if len(logits) == 1:
            logits = logits[0]

        if has_labels:
1646
            labels = nested_detach(tuple(inputs.get(name) for name in self.label_names))
Sylvain Gugger's avatar
Sylvain Gugger committed
1647
1648
1649
1650
1651
1652
            if len(labels) == 1:
                labels = labels[0]
        else:
            labels = None

        return (loss, logits, labels)
1653
1654
1655

    def floating_point_ops(self, inputs: Dict[str, Union[torch.Tensor, Any]]):
        """
Sylvain Gugger's avatar
Sylvain Gugger committed
1656
1657
1658
        For models that inherit from :class:`~transformers.PreTrainedModel`, uses that method to compute the number of
        floating point operations for every backward + forward pass. If using another model, either implement such a
        method in the model or subclass and override this method.
1659
1660
1661
1662
1663
1664
1665
1666

        Args:
            inputs (:obj:`Dict[str, Union[torch.Tensor, Any]]`):
                The inputs and targets of the model.

        Returns:
            :obj:`int`: The number of floating-point operations.
        """
1667
1668
        if hasattr(self.model, "floating_point_ops"):
            return self.model.floating_point_ops(inputs)
1669
1670
        else:
            return 0