trainer.py 90.2 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 gc
21
import inspect
22
import math
Julien Chaumond's avatar
Julien Chaumond committed
23
24
25
import os
import re
import shutil
26
import sys
27
import time
28
import warnings
29
from logging import StreamHandler
Julien Chaumond's avatar
Julien Chaumond committed
30
from pathlib import Path
31
from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
Julien Chaumond's avatar
Julien Chaumond committed
32
33


34
35
# Integrations must be imported before ML frameworks:
from .integrations import (  # isort: split
36
    default_hp_search_backend,
37
    get_reporting_integration_callbacks,
38
    hp_params,
39
    is_fairscale_available,
40
    is_optuna_available,
41
    is_ray_tune_available,
42
43
    run_hp_search_optuna,
    run_hp_search_ray,
44
    init_deepspeed,
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
Sylvain Gugger's avatar
Sylvain Gugger committed
57
58
59
60
61
62
63
from .file_utils import (
    WEIGHTS_NAME,
    is_apex_available,
    is_datasets_available,
    is_in_notebook,
    is_sagemaker_distributed_available,
    is_torch_tpu_available,
64
    is_training_run_on_sagemaker,
Sylvain Gugger's avatar
Sylvain Gugger committed
65
)
66
from .modeling_utils import PreTrainedModel, unwrap_model
Sylvain Gugger's avatar
Sylvain Gugger committed
67
from .optimization import Adafactor, AdamW, get_scheduler
68
from .tokenization_utils_base import PreTrainedTokenizerBase
Sylvain Gugger's avatar
Sylvain Gugger committed
69
70
71
72
73
74
75
76
77
78
from .trainer_callback import (
    CallbackHandler,
    DefaultFlowCallback,
    PrinterCallback,
    ProgressCallback,
    TrainerCallback,
    TrainerControl,
    TrainerState,
)
from .trainer_pt_utils import (
79
    DistributedLengthGroupedSampler,
80
    DistributedTensorGatherer,
Sylvain Gugger's avatar
Sylvain Gugger committed
81
    LabelSmoother,
82
    LengthGroupedSampler,
Sylvain Gugger's avatar
Sylvain Gugger committed
83
84
85
    SequentialDistributedSampler,
    distributed_broadcast_scalars,
    distributed_concat,
86
    get_parameter_names,
Sylvain Gugger's avatar
Sylvain Gugger committed
87
88
89
90
91
92
    nested_concat,
    nested_detach,
    nested_numpify,
    nested_xla_mesh_reduce,
    reissue_pt_warnings,
)
93
94
95
96
97
98
from .trainer_utils import (
    PREFIX_CHECKPOINT_DIR,
    BestRun,
    EvalPrediction,
    HPSearchBackend,
    PredictionOutput,
99
    ShardedDDPOption,
100
    TrainerMemoryTracker,
101
102
103
    TrainOutput,
    default_compute_objective,
    default_hp_space,
104
    denumpify_detensorize,
105
    get_last_checkpoint,
106
    set_seed,
107
    speed_metrics,
108
)
109
from .training_args import ParallelMode, TrainingArguments
Lysandre Debut's avatar
Lysandre Debut committed
110
from .utils import logging
111
from .utils.modeling_auto_mapping import MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES
Julien Chaumond's avatar
Julien Chaumond committed
112
113


114
_is_native_amp_available = False
115

Sylvain Gugger's avatar
Sylvain Gugger committed
116
DEFAULT_CALLBACKS = [DefaultFlowCallback]
117
DEFAULT_PROGRESS_CALLBACK = ProgressCallback
Sylvain Gugger's avatar
Sylvain Gugger committed
118

119
120
121
122
if is_in_notebook():
    from .utils.notebook import NotebookProgressCallback

    DEFAULT_PROGRESS_CALLBACK = NotebookProgressCallback
123

124
125
if is_apex_available():
    from apex import amp
126

127
if version.parse(torch.__version__) >= version.parse("1.6"):
128
    _is_native_amp_available = True
129
    from torch.cuda.amp import autocast
Julien Chaumond's avatar
Julien Chaumond committed
130

131
132
if is_datasets_available():
    import datasets
Julien Chaumond's avatar
Julien Chaumond committed
133

134
if is_torch_tpu_available():
Lysandre Debut's avatar
Lysandre Debut committed
135
136
137
138
    import torch_xla.core.xla_model as xm
    import torch_xla.debug.metrics as met
    import torch_xla.distributed.parallel_loader as pl

139
if is_fairscale_available():
140
    import fairscale
141
142
143
144
    from fairscale.nn.data_parallel import ShardedDataParallel as ShardedDDP
    from fairscale.optim import OSS
    from fairscale.optim.grad_scaler import ShardedGradScaler

145
146
147
148
149
    if version.parse(fairscale.__version__) >= version.parse("0.3"):
        from fairscale.nn.data_parallel import FullyShardedDataParallel as FullyShardedDDP
    else:
        FullyShardedDDP = None

Sylvain Gugger's avatar
Sylvain Gugger committed
150
151
152
153
154
if is_sagemaker_distributed_available():
    import smdistributed.dataparallel.torch.distributed as dist
    from smdistributed.dataparallel.torch.parallel.distributed import DistributedDataParallel as DDP
else:
    import torch.distributed as dist
155

156
157
158
159
if is_training_run_on_sagemaker():
    logging.add_handler(StreamHandler(sys.stdout))


160
161
162
if TYPE_CHECKING:
    import optuna

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


class Trainer:
    """
Sylvain Gugger's avatar
Sylvain Gugger committed
168
    Trainer is a simple but feature-complete training and eval loop for PyTorch, optimized for 馃 Transformers.
169
170

    Args:
Sylvain Gugger's avatar
Sylvain Gugger committed
171
        model (:class:`~transformers.PreTrainedModel` or :obj:`torch.nn.Module`, `optional`):
172
            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
173
174
175
176
177
178

            .. 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.
179
        args (:class:`~transformers.TrainingArguments`, `optional`):
Sylvain Gugger's avatar
Sylvain Gugger committed
180
181
182
            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.
183
        data_collator (:obj:`DataCollator`, `optional`):
Sylvain Gugger's avatar
Sylvain Gugger committed
184
185
186
            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
187
        train_dataset (:obj:`torch.utils.data.dataset.Dataset`, `optional`):
188
            The dataset to use for training. If it is an :obj:`datasets.Dataset`, columns not accepted by the
189
            ``model.forward()`` method are automatically removed.
Sylvain Gugger's avatar
Sylvain Gugger committed
190
        eval_dataset (:obj:`torch.utils.data.dataset.Dataset`, `optional`):
191
             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
192
             ``model.forward()`` method are automatically removed.
193
194
195
196
        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.
197
198
199
        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.
200

Sylvain Gugger's avatar
Sylvain Gugger committed
201
202
            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
203
204
            layers, dropout probabilities etc).
        compute_metrics (:obj:`Callable[[EvalPrediction], Dict]`, `optional`):
205
            The function that will be used to compute metrics at evaluation. Must take a
Sylvain Gugger's avatar
Sylvain Gugger committed
206
207
208
209
            :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
210
211

            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
212
        optimizers (:obj:`Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR`, `optional`): A tuple
Sylvain Gugger's avatar
Sylvain Gugger committed
213
            containing the optimizer and the scheduler to use. Will default to an instance of
214
            :class:`~transformers.AdamW` on your model and a scheduler given by
Sylvain Gugger's avatar
Sylvain Gugger committed
215
            :func:`~transformers.get_linear_schedule_with_warmup` controlled by :obj:`args`.
216

217
218
219
220
221
222
223
224
225
226
    Important attributes:

        - **model** -- Always points to the core model. If using a transformers model, it will be a
          :class:`~transformers.PreTrainedModel` subclass.
        - **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 ``torch.nn.DistributedDataParallel``. If the
          inner model hasn't been wrapped, then ``self.model_wrapped`` is the same as ``self.model``.
        - **is_model_parallel** -- Whether or not a model has been switched to a model parallel mode (different from
          data parallelism, this means some of the model layers are split on different GPUs).
227
228
229
        - **place_model_on_device** -- Whether or not to automatically place the model on the device - it will be set
          to :obj:`False` if model parallel or deepspeed is used, or if the default
          ``TrainingArguments.place_model_on_device`` is overridden to return :obj:`False` .
230
231
        - **is_in_train** -- Whether or not a model is currently running ``train`` (e.g. when ``evaluate`` is called
          while in ``train``)
232

Julien Chaumond's avatar
Julien Chaumond committed
233
234
    """

235
    from .trainer_pt_utils import _get_learning_rate, log_metrics, metrics_format, save_metrics, save_state
236

Julien Chaumond's avatar
Julien Chaumond committed
237
238
    def __init__(
        self,
Sylvain Gugger's avatar
Sylvain Gugger committed
239
        model: Union[PreTrainedModel, torch.nn.Module] = None,
240
        args: TrainingArguments = None,
Julien Chaumond's avatar
Julien Chaumond committed
241
242
243
        data_collator: Optional[DataCollator] = None,
        train_dataset: Optional[Dataset] = None,
        eval_dataset: Optional[Dataset] = None,
244
        tokenizer: Optional["PreTrainedTokenizerBase"] = None,
245
        model_init: Callable[[], PreTrainedModel] = None,
Julien Chaumond's avatar
Julien Chaumond committed
246
        compute_metrics: Optional[Callable[[EvalPrediction], Dict]] = None,
Sylvain Gugger's avatar
Sylvain Gugger committed
247
        callbacks: Optional[List[TrainerCallback]] = None,
248
        optimizers: Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None),
Julien Chaumond's avatar
Julien Chaumond committed
249
    ):
Sylvain Gugger's avatar
Sylvain Gugger committed
250
        if args is None:
251
252
253
            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
254
255
256
        self.args = args
        # Seed must be set before instantiating the model when using model
        set_seed(self.args.seed)
257
        self.hp_name = None
258
        self.deepspeed = None
259
        self.is_in_train = False
260

261
262
263
264
        # memory metrics - must set up as early as possible
        self._memory_tracker = TrainerMemoryTracker(self.args.skip_memory_metrics)
        self._memory_tracker.start()

265
266
267
        # force device and distributed setup init explicitly
        args._setup_devices

268
269
270
271
272
273
274
275
276
277
278
279
280
281
        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
282

283
284
285
286
287
        if hasattr(model, "is_parallelizable") and model.is_parallelizable and model.model_parallel:
            self.is_model_parallel = True
        else:
            self.is_model_parallel = False

288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
        # Setup Sharded DDP training
        self.sharded_ddp = None
        if len(args.sharded_ddp) > 0:
            if args.deepspeed:
                raise ValueError(
                    "Using --sharded_ddp xxx together with --deepspeed is not possible, deactivate one of those flags."
                )

            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`.")
            elif ShardedDDPOption.SIMPLE not in args.sharded_ddp and FullyShardedDDP is None:
                raise ImportError(
                    "Sharded DDP in a mode other than simple training requires fairscale version >= 0.3, found "
                    f"{fairscale.__version__}. Upgrade your fairscale library: `pip install --upgrade fairscale`."
                )
            elif ShardedDDPOption.SIMPLE in args.sharded_ddp:
                self.sharded_ddp = ShardedDDPOption.SIMPLE
            elif ShardedDDPOption.ZERO_DP_2 in args.sharded_ddp:
                self.sharded_ddp = ShardedDDPOption.ZERO_DP_2
            elif ShardedDDPOption.ZERO_DP_3 in args.sharded_ddp:
                self.sharded_ddp = ShardedDDPOption.ZERO_DP_3

312
313
        # one place to sort out whether to place the model on device or not
        self.place_model_on_device = args.place_model_on_device
314
315
316
317
318
319
        if (
            self.is_model_parallel
            or (args.deepspeed and args.do_train)
            or (args.fp16_full_eval and not args.do_train)
            or (self.sharded_ddp in [ShardedDDPOption.ZERO_DP_2, ShardedDDPOption.ZERO_DP_3])
        ):
320
321
            self.place_model_on_device = False

322
323
        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
324
325
        self.train_dataset = train_dataset
        self.eval_dataset = eval_dataset
326
        self.tokenizer = tokenizer
327

Stas Bekman's avatar
Stas Bekman committed
328
329
        # postpone switching model to cuda when:
        # 1. MP - since we are trying to fit a much bigger than 1 gpu model
330
331
        # 2. fp16-enabled DeepSpeed loads the model in half the size and it doesn't need .to() anyway,
        #    and we only use deepspeed for training at the moment
332
        if self.place_model_on_device:
333
            model = model.to(args.device)
Stas Bekman's avatar
Stas Bekman committed
334
335
336

        # Force n_gpu to 1 to avoid DataParallel as MP will manage the GPUs
        if self.is_model_parallel:
337
            self.args._n_gpu = 1
338
339
340
341
342

        # 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
343
        self.compute_metrics = compute_metrics
344
        self.optimizer, self.lr_scheduler = optimizers
Sylvain Gugger's avatar
Sylvain Gugger committed
345
346
347
348
349
        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."
            )
350
351
        default_callbacks = DEFAULT_CALLBACKS + get_reporting_integration_callbacks(self.args.report_to)
        callbacks = default_callbacks if callbacks is None else default_callbacks + callbacks
352
353
354
        self.callback_handler = CallbackHandler(
            callbacks, self.model, self.tokenizer, self.optimizer, self.lr_scheduler
        )
355
        self.add_callback(PrinterCallback if self.args.disable_tqdm else DEFAULT_PROGRESS_CALLBACK)
Sylvain Gugger's avatar
Sylvain Gugger committed
356

357
358
359
        # 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
360
        # Create output directory if needed
361
        if self.is_world_process_zero():
Julien Chaumond's avatar
Julien Chaumond committed
362
            os.makedirs(self.args.output_dir, exist_ok=True)
363
        if not callable(self.data_collator) and callable(getattr(self.data_collator, "collate_batch", None)):
Sylvain Gugger's avatar
Sylvain Gugger committed
364
            raise ValueError("The `data_collator` should be a simple callable (function, class with `__call__`).")
365

366
367
368
369
370
371
372
373
374
        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__")

375
        self._signature_columns = None
376
377
        if is_datasets_available():
            if isinstance(train_dataset, datasets.Dataset):
378
                self._remove_unused_columns(self.train_dataset, description="training")
379
            if isinstance(eval_dataset, datasets.Dataset):
380
381
                self._remove_unused_columns(self.eval_dataset, description="evaluation")

382
383
384
        # Mixed precision setup
        self.use_apex = False
        self.use_amp = False
385
386
        self.fp16_backend = None

387
388
        if args.fp16:
            if args.fp16_backend == "auto":
389
                self.fp16_backend = "amp" if _is_native_amp_available else "apex"
390
            else:
391
392
                self.fp16_backend = args.fp16_backend
            logger.info(f"Using {self.fp16_backend} fp16 backend")
393

394
395
        if args.fp16 and not args.deepspeed:  # deepspeed manages its own fp16
            if self.fp16_backend == "amp":
396
                self.use_amp = True
397
                self.scaler = ShardedGradScaler() if self.sharded_ddp is not None else torch.cuda.amp.GradScaler()
398
399
400
401
402
403
404
            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
405
406
407
408
409
410
        # Label smoothing
        if self.args.label_smoothing_factor != 0:
            self.label_smoother = LabelSmoother(epsilon=self.args.label_smoothing_factor)
        else:
            self.label_smoother = None

411
        self.state = TrainerState()
Sylvain Gugger's avatar
Sylvain Gugger committed
412
        self.control = TrainerControl()
413
414
415
        # 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
416
        self.hp_search_backend = None
417
        self.use_tune_checkpoints = False
418
        default_label_names = (
419
            ["start_positions", "end_positions"]
420
            if type(self.model).__name__ in MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES.values()
421
422
423
            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
424
425
        self.control = self.callback_handler.on_init_end(self.args, self.state, self.control)

426
427
428
        # very last
        self._memory_tracker.stop_and_update_metrics()

Sylvain Gugger's avatar
Sylvain Gugger committed
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
    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
466

467
    def _remove_unused_columns(self, dataset: "datasets.Dataset", description: Optional[str] = None):
468
469
        if not self.args.remove_unused_columns:
            return
470
471
472
473
474
475
476
477
        if self._signature_columns is None:
            # Inspect model forward signature to keep only the arguments it accepts.
            signature = inspect.signature(self.model.forward)
            self._signature_columns = list(signature.parameters.keys())
            # Labels may be named label or label_ids, the default data collator handles that.
            self._signature_columns += ["label", "label_ids"]
        columns = [k for k in self._signature_columns if k in dataset.column_names]
        ignored_columns = list(set(dataset.column_names) - set(self._signature_columns))
478
479
480
481
482
483
        if len(ignored_columns) > 0:
            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 "
                f"`{self.model.__class__.__name__}.forward` and have been ignored: {', '.join(ignored_columns)}."
            )
484
485

        dataset.set_format(type=dataset.format["type"], columns=columns, format_kwargs=dataset.format["format_kwargs"])
486

487
    def _get_train_sampler(self) -> Optional[torch.utils.data.sampler.Sampler]:
488
489
490
        if isinstance(self.train_dataset, torch.utils.data.IterableDataset) or not isinstance(
            self.train_dataset, collections.abc.Sized
        ):
491
            return None
492
493
494
495
496

        # Gather the number of processes and this process index.
        if self.args.parallel_mode == ParallelMode.TPU:
            num_processes = xm.xrt_world_size()
            process_index = xm.get_ordinal()
Sylvain Gugger's avatar
Sylvain Gugger committed
497
498
499
500
501
502
        elif (
            self.args.parallel_mode == ParallelMode.DISTRIBUTED
            or self.args.parallel_mode == ParallelMode.SAGEMAKER_DISTRIBUTED
        ):
            num_processes = dist.get_world_size()
            process_index = dist.get_rank()
Lysandre Debut's avatar
Lysandre Debut committed
503
        else:
504
505
506
507
508
            num_processes = 1
            process_index = 0

        # Build the sampler.
        if self.args.group_by_length:
509
            model_input_name = self.tokenizer.model_input_names[0] if self.tokenizer is not None else None
510
            if num_processes <= 1:
511
512
513
                return LengthGroupedSampler(
                    self.train_dataset, self.args.train_batch_size, model_input_name=model_input_name
                )
514
515
            else:
                return DistributedLengthGroupedSampler(
516
517
518
519
520
                    self.train_dataset,
                    self.args.train_batch_size,
                    num_replicas=num_processes,
                    rank=process_index,
                    model_input_name=model_input_name,
521
522
523
524
525
526
527
                )

        else:
            if num_processes <= 1:
                return RandomSampler(self.train_dataset)
            else:
                return DistributedSampler(self.train_dataset, num_replicas=num_processes, rank=process_index)
528
529
530
531
532

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

Sylvain Gugger's avatar
Sylvain Gugger committed
533
534
        Will use no sampler if :obj:`self.train_dataset` does not implement :obj:`__len__`, a random sampler (adapted
        to distributed training if necessary) otherwise.
535
536
537
538
539
540
541
542

        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
543
544
545
            self.train_dataset,
            batch_size=self.args.train_batch_size,
            sampler=train_sampler,
546
            collate_fn=self.data_collator,
Setu Shah's avatar
Setu Shah committed
547
            drop_last=self.args.dataloader_drop_last,
Chady Kamar's avatar
Chady Kamar committed
548
            num_workers=self.args.dataloader_num_workers,
549
            pin_memory=self.args.dataloader_pin_memory,
Julien Chaumond's avatar
Julien Chaumond committed
550
551
        )

552
    def _get_eval_sampler(self, eval_dataset: Dataset) -> Optional[torch.utils.data.sampler.Sampler]:
553
        if is_torch_tpu_available():
554
555
556
557
558
            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
559

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

564
565
        Subclass and override this method if you want to inject some custom behavior.

566
        Args:
567
            eval_dataset (:obj:`torch.utils.data.dataset.Dataset`, `optional`):
568
                If provided, will override :obj:`self.eval_dataset`. If it is an :obj:`datasets.Dataset`, columns not
569
                accepted by the ``model.forward()`` method are automatically removed. It must implement :obj:`__len__`.
570
        """
Julien Chaumond's avatar
Julien Chaumond committed
571
572
        if eval_dataset is None and self.eval_dataset is None:
            raise ValueError("Trainer: evaluation requires an eval_dataset.")
573
574
575
        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):
576
            self._remove_unused_columns(eval_dataset, description="evaluation")
577
        eval_dataset = eval_dataset if eval_dataset is not None else self.eval_dataset
578
        eval_sampler = self._get_eval_sampler(eval_dataset)
579

580
        return DataLoader(
581
            eval_dataset,
582
            sampler=eval_sampler,
Julien Chaumond's avatar
Julien Chaumond committed
583
            batch_size=self.args.eval_batch_size,
584
            collate_fn=self.data_collator,
Setu Shah's avatar
Setu Shah committed
585
            drop_last=self.args.dataloader_drop_last,
Chady Kamar's avatar
Chady Kamar committed
586
            num_workers=self.args.dataloader_num_workers,
587
            pin_memory=self.args.dataloader_pin_memory,
Julien Chaumond's avatar
Julien Chaumond committed
588
589
590
        )

    def get_test_dataloader(self, test_dataset: Dataset) -> DataLoader:
591
592
593
        """
        Returns the test :class:`~torch.utils.data.DataLoader`.

594
595
        Subclass and override this method if you want to inject some custom behavior.

596
        Args:
597
            test_dataset (:obj:`torch.utils.data.dataset.Dataset`, `optional`):
598
                The test dataset to use. If it is an :obj:`datasets.Dataset`, columns not accepted by the
599
                ``model.forward()`` method are automatically removed. It must implement :obj:`__len__`.
600
        """
601
602
603
        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):
604
            self._remove_unused_columns(test_dataset, description="test")
605
        test_sampler = self._get_eval_sampler(test_dataset)
Lysandre Debut's avatar
Lysandre Debut committed
606

607
608
        # We use the same batch_size as for eval.
        return DataLoader(
Julien Chaumond's avatar
Julien Chaumond committed
609
            test_dataset,
610
            sampler=test_sampler,
Julien Chaumond's avatar
Julien Chaumond committed
611
            batch_size=self.args.eval_batch_size,
612
            collate_fn=self.data_collator,
613
            drop_last=self.args.dataloader_drop_last,
614
            pin_memory=self.args.dataloader_pin_memory,
Julien Chaumond's avatar
Julien Chaumond committed
615
        )
Lysandre Debut's avatar
Lysandre Debut committed
616

617
    def create_optimizer_and_scheduler(self, num_training_steps: int):
618
619
620
        """
        Setup the optimizer and the learning rate scheduler.

621
        We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the
622
        Trainer's init through :obj:`optimizers`, or subclass and override this method in a subclass.
623
        """
624
        if self.optimizer is None:
625
626
            decay_parameters = get_parameter_names(self.model, [torch.nn.LayerNorm])
            decay_parameters = [name for name in decay_parameters if "bias" not in name]
627
628
            optimizer_grouped_parameters = [
                {
629
                    "params": [p for n, p in self.model.named_parameters() if n in decay_parameters],
630
631
632
                    "weight_decay": self.args.weight_decay,
                },
                {
633
                    "params": [p for n, p in self.model.named_parameters() if n not in decay_parameters],
634
635
636
                    "weight_decay": 0.0,
                },
            ]
Sylvain Gugger's avatar
Sylvain Gugger committed
637
638
639
640
641
642
643
644
645
646
647
            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
648
            if self.sharded_ddp == ShardedDDPOption.SIMPLE:
649
650
                self.optimizer = OSS(
                    params=optimizer_grouped_parameters,
Sylvain Gugger's avatar
Sylvain Gugger committed
651
652
                    optim=optimizer_cls,
                    **optimizer_kwargs,
653
654
                )
            else:
Sylvain Gugger's avatar
Sylvain Gugger committed
655
656
                self.optimizer = optimizer_cls(optimizer_grouped_parameters, **optimizer_kwargs)

657
        if self.lr_scheduler is None:
658
659
660
661
662
663
            warmup_steps = (
                self.args.warmup_steps
                if self.args.warmup_steps > 0
                else math.ceil(num_training_steps * self.args.warmup_ratio)
            )

Sylvain Gugger's avatar
Sylvain Gugger committed
664
665
666
            self.lr_scheduler = get_scheduler(
                self.args.lr_scheduler_type,
                self.optimizer,
667
                num_warmup_steps=warmup_steps,
Sylvain Gugger's avatar
Sylvain Gugger committed
668
                num_training_steps=num_training_steps,
669
            )
Julien Chaumond's avatar
Julien Chaumond committed
670

671
    def num_examples(self, dataloader: DataLoader) -> int:
672
        """
673
        Helper to get number of samples in a :class:`~torch.utils.data.DataLoader` by accessing its dataset.
674
675

        Will raise an exception if the underlying dataset dese not implement method :obj:`__len__`
676
        """
677
        return len(dataloader.dataset)
678

679
680
    def _hp_search_setup(self, trial: Union["optuna.Trial", Dict[str, Any]]):
        """ HP search setup code """
681
682
        self._trial = trial

683
684
        if self.hp_search_backend is None or trial is None:
            return
685

686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
        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
705
        self.objective = self.compute_objective(metrics.copy())
706
        if self.hp_search_backend == HPSearchBackend.OPTUNA:
707
708
            import optuna

709
710
711
712
            trial.report(self.objective, epoch)
            if trial.should_prune():
                raise optuna.TrialPruned()
        elif self.hp_search_backend == HPSearchBackend.RAY:
713
714
            from ray import tune

715
            if self.control.should_save:
716
                self._tune_save_checkpoint()
717
718
            tune.report(objective=self.objective, **metrics)

719
    def _tune_save_checkpoint(self):
720
721
        from ray import tune

722
723
        if not self.use_tune_checkpoints:
            return
724
        with tune.checkpoint_dir(step=self.state.global_step) as checkpoint_dir:
725
            output_dir = os.path.join(checkpoint_dir, f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}")
726
            self.save_model(output_dir)
727
            if self.is_world_process_zero():
728
                self.state.save_to_json(os.path.join(output_dir, "trainer_state.json"))
729
730
731
                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"))

732
733
734
735
736
737
738
    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:
739
740
741
742
            raise RuntimeError("model_init should have 0 or 1 argument.")

        if model is None:
            raise RuntimeError("model_init should not return None.")
743
744
745

        return model

746
    def _wrap_model(self, model, training=True):
747
748
        # already initialized its own DDP and AMP
        if self.deepspeed:
749
            return self.deepspeed
750

751
752
753
754
        # train/eval could be run multiple-times - if already wrapped, don't re-wrap it again
        if unwrap_model(model) is not model:
            return model

755
756
757
758
759
760
761
762
763
764
765
766
767
768
        # Mixed precision training with apex (torch < 1.6)
        if self.use_apex and training:
            model, self.optimizer = amp.initialize(model, self.optimizer, opt_level=self.args.fp16_opt_level)

        # Multi-gpu training (should be after apex fp16 initialization)
        if self.args.n_gpu > 1:
            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.
        if not training:
            return model

        # Distributed training (should be after apex fp16 initialization)
769
770
771
772
773
774
775
776
777
778
779
780
781
        if self.sharded_ddp is not None:
            # Sharded DDP!
            if self.sharded_ddp == ShardedDDPOption.SIMPLE:
                model = ShardedDDP(model, self.optimizer)
            else:
                mixed_precision = self.args.fp16
                cpu_offload = ShardedDDPOption.OFFLOAD in self.args.sharded_ddp
                zero_3 = self.sharded_ddp == ShardedDDPOption.ZERO_DP_3
                # XXX: Breaking the self.model convention but I see no way around it for now.
                self.model = model = FullyShardedDDP(
                    model, mixed_precision=mixed_precision, reshard_after_forward=zero_3, cpu_offload=cpu_offload
                ).to(self.args.device)

782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
        elif is_sagemaker_distributed_available():
            model = DDP(model, device_ids=[dist.get_local_rank()], broadcast_buffers=False)
        elif self.args.local_rank != -1:
            if self.args.ddp_find_unused_parameters is not None:
                find_unused_parameters = self.args.ddp_find_unused_parameters
            elif isinstance(model, PreTrainedModel):
                # find_unused_parameters breaks checkpointing as per
                # https://github.com/huggingface/transformers/pull/4659#issuecomment-643356021
                find_unused_parameters = not getattr(model.config, "gradient_checkpointing", False)
            else:
                find_unused_parameters = True
            model = torch.nn.parallel.DistributedDataParallel(
                model,
                device_ids=[self.args.local_rank],
                output_device=self.args.local_rank,
                find_unused_parameters=find_unused_parameters,
            )

        return model

802
803
    def train(
        self,
804
        resume_from_checkpoint: Optional[Union[str, bool]] = None,
805
        trial: Union["optuna.Trial", Dict[str, Any]] = None,
806
        **kwargs,
807
    ):
Julien Chaumond's avatar
Julien Chaumond committed
808
809
810
811
        """
        Main training entry point.

        Args:
812
813
814
815
816
            resume_from_checkpoint (:obj:`str` or :obj:`bool`, `optional`):
                If a :obj:`str`, local path to a saved checkpoint as saved by a previous instance of
                :class:`~transformers.Trainer`. If a :obj:`bool` and equals `True`, load the last checkpoint in
                `args.output_dir` as saved by a previous instance of :class:`~transformers.Trainer`. If present,
                training will resume from the model/optimizer/scheduler states loaded here.
817
818
            trial (:obj:`optuna.Trial` or :obj:`Dict[str, Any]`, `optional`):
                The trial run or the hyperparameter dictionary for hyperparameter search.
819
820
            kwargs:
                Additional keyword arguments used to hide deprecated arguments
Julien Chaumond's avatar
Julien Chaumond committed
821
        """
822
823
824
825

        # memory metrics - must set up as early as possible
        self._memory_tracker.start()

826
827
        self.is_in_train = True

828
829
830
831
832
833
834
835
836
        if "model_path" in kwargs:
            resume_from_checkpoint = kwargs.pop("model_path")
            warnings.warn(
                "`model_path` is deprecated and will be removed in a future version. Use `resume_from_checkpoint` "
                "instead.",
                FutureWarning,
            )
        if len(kwargs) > 0:
            raise TypeError(f"train() received got unexpected keyword arguments: {', '.join(list(kwargs.keys()))}.")
Sylvain Gugger's avatar
Sylvain Gugger committed
837
838
839
        # This might change the seed so needs to run first.
        self._hp_search_setup(trial)

840
        # Model re-init
841
        model_reloaded = False
842
        if self.model_init is not None:
Sylvain Gugger's avatar
Sylvain Gugger committed
843
844
            # Seed must be set before instantiating the model when using model_init.
            set_seed(self.args.seed)
845
846
            self.model = self.call_model_init(trial)
            model_reloaded = True
Sylvain Gugger's avatar
Sylvain Gugger committed
847
848
            # Reinitializes optimizer and scheduler
            self.optimizer, self.lr_scheduler = None, None
849

850
        # Load potential model checkpoint
851
852
853
854
855
        if isinstance(resume_from_checkpoint, bool) and resume_from_checkpoint:
            resume_from_checkpoint = get_last_checkpoint(self.args.output_dir)
            if resume_from_checkpoint is None:
                raise ValueError(f"No valid checkpoint found in output directory ({self.args.output_dir})")

856
857
        if resume_from_checkpoint is not None and os.path.isfile(os.path.join(resume_from_checkpoint, WEIGHTS_NAME)):
            logger.info(f"Loading model from {resume_from_checkpoint}).")
858
            if isinstance(self.model, PreTrainedModel):
859
                self.model = self.model.from_pretrained(resume_from_checkpoint)
860
861
                model_reloaded = True
            else:
862
                state_dict = torch.load(os.path.join(resume_from_checkpoint, WEIGHTS_NAME))
863
864
865
866
                self.model.load_state_dict(state_dict)

        # If model was re-initialized, put it on the right device and update self.model_wrapped
        if model_reloaded:
867
            if self.place_model_on_device:
868
869
870
                self.model = self.model.to(self.args.device)
            self.model_wrapped = self.model

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

874
        # Data loader and number of training steps
Julien Chaumond's avatar
Julien Chaumond committed
875
        train_dataloader = self.get_train_dataloader()
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891

        # 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
892
        else:
893
894
895
896
            # 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
897

898
        delay_optimizer_creation = self.sharded_ddp is not None and self.sharded_ddp != ShardedDDPOption.SIMPLE
899
900
901
902
903
904
905
        if self.args.deepspeed:
            model, optimizer, lr_scheduler = init_deepspeed(self, num_training_steps=max_steps)
            self.model = model.module
            self.model_wrapped = model  # will get further wrapped in DDP
            self.deepspeed = model  # DeepSpeedEngine object
            self.optimizer = optimizer
            self.lr_scheduler = lr_scheduler
906
        elif not delay_optimizer_creation:
907
908
            self.create_optimizer_and_scheduler(num_training_steps=max_steps)

909
        self.state = TrainerState()
910
        self.state.is_hyper_param_search = trial is not None
Julien Chaumond's avatar
Julien Chaumond committed
911
912

        # Check if saved optimizer or scheduler states exist
913
        self._load_optimizer_and_scheduler(resume_from_checkpoint)
Julien Chaumond's avatar
Julien Chaumond committed
914

915
        model = self._wrap_model(self.model_wrapped)
Julien Chaumond's avatar
Julien Chaumond committed
916

917
918
919
920
        # 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

921
922
923
        if delay_optimizer_creation:
            self.create_optimizer_and_scheduler(num_training_steps=max_steps)

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

Julien Chaumond's avatar
Julien Chaumond committed
928
        # Train!
929
        if is_torch_tpu_available():
Sylvain Gugger's avatar
Sylvain Gugger committed
930
931
932
            world_size = xm.xrt_world_size()
        elif self.args.local_rank != -1:
            world_size = dist.get_world_size()
Lysandre Debut's avatar
Lysandre Debut committed
933
        else:
Sylvain Gugger's avatar
Sylvain Gugger committed
934
            world_size = 1
935

Sylvain Gugger's avatar
Sylvain Gugger committed
936
        total_train_batch_size = self.args.train_batch_size * self.args.gradient_accumulation_steps * world_size
937
938
939
940
941
942
        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
943
        logger.info("***** Running training *****")
944
945
946
947
948
949
        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
950

951
        self.state.epoch = 0
952
        start_time = time.time()
Julien Chaumond's avatar
Julien Chaumond committed
953
954
        epochs_trained = 0
        steps_trained_in_current_epoch = 0
955

Julien Chaumond's avatar
Julien Chaumond committed
956
        # Check if continuing training from a checkpoint
957
958
959
960
        if resume_from_checkpoint is not None and os.path.isfile(
            os.path.join(resume_from_checkpoint, "trainer_state.json")
        ):
            self.state = TrainerState.load_from_json(os.path.join(resume_from_checkpoint, "trainer_state.json"))
961
            epochs_trained = self.state.global_step // num_update_steps_per_epoch
962
963
964
965
966
            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
967
968

            logger.info("  Continuing training from checkpoint, will skip to saved global_step")
969
970
971
972
973
974
975
            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."
                )
976

Sylvain Gugger's avatar
Sylvain Gugger committed
977
978
979
980
981
        # 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
982
983
        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
984
985
986
987
        # 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
988
989
        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
990

991
        # tr_loss is a tensor to avoid synchronization of TPUs through .item()
992
        tr_loss = torch.tensor(0.0).to(self.args.device)
993
994
        # _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
995
        self._globalstep_last_logged = self.state.global_step
996
        self._total_flos = self.state.total_flos
Julien Chaumond's avatar
Julien Chaumond committed
997
        model.zero_grad()
Sylvain Gugger's avatar
Sylvain Gugger committed
998
999
1000

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

1001
1002
1003
1004
1005
1006
1007
        # 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

1008
        for epoch in range(epochs_trained, num_train_epochs):
1009
1010
1011
            if isinstance(train_dataloader, DataLoader) and isinstance(train_dataloader.sampler, DistributedSampler):
                train_dataloader.sampler.set_epoch(epoch)

1012
            if is_torch_tpu_available():
1013
1014
1015
                parallel_loader = pl.ParallelLoader(train_dataloader, [self.args.device]).per_device_loader(
                    self.args.device
                )
1016
                epoch_iterator = parallel_loader
1017
            else:
1018
                epoch_iterator = train_dataloader
1019

1020
1021
1022
1023
            # Reset the past mems state at the beginning of each epoch if necessary.
            if self.args.past_index >= 0:
                self._past = None

1024
1025
1026
1027
1028
            steps_in_epoch = (
                len(epoch_iterator)
                if train_dataset_is_sized
                else self.args.max_steps * self.args.gradient_accumulation_steps
            )
Sylvain Gugger's avatar
Sylvain Gugger committed
1029
1030
            self.control = self.callback_handler.on_epoch_begin(self.args, self.state, self.control)

Julien Chaumond's avatar
Julien Chaumond committed
1031
1032
1033
1034
1035
1036
1037
            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
1038
1039
1040
                if (step + 1) % self.args.gradient_accumulation_steps == 0:
                    self.control = self.callback_handler.on_step_begin(self.args, self.state, self.control)

1041
1042
1043
                if (
                    ((step + 1) % self.args.gradient_accumulation_steps != 0)
                    and self.args.local_rank != -1
Sylvain Gugger's avatar
Sylvain Gugger committed
1044
                    and self.args._no_sync_in_gradient_accumulation
1045
                ):
1046
                    # Avoid unnecessary DDP synchronization since there will be no backward pass on this example.
1047
1048
1049
1050
                    with model.no_sync():
                        tr_loss += self.training_step(model, inputs)
                else:
                    tr_loss += self.training_step(model, inputs)
1051
                self._total_flos += float(self.floating_point_ops(inputs))
Julien Chaumond's avatar
Julien Chaumond committed
1052

1053
1054
1055
1056
                # Optimizer step for deepspeed must be called on every step regardless of the value of gradient_accumulation_steps
                if self.deepspeed:
                    self.deepspeed.step()

Julien Chaumond's avatar
Julien Chaumond committed
1057
1058
                if (step + 1) % self.args.gradient_accumulation_steps == 0 or (
                    # last step in epoch but step is always smaller than gradient_accumulation_steps
1059
1060
                    steps_in_epoch <= self.args.gradient_accumulation_steps
                    and (step + 1) == steps_in_epoch
Julien Chaumond's avatar
Julien Chaumond committed
1061
                ):
1062
                    # Gradient clipping
1063
1064
1065
                    if self.args.max_grad_norm is not None and self.args.max_grad_norm > 0 and not self.deepspeed:
                        # deepspeed does its own clipping

1066
1067
1068
1069
1070
1071
1072
                        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)
1073
1074
1075
                        elif hasattr(model, "clip_grad_norm_"):
                            # Some models (like FullyShardedDDP) have a specific way to do gradient clipping
                            model.clip_grad_norm_(self.args.max_grad_norm)
1076
1077
1078
1079
1080
1081
1082
1083
                        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
Stas Bekman's avatar
Stas Bekman committed
1084
                    if self.deepspeed:
1085
                        pass  # called outside the loop
Stas Bekman's avatar
Stas Bekman committed
1086
                    elif is_torch_tpu_available():
1087
                        xm.optimizer_step(self.optimizer)
1088
                    elif self.use_amp:
1089
                        self.scaler.step(self.optimizer)
1090
                        self.scaler.update()
Lysandre Debut's avatar
Lysandre Debut committed
1091
                    else:
1092
                        self.optimizer.step()
Lysandre Debut's avatar
Lysandre Debut committed
1093

1094
1095
1096
                    if not self.deepspeed:
                        self.lr_scheduler.step()

Julien Chaumond's avatar
Julien Chaumond committed
1097
                    model.zero_grad()
1098
                    self.state.global_step += 1
1099
                    self.state.epoch = epoch + (step + 1) / steps_in_epoch
Sylvain Gugger's avatar
Sylvain Gugger committed
1100
1101
                    self.control = self.callback_handler.on_step_end(self.args, self.state, self.control)

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

Sylvain Gugger's avatar
Sylvain Gugger committed
1104
                if self.control.should_epoch_stop or self.control.should_training_stop:
Julien Chaumond's avatar
Julien Chaumond committed
1105
                    break
1106

Sylvain Gugger's avatar
Sylvain Gugger committed
1107
            self.control = self.callback_handler.on_epoch_end(self.args, self.state, self.control)
1108
            self._maybe_log_save_evaluate(tr_loss, model, trial, epoch)
1109

1110
            if self.args.tpu_metrics_debug or self.args.debug:
1111
1112
1113
1114
1115
1116
1117
1118
                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
1119
            if self.control.should_training_stop:
1120
                break
Julien Chaumond's avatar
Julien Chaumond committed
1121

1122
1123
1124
        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
1125
1126

        logger.info("\n\nTraining completed. Do not forget to share your model on huggingface.co/models =)\n\n")
1127
1128
1129
1130
        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})."
            )
1131
1132
            if isinstance(self.model, PreTrainedModel):
                self.model = self.model.from_pretrained(self.state.best_model_checkpoint)
1133
                if self.place_model_on_device:
1134
                    self.model = self.model.to(self.args.device)
1135
1136
1137
1138
            else:
                state_dict = torch.load(os.path.join(self.state.best_model_checkpoint, WEIGHTS_NAME))
                self.model.load_state_dict(state_dict)

1139
1140
1141
1142
1143
            if self.deepspeed:
                self.deepspeed.load_checkpoint(
                    self.state.best_model_checkpoint, load_optimizer_states=False, load_lr_scheduler_states=False
                )

1144
        metrics = speed_metrics("train", start_time, self.state.max_steps)
1145
1146
        if self._total_flos is not None:
            self.store_flos()
1147
1148
            metrics["total_flos"] = self.state.total_flos
        self.log(metrics)
1149

Sylvain Gugger's avatar
Sylvain Gugger committed
1150
        self.control = self.callback_handler.on_train_end(self.args, self.state, self.control)
1151
1152
        # add remaining tr_loss
        self._total_loss_scalar += tr_loss.item()
Sylvain Gugger's avatar
Sylvain Gugger committed
1153

1154
1155
1156
1157
1158
1159
1160
        if self.deepspeed:
            # free up any memory that might be useful for eval
            self.deepspeed = None
            self.optimizer = None
            self.lr_scheduler = None
            self.model_wrapped = self.model
            gc.collect()  # force memory release
1161
1162
1163
1164
1165
1166
            # to restore normal behavior outside of train replay the place_model_on_device logic w/o deepspeed
            self.place_model_on_device = self.args.place_model_on_device
            if self.is_model_parallel:
                self.place_model_on_device = False

        self.is_in_train = False
1167

1168
1169
        self._memory_tracker.stop_and_update_metrics(metrics)

1170
        return TrainOutput(self.state.global_step, self._total_loss_scalar / self.state.global_step, metrics)
1171

1172
    def _maybe_log_save_evaluate(self, tr_loss, model, trial, epoch):
Sylvain Gugger's avatar
Sylvain Gugger committed
1173
1174
1175
        if self.control.should_log:
            logs: Dict[str, float] = {}
            tr_loss_scalar = tr_loss.item()
1176
1177
1178
            # reset tr_loss to zero
            tr_loss -= tr_loss

1179
            logs["loss"] = round(tr_loss_scalar / (self.state.global_step - self._globalstep_last_logged), 4)
1180
            logs["learning_rate"] = self._get_learning_rate()
1181

1182
            self._total_loss_scalar += tr_loss_scalar
1183
            self._globalstep_last_logged = self.state.global_step
Sylvain Gugger's avatar
Sylvain Gugger committed
1184
1185
1186
1187
1188
1189
1190

            self.log(logs)

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

Sylvain Gugger's avatar
Sylvain Gugger committed
1192
1193
1194
1195
1196
        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):
1197
        # In all cases, including ddp/dp/deepspeed, self.model is always a reference to the model we
1198
        # want to save except FullyShardedDDP.
1199
        # assert unwrap_model(model) is self.model, "internal model should be a reference to self.model"
1200

1201
        # Save model checkpoint
1202
        checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}"
1203

1204
        if self.hp_search_backend is not None and trial is not None:
1205
1206
1207
1208
1209
1210
            if self.hp_search_backend == HPSearchBackend.OPTUNA:
                run_id = trial.number
            else:
                from ray import tune

                run_id = tune.get_trial_id()
1211
            run_name = self.hp_name(trial) if self.hp_name is not None else f"run-{run_id}"
1212
            run_dir = os.path.join(self.args.output_dir, run_name)
1213
        else:
1214
            run_dir = self.args.output_dir
1215
            self.store_flos()
1216

1217
        output_dir = os.path.join(run_dir, checkpoint_folder)
1218
        self.save_model(output_dir)
1219
1220
        if self.deepspeed:
            self.deepspeed.save_checkpoint(output_dir)
1221
1222

        # Save optimizer and scheduler
1223
        if self.sharded_ddp == ShardedDDPOption.SIMPLE:
1224
            self.optimizer.consolidate_state_dict()
1225

1226
1227
1228
1229
1230
1231
        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)
1232
1233
        elif self.is_world_process_zero() and not self.deepspeed:
            # deepspeed.save_checkpoint above saves model/optim/sched
1234
1235
1236
1237
1238
1239
            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
1240
        if metrics is not None and self.args.metric_for_best_model is not None:
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
            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():
1261
            self._rotate_checkpoints(use_mtime=True, output_dir=run_dir)
1262

1263
    def _load_optimizer_and_scheduler(self, checkpoint):
Sylvain Gugger's avatar
Sylvain Gugger committed
1264
        """If optimizer and scheduler states exist, load them."""
1265
        if checkpoint is None:
1266
1267
            return

1268
1269
        if os.path.isfile(os.path.join(checkpoint, "optimizer.pt")) and os.path.isfile(
            os.path.join(checkpoint, "scheduler.pt")
Sylvain Gugger's avatar
Sylvain Gugger committed
1270
1271
1272
1273
        ):
            # 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.
1274
                optimizer_state = torch.load(os.path.join(checkpoint, "optimizer.pt"), map_location="cpu")
Sylvain Gugger's avatar
Sylvain Gugger committed
1275
                with warnings.catch_warnings(record=True) as caught_warnings:
1276
                    lr_scheduler_state = torch.load(os.path.join(checkpoint, "scheduler.pt"), map_location="cpu")
Sylvain Gugger's avatar
Sylvain Gugger committed
1277
1278
1279
1280
1281
1282
1283
1284
1285
                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(
1286
                    torch.load(os.path.join(checkpoint, "optimizer.pt"), map_location=self.args.device)
Sylvain Gugger's avatar
Sylvain Gugger committed
1287
1288
                )
                with warnings.catch_warnings(record=True) as caught_warnings:
1289
                    self.lr_scheduler.load_state_dict(torch.load(os.path.join(checkpoint, "scheduler.pt")))
Sylvain Gugger's avatar
Sylvain Gugger committed
1290
1291
                reissue_pt_warnings(caught_warnings)

1292
1293
        if self.deepspeed:
            # Not sure how to check if there is a saved deepspeed checkpoint, but since it just return None if it fails to find a deepspeed checkpoint this is sort of a check-n-load function
1294
            self.deepspeed.load_checkpoint(checkpoint, load_optimizer_states=True, load_lr_scheduler_states=True)
1295

1296
1297
1298
1299
1300
1301
1302
    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,
1303
        hp_name: Optional[Callable[["optuna.Trial"], str]] = None,
1304
        **kwargs,
1305
1306
    ) -> BestRun:
        """
1307
        Launch an hyperparameter search using ``optuna`` or ``Ray Tune``. The optimized quantity is determined by
Sylvain Gugger's avatar
Sylvain Gugger committed
1308
1309
        :obj:`compute_objective`, which defaults to a function returning the evaluation loss when no metric is
        provided, the sum of all metrics otherwise.
1310

Sylvain Gugger's avatar
Sylvain Gugger committed
1311
1312
1313
1314
1315
1316
1317
        .. 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.

1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
        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
1339
                - the documentation of `optuna.create_study
1340
                  <https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.create_study.html>`__
Sylvain Gugger's avatar
Sylvain Gugger committed
1341
1342
                - the documentation of `tune.run
                  <https://docs.ray.io/en/latest/tune/api_docs/execution.html#tune-run>`__
1343
1344

        Returns:
Tiger's avatar
Tiger committed
1345
            :class:`transformers.trainer_utils.BestRun`: All the information about the best run.
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
        """
        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
1357
            raise RuntimeError("You picked the optuna backend, but it is not installed. Use `pip install optuna`.")
1358
        if backend == HPSearchBackend.RAY and not is_ray_tune_available():
1359
            raise RuntimeError(
Sylvain Gugger's avatar
Sylvain Gugger committed
1360
                "You picked the Ray Tune backend, but it is not installed. Use `pip install 'ray[tune]'`."
1361
1362
            )
        self.hp_search_backend = backend
Sylvain Gugger's avatar
Sylvain Gugger committed
1363
1364
1365
1366
1367
        if self.model_init is None:
            raise RuntimeError(
                "To use hyperparameter search, you need to pass your model through a model_init function."
            )

1368
        self.hp_space = default_hp_space[backend] if hp_space is None else hp_space
1369
        self.hp_name = hp_name
1370
1371
        self.compute_objective = default_compute_objective if compute_objective is None else compute_objective

1372
1373
        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)
1374
1375
1376
1377

        self.hp_search_backend = None
        return best_run

Sylvain Gugger's avatar
Sylvain Gugger committed
1378
    def log(self, logs: Dict[str, float]) -> None:
1379
1380
1381
1382
1383
1384
1385
1386
1387
        """
        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.
        """
1388
        if self.state.epoch is not None:
1389
            logs["epoch"] = round(self.state.epoch, 2)
1390

1391
1392
        output = {**logs, **{"step": self.state.global_step}}
        self.state.log_history.append(output)
1393
        self.control = self.callback_handler.on_log(self.args, self.state, self.control, logs)
Julien Chaumond's avatar
Julien Chaumond committed
1394

sgugger's avatar
Fix CI  
sgugger committed
1395
    def _prepare_inputs(self, inputs: Dict[str, Union[torch.Tensor, Any]]) -> Dict[str, Union[torch.Tensor, Any]]:
1396
1397
1398
1399
        """
        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
1400
        for k, v in inputs.items():
1401
1402
            if isinstance(v, torch.Tensor):
                inputs[k] = v.to(self.args.device)
Julien Chaumond's avatar
Julien Chaumond committed
1403

1404
1405
        if self.args.past_index >= 0 and self._past is not None:
            inputs["mems"] = self._past
1406

1407
1408
        return inputs

1409
    def training_step(self, model: nn.Module, inputs: Dict[str, Union[torch.Tensor, Any]]) -> torch.Tensor:
1410
        """
1411
        Perform a training step on a batch of inputs.
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424

        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:
1425
            :obj:`torch.Tensor`: The tensor with training loss on this batch.
1426
1427
        """
        model.train()
1428
        inputs = self._prepare_inputs(inputs)
1429

1430
        if self.use_amp:
1431
            with autocast():
Sylvain Gugger's avatar
Sylvain Gugger committed
1432
                loss = self.compute_loss(model, inputs)
1433
        else:
Sylvain Gugger's avatar
Sylvain Gugger committed
1434
            loss = self.compute_loss(model, inputs)
1435

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

1439
1440
        if self.args.gradient_accumulation_steps > 1 and not self.deepspeed:
            # deepspeed handles loss scaling by gradient_accumulation_steps in its `backward`
Julien Chaumond's avatar
Julien Chaumond committed
1441
1442
            loss = loss / self.args.gradient_accumulation_steps

1443
        if self.use_amp:
1444
            self.scaler.scale(loss).backward()
1445
        elif self.use_apex:
1446
            with amp.scale_loss(loss, self.optimizer) as scaled_loss:
Julien Chaumond's avatar
Julien Chaumond committed
1447
                scaled_loss.backward()
1448
        elif self.deepspeed:
1449
1450
            # loss gets scaled under gradient_accumulation_steps in deepspeed
            loss = self.deepspeed.backward(loss)
Julien Chaumond's avatar
Julien Chaumond committed
1451
1452
1453
        else:
            loss.backward()

1454
        return loss.detach()
Julien Chaumond's avatar
Julien Chaumond committed
1455

1456
    def compute_loss(self, model, inputs, return_outputs=False):
Sylvain Gugger's avatar
Sylvain Gugger committed
1457
1458
1459
1460
1461
        """
        How the loss is computed by Trainer. By default, all models return the loss in the first element.

        Subclass and override for custom behavior.
        """
1462
1463
1464
1465
        if self.label_smoother is not None and "labels" in inputs:
            labels = inputs.pop("labels")
        else:
            labels = None
Sylvain Gugger's avatar
Sylvain Gugger committed
1466
1467
        outputs = model(**inputs)
        # Save past state if it exists
1468
        # TODO: this needs to be fixed and made cleaner later.
Sylvain Gugger's avatar
Sylvain Gugger committed
1469
1470
        if self.args.past_index >= 0:
            self._past = outputs[self.args.past_index]
Sylvain Gugger's avatar
Sylvain Gugger committed
1471

1472
        if labels is not None:
1473
            loss = self.label_smoother(outputs, labels)
Sylvain Gugger's avatar
Sylvain Gugger committed
1474
1475
        else:
            # We don't use .loss here since the model may return tuples instead of ModelOutput.
1476
1477
1478
            loss = outputs["loss"] if isinstance(outputs, dict) else outputs[0]

        return (loss, outputs) if return_outputs else loss
Sylvain Gugger's avatar
Sylvain Gugger committed
1479

1480
1481
    def is_local_process_zero(self) -> bool:
        """
Sylvain Gugger's avatar
Sylvain Gugger committed
1482
1483
        Whether or not this process is the local (e.g., on one machine if training in a distributed fashion on several
        machines) main process.
1484
        """
1485
        if is_torch_tpu_available():
Lysandre Debut's avatar
Lysandre Debut committed
1486
1487
1488
1489
            return xm.is_master_ordinal(local=True)
        else:
            return self.args.local_rank in [-1, 0]

1490
1491
    def is_world_process_zero(self) -> bool:
        """
Sylvain Gugger's avatar
Sylvain Gugger committed
1492
1493
        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
1494
        """
1495
        if is_torch_tpu_available():
Lysandre Debut's avatar
Lysandre Debut committed
1496
1497
            return xm.is_master_ordinal(local=False)
        else:
Sylvain Gugger's avatar
Sylvain Gugger committed
1498
            return self.args.local_rank == -1 or dist.get_rank() == 0
Julien Chaumond's avatar
Julien Chaumond committed
1499
1500
1501

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

1504
        Will only save from the main process.
Julien Chaumond's avatar
Julien Chaumond committed
1505
        """
1506
        if is_torch_tpu_available():
1507
            self._save_tpu(output_dir)
1508
1509
1510
1511
        elif (
            ShardedDDPOption.ZERO_DP_2 in self.args.sharded_ddp or ShardedDDPOption.ZERO_DP_3 in self.args.sharded_ddp
        ):
            state_dict = self.model.state_dict()
1512
            if self.is_world_process_zero():
1513
1514
1515
                self._save(output_dir, state_dict=state_dict)
        elif self.is_world_process_zero():
            self._save(output_dir)
Julien Chaumond's avatar
Julien Chaumond committed
1516

1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
    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")
1528
        if not isinstance(self.model, PreTrainedModel):
1529
1530
1531
1532
1533
1534
1535
            if isinstance(unwrap_model(self.model), PreTrainedModel):
                unwrap_model(self.model).save_pretrained(
                    output_dir,
                    save_config=self.is_world_process_zero(),
                    state_dict=self.model.state_dict(),
                    save_function=xm.save,
                )
1536
1537
            else:
                logger.info("Trainer.model is not a `PreTrainedModel`, only saving its state dict.")
1538
1539
                state_dict = self.model.state_dict()
                xm.save(state_dict, os.path.join(output_dir, WEIGHTS_NAME))
1540
        else:
1541
            self.model.save_pretrained(output_dir, save_config=self.is_world_process_zero(), save_function=xm.save)
Sylvain Gugger's avatar
Sylvain Gugger committed
1542
        if self.tokenizer is not None and self.is_world_process_zero():
1543
            self.tokenizer.save_pretrained(output_dir)
1544

1545
    def _save(self, output_dir: Optional[str] = None, state_dict=None):
1546
        # If we are executing this function, we are the process zero, so we don't check for that.
Julien Chaumond's avatar
Julien Chaumond committed
1547
1548
1549
1550
1551
1552
        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):
1553
            if isinstance(unwrap_model(self.model), PreTrainedModel):
1554
1555
1556
                if state_dict is None:
                    state_dict = self.model.state_dict()
                unwrap_model(self.model).save_pretrained(output_dir, state_dict=state_dict)
1557
1558
            else:
                logger.info("Trainer.model is not a `PreTrainedModel`, only saving its state dict.")
1559
1560
                if state_dict is None:
                    state_dict = self.model.state_dict()
1561
                torch.save(state_dict, os.path.join(output_dir, WEIGHTS_NAME))
1562
        else:
1563
            self.model.save_pretrained(output_dir, state_dict=state_dict)
1564
        if self.tokenizer is not None:
1565
            self.tokenizer.save_pretrained(output_dir)
Julien Chaumond's avatar
Julien Chaumond committed
1566
1567
1568

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

1570
    def store_flos(self):
1571
        # Storing the number of floating-point operations that went into the model
1572
        if self._total_flos is not None:
1573
            if self.args.local_rank != -1:
1574
                self.state.total_flos = distributed_broadcast_scalars([self._total_flos]).sum().item()
1575
            else:
1576
                self.state.total_flos = self._total_flos
Julien Chaumond's avatar
Julien Chaumond committed
1577

1578
1579
1580
    def _sorted_checkpoints(
        self, output_dir=None, checkpoint_prefix=PREFIX_CHECKPOINT_DIR, use_mtime=False
    ) -> List[str]:
Julien Chaumond's avatar
Julien Chaumond committed
1581
1582
        ordering_and_checkpoint_path = []

1583
        glob_checkpoints = [str(x) for x in Path(output_dir).glob(f"{checkpoint_prefix}-*")]
Julien Chaumond's avatar
Julien Chaumond committed
1584
1585
1586
1587
1588

        for path in glob_checkpoints:
            if use_mtime:
                ordering_and_checkpoint_path.append((os.path.getmtime(path), path))
            else:
1589
                regex_match = re.match(f".*{checkpoint_prefix}-([0-9]+)", path)
Julien Chaumond's avatar
Julien Chaumond committed
1590
1591
1592
1593
1594
                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]
1595
1596
        # Make sure we don't delete the best model.
        if self.state.best_model_checkpoint is not None:
1597
            best_model_index = checkpoints_sorted.index(str(Path(self.state.best_model_checkpoint)))
1598
            checkpoints_sorted[best_model_index], checkpoints_sorted[-1] = (
1599
1600
1601
                checkpoints_sorted[-1],
                checkpoints_sorted[best_model_index],
            )
Julien Chaumond's avatar
Julien Chaumond committed
1602
1603
        return checkpoints_sorted

1604
    def _rotate_checkpoints(self, use_mtime=False, output_dir=None) -> None:
1605
        if self.args.save_total_limit is None or self.args.save_total_limit <= 0:
Julien Chaumond's avatar
Julien Chaumond committed
1606
1607
1608
            return

        # Check if we should delete older checkpoint(s)
1609
        checkpoints_sorted = self._sorted_checkpoints(use_mtime=use_mtime, output_dir=output_dir)
Julien Chaumond's avatar
Julien Chaumond committed
1610
1611
1612
1613
1614
1615
1616
1617
1618
        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)

1619
    def evaluate(
1620
1621
1622
1623
        self,
        eval_dataset: Optional[Dataset] = None,
        ignore_keys: Optional[List[str]] = None,
        metric_key_prefix: str = "eval",
1624
    ) -> Dict[str, float]:
Julien Chaumond's avatar
Julien Chaumond committed
1625
        """
1626
        Run evaluation and returns metrics.
Julien Chaumond's avatar
Julien Chaumond committed
1627

Sylvain Gugger's avatar
Sylvain Gugger committed
1628
1629
        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
1630

1631
1632
        You can also subclass and override this method to inject custom behavior.

Julien Chaumond's avatar
Julien Chaumond committed
1633
        Args:
1634
            eval_dataset (:obj:`Dataset`, `optional`):
1635
                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
1636
1637
                columns not accepted by the ``model.forward()`` method are automatically removed. It must implement the
                :obj:`__len__` method.
1638
1639
1640
            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.
1641
1642
1643
            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)
1644

Julien Chaumond's avatar
Julien Chaumond committed
1645
        Returns:
1646
1647
            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
1648
        """
1649
1650
1651
        # memory metrics - must set up as early as possible
        self._memory_tracker.start()

1652
1653
1654
        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
1655
        eval_dataloader = self.get_eval_dataloader(eval_dataset)
1656
        start_time = time.time()
Julien Chaumond's avatar
Julien Chaumond committed
1657

1658
1659
1660
1661
1662
1663
        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,
1664
            ignore_keys=ignore_keys,
1665
            metric_key_prefix=metric_key_prefix,
1666
        )
Lysandre Debut's avatar
Lysandre Debut committed
1667

1668
1669
        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))
1670
        self.log(output.metrics)
1671

1672
        if self.args.tpu_metrics_debug or self.args.debug:
Lysandre Debut's avatar
Lysandre Debut committed
1673
1674
1675
            # 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
1676
        self.control = self.callback_handler.on_evaluate(self.args, self.state, self.control, output.metrics)
1677
1678
1679

        self._memory_tracker.stop_and_update_metrics(output.metrics)

Julien Chaumond's avatar
Julien Chaumond committed
1680
1681
        return output.metrics

1682
1683
1684
    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
1685
        """
1686
        Run prediction and returns predictions and potential metrics.
Julien Chaumond's avatar
Julien Chaumond committed
1687

Sylvain Gugger's avatar
Sylvain Gugger committed
1688
1689
        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()`.
1690
1691
1692

        Args:
            test_dataset (:obj:`Dataset`):
1693
                Dataset to run the predictions on. If it is an :obj:`datasets.Dataset`, columns not accepted by the
1694
                ``model.forward()`` method are automatically removed. Has to implement the method :obj:`__len__`
1695
1696
1697
            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.
1698
1699
1700
            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)
1701

1702
1703
1704
1705
1706
1707
        .. 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
1708
1709
1710
1711
1712
1713
        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
1714
        """
1715
1716
1717
        # memory metrics - must set up as early as possible
        self._memory_tracker.start()

1718
1719
1720
        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
1721
        test_dataloader = self.get_test_dataloader(test_dataset)
1722
        start_time = time.time()
1723

1724
        output = self.prediction_loop(
1725
1726
            test_dataloader, description="Prediction", ignore_keys=ignore_keys, metric_key_prefix=metric_key_prefix
        )
1727
        output.metrics.update(speed_metrics(metric_key_prefix, start_time, len(test_dataset)))
1728
1729
1730

        self._memory_tracker.stop_and_update_metrics(output.metrics)

1731
        return output
Julien Chaumond's avatar
Julien Chaumond committed
1732

1733
    def prediction_loop(
1734
1735
1736
1737
1738
        self,
        dataloader: DataLoader,
        description: str,
        prediction_loss_only: Optional[bool] = None,
        ignore_keys: Optional[List[str]] = None,
1739
        metric_key_prefix: str = "eval",
Julien Chaumond's avatar
Julien Chaumond committed
1740
1741
    ) -> PredictionOutput:
        """
1742
        Prediction/evaluation loop, shared by :obj:`Trainer.evaluate()` and :obj:`Trainer.predict()`.
Julien Chaumond's avatar
Julien Chaumond committed
1743
1744
1745

        Works both with or without labels.
        """
1746
1747
        if not isinstance(dataloader.dataset, collections.abc.Sized):
            raise ValueError("dataset must implement __len__")
1748
1749
1750
        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
1751

1752
        if self.args.deepspeed and not self.args.do_train:
1753
1754
1755
            # no harm, but flagging to the user that deepspeed config is ignored for eval
            # flagging only for when --do_train wasn't passed as only then it's redundant
            logger.info("Detected the deepspeed argument but it will not be used for evaluation")
1756

1757
        model = self._wrap_model(self.model, training=False)
Julien Chaumond's avatar
Julien Chaumond committed
1758

1759
1760
1761
1762
1763
        # if full fp16 is wanted on eval and this ``evaluation`` or ``predict`` isn't called while
        # ``train`` is running, half it first and then put on device
        if not self.is_in_train and self.args.fp16_full_eval:
            model = model.half().to(self.args.device)

1764
        batch_size = dataloader.batch_size
1765
        num_examples = self.num_examples(dataloader)
Julien Chaumond's avatar
Julien Chaumond committed
1766
        logger.info("***** Running %s *****", description)
1767
        logger.info("  Num examples = %d", num_examples)
1768
        logger.info("  Batch size = %d", batch_size)
1769
1770
1771
1772
1773
1774
1775
1776
        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:
Sylvain Gugger's avatar
Sylvain Gugger committed
1777
            world_size = dist.get_world_size()
1778
1779
1780
        world_size = max(1, world_size)

        eval_losses_gatherer = DistributedTensorGatherer(world_size, num_examples, make_multiple_of=batch_size)
1781
1782
1783
        if not prediction_loss_only:
            preds_gatherer = DistributedTensorGatherer(world_size, num_examples)
            labels_gatherer = DistributedTensorGatherer(world_size, num_examples)
1784

Julien Chaumond's avatar
Julien Chaumond committed
1785
1786
        model.eval()

1787
        if is_torch_tpu_available():
1788
1789
            dataloader = pl.ParallelLoader(dataloader, [self.args.device]).per_device_loader(self.args.device)

1790
        if self.args.past_index >= 0:
1791
            self._past = None
1792

Sylvain Gugger's avatar
Sylvain Gugger committed
1793
1794
        self.callback_handler.eval_dataloader = dataloader

1795
        for step, inputs in enumerate(dataloader):
1796
            loss, logits, labels = self.prediction_step(model, inputs, prediction_loss_only, ignore_keys=ignore_keys)
1797
            if loss is not None:
1798
1799
                losses = loss.repeat(batch_size)
                losses_host = losses if losses_host is None else torch.cat((losses_host, losses), dim=0)
1800
            if logits is not None:
1801
                preds_host = logits if preds_host is None else nested_concat(preds_host, logits, padding_index=-100)
1802
            if labels is not None:
1803
                labels_host = labels if labels_host is None else nested_concat(labels_host, labels, padding_index=-100)
Sylvain Gugger's avatar
Sylvain Gugger committed
1804
            self.control = self.callback_handler.on_prediction_step(self.args, self.state, self.control)
Julien Chaumond's avatar
Julien Chaumond committed
1805

1806
1807
1808
            # 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"))
1809
1810
1811
                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"))
1812
1813
1814
1815

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

1816
1817
1818
        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
1819

1820
1821
        # Gather all remaining tensors and put them back on the CPU
        eval_losses_gatherer.add_arrays(self._gather_and_numpify(losses_host, "eval_losses"))
1822
1823
1824
        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"))
1825
1826

        eval_loss = eval_losses_gatherer.finalize()
1827
1828
        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
1829

Julien Chaumond's avatar
Julien Chaumond committed
1830
1831
1832
1833
        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 = {}
1834

1835
1836
1837
        # To be JSON-serializable, we need to remove numpy types or zero-d tensors
        metrics = denumpify_detensorize(metrics)

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

1841
        # Prefix all keys with metric_key_prefix + '_'
1842
        for key in list(metrics.keys()):
1843
1844
            if not key.startswith(f"{metric_key_prefix}_"):
                metrics[f"{metric_key_prefix}_{key}"] = metrics.pop(key)
Julien Chaumond's avatar
Julien Chaumond committed
1845
1846

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

1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
    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)

1862
    def prediction_step(
1863
1864
1865
1866
1867
        self,
        model: nn.Module,
        inputs: Dict[str, Union[torch.Tensor, Any]],
        prediction_loss_only: bool,
        ignore_keys: Optional[List[str]] = None,
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
    ) -> 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.
1884
1885
1886
            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.
1887
1888

        Return:
Sylvain Gugger's avatar
Sylvain Gugger committed
1889
1890
            Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]: A tuple with the loss, logits and
            labels (each being optional).
1891
        """
1892
        has_labels = all(inputs.get(k) is not None for k in self.label_names)
1893
        inputs = self._prepare_inputs(inputs)
1894
1895
1896
1897
1898
        if ignore_keys is None:
            if hasattr(self.model, "config"):
                ignore_keys = getattr(self.model.config, "keys_to_ignore_at_inference", [])
            else:
                ignore_keys = []
1899

1900
1901
1902
1903
1904
1905
1906
1907
        # labels may be popped when computing the loss (label smoothing for instance) so we grab them first.
        if has_labels:
            labels = nested_detach(tuple(inputs.get(name) for name in self.label_names))
            if len(labels) == 1:
                labels = labels[0]
        else:
            labels = None

1908
1909
        with torch.no_grad():
            if has_labels:
1910
1911
                loss, outputs = self.compute_loss(model, inputs, return_outputs=True)
                loss = loss.mean().detach()
1912
1913
1914
1915
                if isinstance(outputs, dict):
                    logits = tuple(v for k, v in outputs.items() if k not in ignore_keys + ["loss"])
                else:
                    logits = outputs[1:]
1916
1917
            else:
                loss = None
1918
1919
1920
1921
1922
                if self.use_amp:
                    with autocast():
                        outputs = model(**inputs)
                else:
                    outputs = model(**inputs)
1923
1924
1925
1926
                if isinstance(outputs, dict):
                    logits = tuple(v for k, v in outputs.items() if k not in ignore_keys)
                else:
                    logits = outputs
1927
1928
1929
                # TODO: this needs to be fixed and made cleaner later.
                if self.args.past_index >= 0:
                    self._past = outputs[self.args.past_index - 1]
1930
1931
1932
1933

        if prediction_loss_only:
            return (loss, None, None)

1934
        logits = nested_detach(logits)
Sylvain Gugger's avatar
Sylvain Gugger committed
1935
1936
1937
1938
        if len(logits) == 1:
            logits = logits[0]

        return (loss, logits, labels)
1939
1940
1941

    def floating_point_ops(self, inputs: Dict[str, Union[torch.Tensor, Any]]):
        """
Sylvain Gugger's avatar
Sylvain Gugger committed
1942
1943
1944
        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.
1945
1946
1947
1948
1949
1950
1951
1952

        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.
        """
1953
1954
        if hasattr(self.model, "floating_point_ops"):
            return self.model.floating_point_ops(inputs)
1955
1956
        else:
            return 0