test_modeling_common.py 49.1 KB
Newer Older
thomwolf's avatar
thomwolf committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# coding=utf-8
# Copyright 2019 HuggingFace Inc.
#
# 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.
Aymeric Augustin's avatar
Aymeric Augustin committed
15

16
import copy
17
import inspect
18
import os.path
Aymeric Augustin's avatar
Aymeric Augustin committed
19
import random
20
import tempfile
thomwolf's avatar
thomwolf committed
21
import unittest
22
from typing import List, Tuple
thomwolf's avatar
thomwolf committed
23

24
from transformers import is_torch_available
25
from transformers.testing_utils import require_multigpu, require_torch, slow, torch_device
26

Aymeric Augustin's avatar
Aymeric Augustin committed
27

28
if is_torch_available():
29
    import numpy as np
30
    import torch
thomwolf's avatar
thomwolf committed
31

32
    from transformers import (
33
        BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
34
35
        MODEL_FOR_CAUSAL_LM_MAPPING,
        MODEL_FOR_MASKED_LM_MAPPING,
36
37
        MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
        MODEL_FOR_QUESTION_ANSWERING_MAPPING,
38
39
40
        MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
        MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
        MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
41
42
43
44
45
        AdaptiveEmbedding,
        BertConfig,
        BertModel,
        PretrainedConfig,
        PreTrainedModel,
46
        top_k_top_p_filtering,
47
    )
thomwolf's avatar
thomwolf committed
48

49

50
51
52
def _config_zero_init(config):
    configs_no_init = copy.deepcopy(config)
    for key in configs_no_init.__dict__.keys():
53
        if "_range" in key or "_std" in key or "initializer_factor" in key:
Lysandre Debut's avatar
Lysandre Debut committed
54
            setattr(configs_no_init, key, 1e-10)
55
56
    return configs_no_init

thomwolf's avatar
thomwolf committed
57

58
59
60
61
62
@require_torch
class ModelTesterMixin:

    model_tester = None
    all_model_classes = ()
63
    all_generative_model_classes = ()
Patrick von Platen's avatar
Patrick von Platen committed
64
65
66
67
    test_torchscript = True
    test_pruning = True
    test_resize_embeddings = True
    test_head_masking = True
68
    test_missing_keys = True
69
70
    is_encoder_decoder = False

71
72
    def _prepare_for_class(self, inputs_dict, model_class, return_labels=False):
        inputs_dict = copy.deepcopy(inputs_dict)
73
        if model_class in MODEL_FOR_MULTIPLE_CHOICE_MAPPING.values():
74
            inputs_dict = {
75
                k: v.unsqueeze(1).expand(-1, self.model_tester.num_choices, -1).contiguous()
76
                if isinstance(v, torch.Tensor) and v.ndim > 1
Sylvain Gugger's avatar
Sylvain Gugger committed
77
                else v
78
79
                for k, v in inputs_dict.items()
            }
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

        if return_labels:
            if model_class in MODEL_FOR_MULTIPLE_CHOICE_MAPPING.values():
                inputs_dict["labels"] = torch.ones(self.model_tester.batch_size, dtype=torch.long, device=torch_device)
            elif model_class in MODEL_FOR_QUESTION_ANSWERING_MAPPING.values():
                inputs_dict["start_positions"] = torch.zeros(
                    self.model_tester.batch_size, dtype=torch.long, device=torch_device
                )
                inputs_dict["end_positions"] = torch.zeros(
                    self.model_tester.batch_size, dtype=torch.long, device=torch_device
                )
            elif model_class in MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING.values():
                inputs_dict["labels"] = torch.zeros(
                    self.model_tester.batch_size, dtype=torch.long, device=torch_device
                )
            elif model_class in [
                *MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING.values(),
                *MODEL_FOR_CAUSAL_LM_MAPPING.values(),
                *MODEL_FOR_MASKED_LM_MAPPING.values(),
                *MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING.values(),
            ]:
                inputs_dict["labels"] = torch.zeros(
                    (self.model_tester.batch_size, self.model_tester.seq_length), dtype=torch.long, device=torch_device
                )
104
105
        return inputs_dict

Patrick von Platen's avatar
Patrick von Platen committed
106
    def test_save_load(self):
107
108
109
110
111
112
113
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            model = model_class(config)
            model.to(torch_device)
            model.eval()
            with torch.no_grad():
114
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
115
            out_2 = outputs[0].cpu().numpy()
116
            out_2[np.isnan(out_2)] = 0
117

118
            with tempfile.TemporaryDirectory() as tmpdirname:
119
120
                model.save_pretrained(tmpdirname)
                model = model_class.from_pretrained(tmpdirname)
121
                model.to(torch_device)
122
                with torch.no_grad():
123
                    after_outputs = model(**self._prepare_for_class(inputs_dict, model_class))
thomwolf's avatar
thomwolf committed
124

125
126
127
                # Make sure we don't have nans
                out_1 = after_outputs[0].cpu().numpy()
                out_1[np.isnan(out_1)] = 0
thomwolf's avatar
thomwolf committed
128
129
                max_diff = np.amax(np.abs(out_1 - out_2))
                self.assertLessEqual(max_diff, 1e-5)
130

Patrick von Platen's avatar
Patrick von Platen committed
131
    def test_initialization(self):
132
133
134
135
136
137
138
139
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        configs_no_init = _config_zero_init(config)
        for model_class in self.all_model_classes:
            model = model_class(config=configs_no_init)
            for name, param in model.named_parameters():
                if param.requires_grad:
                    self.assertIn(
Lysandre Debut's avatar
Lysandre Debut committed
140
                        ((param.data.mean() * 1e9).round() / 1e9).item(),
141
142
143
                        [0.0, 1.0],
                        msg="Parameter {} of model {} seems not properly initialized".format(name, model_class),
                    )
thomwolf's avatar
thomwolf committed
144

Patrick von Platen's avatar
Patrick von Platen committed
145
    def test_determinism(self):
146
147
148
149
150
151
152
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            model = model_class(config)
            model.to(torch_device)
            model.eval()
            with torch.no_grad():
153
154
                first = model(**self._prepare_for_class(inputs_dict, model_class))[0]
                second = model(**self._prepare_for_class(inputs_dict, model_class))[0]
155
156
157
158
159
160
161
            out_1 = first.cpu().numpy()
            out_2 = second.cpu().numpy()
            out_1 = out_1[~np.isnan(out_1)]
            out_2 = out_2[~np.isnan(out_2)]
            max_diff = np.amax(np.abs(out_1 - out_2))
            self.assertLessEqual(max_diff, 1e-5)

162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
    def test_forward_signature(self):
        config, _ = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            model = model_class(config)
            signature = inspect.signature(model.forward)
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            arg_names = [*signature.parameters.keys()]

            if model.config.is_encoder_decoder:
                expected_arg_names = [
                    "input_ids",
                    "attention_mask",
                    "decoder_input_ids",
                    "decoder_attention_mask",
                    "encoder_outputs",
                ]
                self.assertListEqual(arg_names[:5], expected_arg_names)
            else:
                expected_arg_names = ["input_ids"]
                self.assertListEqual(arg_names[:1], expected_arg_names)

Patrick von Platen's avatar
Patrick von Platen committed
184
    def test_attention_outputs(self):
185
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
sshleifer's avatar
sshleifer committed
186
        seq_len = getattr(self.model_tester, "seq_length", None)
sshleifer's avatar
sshleifer committed
187
188
        decoder_seq_length = getattr(self.model_tester, "decoder_seq_length", seq_len)
        encoder_seq_length = getattr(self.model_tester, "encoder_seq_length", seq_len)
189
190
        decoder_key_length = getattr(self.model_tester, "key_length", decoder_seq_length)
        encoder_key_length = getattr(self.model_tester, "key_length", encoder_seq_length)
Patrick von Platen's avatar
Patrick von Platen committed
191
192
193
        chunk_length = getattr(self.model_tester, "chunk_length", None)
        if chunk_length is not None and hasattr(self.model_tester, "num_hashes"):
            encoder_seq_length = encoder_seq_length * self.model_tester.num_hashes
194
195

        for model_class in self.all_model_classes:
196
            inputs_dict["output_attentions"] = True
Joseph Liu's avatar
Joseph Liu committed
197
            inputs_dict["output_hidden_states"] = False
198
199
200
201
            model = model_class(config)
            model.to(torch_device)
            model.eval()
            with torch.no_grad():
202
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
203
            attentions = outputs[-1]
204
205
206
207
208
209
210
211
212
            self.assertEqual(len(attentions), self.model_tester.num_hidden_layers)

            # check that output_attentions also work using config
            del inputs_dict["output_attentions"]
            config.output_attentions = True
            model = model_class(config)
            model.to(torch_device)
            model.eval()
            with torch.no_grad():
213
                outputs = model(**self._prepare_for_class(inputs_dict, model_class), return_dict=True)
214
            attentions = outputs[-1]
215
            self.assertEqual(len(attentions), self.model_tester.num_hidden_layers)
Patrick von Platen's avatar
Patrick von Platen committed
216
217
218
219
220
221
222
223
224
225
226

            if chunk_length is not None:
                self.assertListEqual(
                    list(attentions[0].shape[-4:]),
                    [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length],
                )
            else:
                self.assertListEqual(
                    list(attentions[0].shape[-3:]),
                    [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length],
                )
227
            out_len = len(outputs)
thomwolf's avatar
thomwolf committed
228

229
            if self.is_encoder_decoder:
230
                correct_outlen = 4
Sam Shleifer's avatar
Sam Shleifer committed
231
                decoder_attention_idx = 1
232

233
234
235
236
237
238
239
                # loss is at first position
                if "labels" in inputs_dict:
                    correct_outlen += 1  # loss is added to beginning
                    decoder_attention_idx += 1
                # Question Answering model returns start_logits and end_logits
                if model_class in MODEL_FOR_QUESTION_ANSWERING_MAPPING.values():
                    correct_outlen += 1  # start_logits and end_logits instead of only 1 output
Sam Shleifer's avatar
Sam Shleifer committed
240
241
242
243
244
                    decoder_attention_idx += 1
                self.assertEqual(out_len, correct_outlen)

                decoder_attentions = outputs[decoder_attention_idx]
                self.assertIsInstance(decoder_attentions, (list, tuple))
245
                self.assertEqual(len(decoder_attentions), self.model_tester.num_hidden_layers)
thomwolf's avatar
thomwolf committed
246
                self.assertListEqual(
247
248
                    list(decoder_attentions[0].shape[-3:]),
                    [self.model_tester.num_attention_heads, decoder_seq_length, decoder_key_length],
249
                )
thomwolf's avatar
thomwolf committed
250

251
            # Check attention is always last and order is fine
252
            inputs_dict["output_attentions"] = True
Joseph Liu's avatar
Joseph Liu committed
253
            inputs_dict["output_hidden_states"] = True
254
255
256
257
            model = model_class(config)
            model.to(torch_device)
            model.eval()
            with torch.no_grad():
258
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
259
260
261
262
            self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1), len(outputs))

            self_attentions = outputs[-1]
            self.assertEqual(len(self_attentions), self.model_tester.num_hidden_layers)
Patrick von Platen's avatar
Patrick von Platen committed
263
264
265
266
267
268
269
270
271
272
            if chunk_length is not None:
                self.assertListEqual(
                    list(self_attentions[0].shape[-4:]),
                    [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length],
                )
            else:
                self.assertListEqual(
                    list(self_attentions[0].shape[-3:]),
                    [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length],
                )
thomwolf's avatar
thomwolf committed
273

Patrick von Platen's avatar
Patrick von Platen committed
274
    def test_torchscript(self):
275
276
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
        self._create_and_check_torchscript(config, inputs_dict)
thomwolf's avatar
thomwolf committed
277

Patrick von Platen's avatar
Patrick von Platen committed
278
    def test_torchscript_output_attentions(self):
279
280
281
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
        config.output_attentions = True
        self._create_and_check_torchscript(config, inputs_dict)
thomwolf's avatar
thomwolf committed
282

Patrick von Platen's avatar
Patrick von Platen committed
283
    def test_torchscript_output_hidden_state(self):
284
285
286
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
        config.output_hidden_states = True
        self._create_and_check_torchscript(config, inputs_dict)
thomwolf's avatar
thomwolf committed
287

288
    def _create_and_check_torchscript(self, config, inputs_dict):
Patrick von Platen's avatar
Patrick von Platen committed
289
        if not self.test_torchscript:
290
            return
291

292
293
294
295
296
297
        configs_no_init = _config_zero_init(config)  # To be sure we have no Nan
        configs_no_init.torchscript = True
        for model_class in self.all_model_classes:
            model = model_class(config=configs_no_init)
            model.to(torch_device)
            model.eval()
298
            inputs = self._prepare_for_class(inputs_dict, model_class)
thomwolf's avatar
thomwolf committed
299

300
            try:
301
302
303
304
305
306
307
308
309
310
311
312
313
                if model.config.is_encoder_decoder:
                    model.config.use_cache = False  # TODO: this should be deleted after bug #7474 is solved
                    input_ids = inputs["input_ids"]
                    attention_mask = inputs["attention_mask"]
                    decoder_input_ids = inputs["decoder_input_ids"]
                    decoder_attention_mask = inputs["decoder_attention_mask"]

                    traced_model = torch.jit.trace(
                        model, (input_ids, attention_mask, decoder_input_ids, decoder_attention_mask)
                    )
                else:
                    input_ids = inputs["input_ids"]
                    traced_model = torch.jit.trace(model, input_ids)
314
315
            except RuntimeError:
                self.fail("Couldn't trace module.")
thomwolf's avatar
thomwolf committed
316

317
            with tempfile.TemporaryDirectory() as tmp_dir_name:
318
                pt_file_name = os.path.join(tmp_dir_name, "traced_model.pt")
thomwolf's avatar
thomwolf committed
319

320
                try:
321
                    torch.jit.save(traced_model, pt_file_name)
322
323
                except Exception:
                    self.fail("Couldn't save module.")
thomwolf's avatar
thomwolf committed
324

325
326
327
328
                try:
                    loaded_model = torch.jit.load(pt_file_name)
                except Exception:
                    self.fail("Couldn't load module.")
LysandreJik's avatar
LysandreJik committed
329

330
331
            model.to(torch_device)
            model.eval()
thomwolf's avatar
thomwolf committed
332

333
334
            loaded_model.to(torch_device)
            loaded_model.eval()
thomwolf's avatar
thomwolf committed
335

336
337
338
339
            model_state_dict = model.state_dict()
            loaded_model_state_dict = loaded_model.state_dict()

            self.assertEqual(set(model_state_dict.keys()), set(loaded_model_state_dict.keys()))
thomwolf's avatar
thomwolf committed
340

341
            models_equal = True
342
343
            for layer_name, p1 in model_state_dict.items():
                p2 = loaded_model_state_dict[layer_name]
344
345
                if p1.data.ne(p2.data).sum() > 0:
                    models_equal = False
thomwolf's avatar
thomwolf committed
346

347
            self.assertTrue(models_equal)
thomwolf's avatar
thomwolf committed
348

Patrick von Platen's avatar
Patrick von Platen committed
349
350
    def test_headmasking(self):
        if not self.test_head_masking:
351
            return
352

353
354
355
        global_rng.seed(42)
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
        global_rng.seed()
LysandreJik's avatar
LysandreJik committed
356

357
        inputs_dict["output_attentions"] = True
358
359
360
361
362
363
        config.output_hidden_states = True
        configs_no_init = _config_zero_init(config)  # To be sure we have no Nan
        for model_class in self.all_model_classes:
            model = model_class(config=configs_no_init)
            model.to(torch_device)
            model.eval()
LysandreJik's avatar
LysandreJik committed
364

365
366
367
            # Prepare head_mask
            # Set require_grad after having prepared the tensor to avoid error (leaf variable has been moved into the graph interior)
            head_mask = torch.ones(
Lysandre's avatar
Lysandre committed
368
369
370
                self.model_tester.num_hidden_layers,
                self.model_tester.num_attention_heads,
                device=torch_device,
371
372
373
374
            )
            head_mask[0, 0] = 0
            head_mask[-1, :-1] = 0
            head_mask.requires_grad_(requires_grad=True)
375
            inputs = self._prepare_for_class(inputs_dict, model_class).copy()
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
            inputs["head_mask"] = head_mask

            outputs = model(**inputs)

            # Test that we can get a gradient back for importance score computation
            output = sum(t.sum() for t in outputs[0])
            output = output.sum()
            output.backward()
            multihead_outputs = head_mask.grad

            attentions = outputs[-1]

            # Remove Nan
            for t in attentions:
                self.assertLess(
                    torch.sum(torch.isnan(t)), t.numel() / 4
                )  # Check we don't have more than 25% nans (arbitrary)
            attentions = [
                t.masked_fill(torch.isnan(t), 0.0) for t in attentions
            ]  # remove them (the test is less complete)

            self.assertIsNotNone(multihead_outputs)
            self.assertEqual(len(multihead_outputs), self.model_tester.num_hidden_layers)
            self.assertAlmostEqual(attentions[0][..., 0, :, :].flatten().sum().item(), 0.0)
            self.assertNotEqual(attentions[0][..., -1, :, :].flatten().sum().item(), 0.0)
            self.assertNotEqual(attentions[1][..., 0, :, :].flatten().sum().item(), 0.0)
            self.assertAlmostEqual(attentions[-1][..., -2, :, :].flatten().sum().item(), 0.0)
            self.assertNotEqual(attentions[-1][..., -1, :, :].flatten().sum().item(), 0.0)

Patrick von Platen's avatar
Patrick von Platen committed
405
406
    def test_head_pruning(self):
        if not self.test_pruning:
407
408
409
            return

        for model_class in self.all_model_classes:
Lysandre's avatar
Lysandre committed
410
411
412
413
            (
                config,
                inputs_dict,
            ) = self.model_tester.prepare_config_and_inputs_for_common()
414

415
416
            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
417

418
            inputs_dict["output_attentions"] = True
419
420
421
422
            config.output_hidden_states = False
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
423
424
425
426
            heads_to_prune = {
                0: list(range(1, self.model_tester.num_attention_heads)),
                -1: [0],
            }
427
428
            model.prune_heads(heads_to_prune)
            with torch.no_grad():
429
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
430

431
            attentions = outputs[-1]
432

433
434
435
            self.assertEqual(attentions[0].shape[-3], 1)
            self.assertEqual(attentions[1].shape[-3], self.model_tester.num_attention_heads)
            self.assertEqual(attentions[-1].shape[-3], self.model_tester.num_attention_heads - 1)
LysandreJik's avatar
LysandreJik committed
436

Patrick von Platen's avatar
Patrick von Platen committed
437
438
    def test_head_pruning_save_load_from_pretrained(self):
        if not self.test_pruning:
439
            return
LysandreJik's avatar
LysandreJik committed
440

441
        for model_class in self.all_model_classes:
Lysandre's avatar
Lysandre committed
442
443
444
445
            (
                config,
                inputs_dict,
            ) = self.model_tester.prepare_config_and_inputs_for_common()
446
447
448

            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
449

450
            inputs_dict["output_attentions"] = True
451
452
453
454
            config.output_hidden_states = False
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
455
456
457
458
            heads_to_prune = {
                0: list(range(1, self.model_tester.num_attention_heads)),
                -1: [0],
            }
459
            model.prune_heads(heads_to_prune)
460

461
            with tempfile.TemporaryDirectory() as temp_dir_name:
462
463
                model.save_pretrained(temp_dir_name)
                model = model_class.from_pretrained(temp_dir_name)
464
                model.to(torch_device)
465

466
            with torch.no_grad():
467
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
468
469
470
471
            attentions = outputs[-1]
            self.assertEqual(attentions[0].shape[-3], 1)
            self.assertEqual(attentions[1].shape[-3], self.model_tester.num_attention_heads)
            self.assertEqual(attentions[-1].shape[-3], self.model_tester.num_attention_heads - 1)
472

Patrick von Platen's avatar
Patrick von Platen committed
473
474
    def test_head_pruning_save_load_from_config_init(self):
        if not self.test_pruning:
475
            return
476

477
        for model_class in self.all_model_classes:
Lysandre's avatar
Lysandre committed
478
479
480
481
            (
                config,
                inputs_dict,
            ) = self.model_tester.prepare_config_and_inputs_for_common()
482

483
484
            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
485

486
            inputs_dict["output_attentions"] = True
487
            config.output_hidden_states = False
488

489
490
491
492
            heads_to_prune = {
                0: list(range(1, self.model_tester.num_attention_heads)),
                -1: [0],
            }
493
            config.pruned_heads = heads_to_prune
494

495
496
497
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
498

499
            with torch.no_grad():
500
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
501
            attentions = outputs[-1]
502

503
504
505
            self.assertEqual(attentions[0].shape[-3], 1)
            self.assertEqual(attentions[1].shape[-3], self.model_tester.num_attention_heads)
            self.assertEqual(attentions[-1].shape[-3], self.model_tester.num_attention_heads - 1)
506

Patrick von Platen's avatar
Patrick von Platen committed
507
508
    def test_head_pruning_integration(self):
        if not self.test_pruning:
509
            return
510

511
        for model_class in self.all_model_classes:
Lysandre's avatar
Lysandre committed
512
513
514
515
            (
                config,
                inputs_dict,
            ) = self.model_tester.prepare_config_and_inputs_for_common()
516

517
518
            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
519

520
            inputs_dict["output_attentions"] = True
521
            config.output_hidden_states = False
522

523
524
            heads_to_prune = {0: [0], 1: [1, 2]}
            config.pruned_heads = heads_to_prune
525

526
527
528
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
529

530
            with torch.no_grad():
531
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
532
            attentions = outputs[-1]
533

534
535
536
537
            self.assertEqual(attentions[0].shape[-3], self.model_tester.num_attention_heads - 1)
            self.assertEqual(attentions[1].shape[-3], self.model_tester.num_attention_heads - 2)
            self.assertEqual(attentions[2].shape[-3], self.model_tester.num_attention_heads)
            self.assertEqual(attentions[3].shape[-3], self.model_tester.num_attention_heads)
thomwolf's avatar
thomwolf committed
538

539
            with tempfile.TemporaryDirectory() as temp_dir_name:
540
541
                model.save_pretrained(temp_dir_name)
                model = model_class.from_pretrained(temp_dir_name)
542
                model.to(torch_device)
thomwolf's avatar
thomwolf committed
543

544
            with torch.no_grad():
545
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
546
            attentions = outputs[-1]
LysandreJik's avatar
LysandreJik committed
547

548
549
550
551
            self.assertEqual(attentions[0].shape[-3], self.model_tester.num_attention_heads - 1)
            self.assertEqual(attentions[1].shape[-3], self.model_tester.num_attention_heads - 2)
            self.assertEqual(attentions[2].shape[-3], self.model_tester.num_attention_heads)
            self.assertEqual(attentions[3].shape[-3], self.model_tester.num_attention_heads)
thomwolf's avatar
thomwolf committed
552

553
554
            heads_to_prune = {0: [0], 2: [1, 2]}
            model.prune_heads(heads_to_prune)
555

556
            with torch.no_grad():
557
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
558
            attentions = outputs[-1]
559

560
561
562
563
            self.assertEqual(attentions[0].shape[-3], self.model_tester.num_attention_heads - 1)
            self.assertEqual(attentions[1].shape[-3], self.model_tester.num_attention_heads - 2)
            self.assertEqual(attentions[2].shape[-3], self.model_tester.num_attention_heads - 2)
            self.assertEqual(attentions[3].shape[-3], self.model_tester.num_attention_heads)
564

565
            self.assertDictEqual(model.config.pruned_heads, {0: [0], 1: [1, 2], 2: [1, 2]})
thomwolf's avatar
thomwolf committed
566

Patrick von Platen's avatar
Patrick von Platen committed
567
    def test_hidden_states_output(self):
Joseph Liu's avatar
Joseph Liu committed
568
        def check_hidden_states_output(inputs_dict, config, model_class):
569
            model = model_class(config)
570
            model.to(torch_device)
thomwolf's avatar
thomwolf committed
571
            model.eval()
Joseph Liu's avatar
Joseph Liu committed
572

thomwolf's avatar
thomwolf committed
573
            with torch.no_grad():
574
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
575
            hidden_states = outputs[-1]
Patrick von Platen's avatar
Patrick von Platen committed
576

Sylvain Gugger's avatar
Sylvain Gugger committed
577
578
579
580
            expected_num_layers = getattr(
                self.model_tester, "expected_num_hidden_layers", self.model_tester.num_hidden_layers + 1
            )
            self.assertEqual(len(hidden_states), expected_num_layers)
Patrick von Platen's avatar
Patrick von Platen committed
581
582
583
584
585
586
587
            if hasattr(self.model_tester, "encoder_seq_length"):
                seq_length = self.model_tester.encoder_seq_length
                if hasattr(self.model_tester, "chunk_length") and self.model_tester.chunk_length > 1:
                    seq_length = seq_length * self.model_tester.chunk_length
            else:
                seq_length = self.model_tester.seq_length

588
            self.assertListEqual(
Lysandre's avatar
Lysandre committed
589
590
                list(hidden_states[0].shape[-2:]),
                [seq_length, self.model_tester.hidden_size],
591
            )
thomwolf's avatar
thomwolf committed
592

Joseph Liu's avatar
Joseph Liu committed
593
594
595
596
597
598
599
600
601
602
603
604
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            inputs_dict["output_hidden_states"] = True
            check_hidden_states_output(inputs_dict, config, model_class)

            # check that output_hidden_states also work using config
            del inputs_dict["output_hidden_states"]
            config.output_hidden_states = True

            check_hidden_states_output(inputs_dict, config, model_class)

Pradhy729's avatar
Pradhy729 committed
605
    def test_feed_forward_chunking(self):
Lysandre's avatar
Lysandre committed
606
607
608
609
        (
            original_config,
            inputs_dict,
        ) = self.model_tester.prepare_config_and_inputs_for_common()
Pradhy729's avatar
Pradhy729 committed
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
        for model_class in self.all_model_classes:
            torch.manual_seed(0)
            config = copy.deepcopy(original_config)
            model = model_class(config)
            model.to(torch_device)
            model.eval()

            hidden_states_no_chunk = model(**self._prepare_for_class(inputs_dict, model_class))[0]

            torch.manual_seed(0)
            config.chunk_size_feed_forward = 1
            model = model_class(config)
            model.to(torch_device)
            model.eval()

            hidden_states_with_chunk = model(**self._prepare_for_class(inputs_dict, model_class))[0]
            self.assertTrue(torch.allclose(hidden_states_no_chunk, hidden_states_with_chunk, atol=1e-3))

Patrick von Platen's avatar
Patrick von Platen committed
628
    def test_resize_tokens_embeddings(self):
Lysandre's avatar
Lysandre committed
629
630
631
632
        (
            original_config,
            inputs_dict,
        ) = self.model_tester.prepare_config_and_inputs_for_common()
Patrick von Platen's avatar
Patrick von Platen committed
633
        if not self.test_resize_embeddings:
634
635
636
637
638
            return

        for model_class in self.all_model_classes:
            config = copy.deepcopy(original_config)
            model = model_class(config)
639
            model.to(torch_device)
640

Patrick von Platen's avatar
Patrick von Platen committed
641
642
643
            if self.model_tester.is_training is False:
                model.eval()

644
645
646
647
648
649
650
651
652
653
            model_vocab_size = config.vocab_size
            # Retrieve the embeddings and clone theme
            model_embed = model.resize_token_embeddings(model_vocab_size)
            cloned_embeddings = model_embed.weight.clone()

            # Check that resizing the token embeddings with a larger vocab size increases the model's vocab size
            model_embed = model.resize_token_embeddings(model_vocab_size + 10)
            self.assertEqual(model.config.vocab_size, model_vocab_size + 10)
            # Check that it actually resizes the embeddings matrix
            self.assertEqual(model_embed.weight.shape[0], cloned_embeddings.shape[0] + 10)
654
            # Check that the model can still do a forward pass successfully (every parameter should be resized)
655
            model(**self._prepare_for_class(inputs_dict, model_class))
656
657
658
659
660
661
662

            # Check that resizing the token embeddings with a smaller vocab size decreases the model's vocab size
            model_embed = model.resize_token_embeddings(model_vocab_size - 15)
            self.assertEqual(model.config.vocab_size, model_vocab_size - 15)
            # Check that it actually resizes the embeddings matrix
            self.assertEqual(model_embed.weight.shape[0], cloned_embeddings.shape[0] - 15)

663
664
665
            # Check that the model can still do a forward pass successfully (every parameter should be resized)
            # Input ids should be clamped to the maximum size of the vocabulary
            inputs_dict["input_ids"].clamp_(max=model_vocab_size - 15 - 1)
666
            model(**self._prepare_for_class(inputs_dict, model_class))
667

668
669
670
671
672
673
674
675
            # Check that adding and removing tokens has not modified the first part of the embedding matrix.
            models_equal = True
            for p1, p2 in zip(cloned_embeddings, model_embed.weight):
                if p1.data.ne(p2.data).sum() > 0:
                    models_equal = False

            self.assertTrue(models_equal)

Patrick von Platen's avatar
Patrick von Platen committed
676
    def test_model_common_attributes(self):
677
678
679
680
681
682
683
684
685
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            model = model_class(config)
            self.assertIsInstance(model.get_input_embeddings(), (torch.nn.Embedding, AdaptiveEmbedding))
            model.set_input_embeddings(torch.nn.Embedding(10, 10))
            x = model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(x, torch.nn.Linear))

686
    def test_correct_missing_keys(self):
687
688
        if not self.test_missing_keys:
            return
689
690
691
692
693
694
695
696
697
698
699
700
701
702
        config, _ = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            model = model_class(config)
            base_model_prefix = model.base_model_prefix

            if hasattr(model, base_model_prefix):
                with tempfile.TemporaryDirectory() as temp_dir_name:
                    model.base_model.save_pretrained(temp_dir_name)
                    model, loading_info = model_class.from_pretrained(temp_dir_name, output_loading_info=True)

                    with self.subTest(msg="Missing keys for {}".format(model.__class__.__name__)):
                        self.assertGreater(len(loading_info["missing_keys"]), 0)

703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
    def test_tie_model_weights(self):
        if not self.test_torchscript:
            return

        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        def check_same_values(layer_1, layer_2):
            equal = True
            for p1, p2 in zip(layer_1.weight, layer_2.weight):
                if p1.data.ne(p2.data).sum() > 0:
                    equal = False
            return equal

        for model_class in self.all_model_classes:
            config.torchscript = True
            model_not_tied = model_class(config)
            if model_not_tied.get_output_embeddings() is None:
                continue

            config_tied = copy.deepcopy(config)
            config_tied.torchscript = False
            model_tied = model_class(config_tied)
            params_tied = list(model_tied.parameters())
            # Check that the embedding layer and decoding layer are the same in size and in value
            # self.assertTrue(check_same_values(embeddings, decoding))

            # # Check that after modification, they remain the same.
            # embeddings.weight.data.div_(2)
            # # Check that the embedding layer and decoding layer are the same in size and in value
            # self.assertTrue(embeddings.weight.shape, decoding.weight.shape)
            # self.assertTrue(check_same_values(embeddings, decoding))

            # # Check that after modification, they remain the same.
            # decoding.weight.data.div_(4)
            # # Check that the embedding layer and decoding layer are the same in size and in value
            # self.assertTrue(embeddings.weight.shape, decoding.weight.shape)
            # self.assertTrue(check_same_values(embeddings, decoding))

            # Check that after resize they remain tied.
            model_tied.resize_token_embeddings(config.vocab_size + 10)
            params_tied_2 = list(model_tied.parameters())
            self.assertEqual(len(params_tied_2), len(params_tied))

            # decoding.weight.data.mul_(20)
            # # Check that the embedding layer and decoding layer are the same in size and in value
            # self.assertTrue(model.transformer.wte.weight.shape, model.lm_head.weight.shape)
            # self.assertTrue(check_same_values(model.transformer.wte, model.lm_head))

751
752
753
754
    def test_model_outputs_equivalence(self):

        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

Sam Shleifer's avatar
Sam Shleifer committed
755
756
757
758
        def set_nan_tensor_to_zero(t):
            t[t != t] = 0
            return t

759
760
761
762
763
764
765
766
767
768
769
770
771
        def check_equivalence(model, tuple_inputs, dict_inputs, additional_kwargs={}):
            with torch.no_grad():
                tuple_output = model(**tuple_inputs, return_dict=False, **additional_kwargs)
                dict_output = model(**dict_inputs, return_dict=True, **additional_kwargs).to_tuple()

                def recursive_check(tuple_object, dict_object):
                    if isinstance(tuple_object, (List, Tuple)):
                        for tuple_iterable_value, dict_iterable_value in zip(tuple_object, dict_object):
                            recursive_check(tuple_iterable_value, dict_iterable_value)
                    elif tuple_object is None:
                        return
                    else:
                        self.assertTrue(
Sam Shleifer's avatar
Sam Shleifer committed
772
773
774
                            torch.allclose(
                                set_nan_tensor_to_zero(tuple_object), set_nan_tensor_to_zero(dict_object), atol=1e-5
                            ),
775
                            msg=f"Tuple and dict output are not equal. Difference: {torch.max(torch.abs(tuple_object - dict_object))}. Tuple has `nan`: {torch.isnan(tuple_object).any()} and `inf`: {torch.isinf(tuple_object)}. Dict has `nan`: {torch.isnan(dict_object).any()} and `inf`: {torch.isinf(dict_object)}.",
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
                        )

                recursive_check(tuple_output, dict_output)

        for model_class in self.all_model_classes:
            model = model_class(config)
            model.to(torch_device)
            model.eval()

            tuple_inputs = self._prepare_for_class(inputs_dict, model_class)
            dict_inputs = self._prepare_for_class(inputs_dict, model_class)
            check_equivalence(model, tuple_inputs, dict_inputs)

            tuple_inputs = self._prepare_for_class(inputs_dict, model_class, return_labels=True)
            dict_inputs = self._prepare_for_class(inputs_dict, model_class, return_labels=True)
            check_equivalence(model, tuple_inputs, dict_inputs)

            tuple_inputs = self._prepare_for_class(inputs_dict, model_class)
            dict_inputs = self._prepare_for_class(inputs_dict, model_class)
            check_equivalence(model, tuple_inputs, dict_inputs, {"output_hidden_states": True})

            tuple_inputs = self._prepare_for_class(inputs_dict, model_class)
            dict_inputs = self._prepare_for_class(inputs_dict, model_class)
            check_equivalence(model, tuple_inputs, dict_inputs, {"output_attentions": True})

            tuple_inputs = self._prepare_for_class(inputs_dict, model_class, return_labels=True)
            dict_inputs = self._prepare_for_class(inputs_dict, model_class, return_labels=True)
            check_equivalence(model, tuple_inputs, dict_inputs, {"output_hidden_states": True})

            tuple_inputs = self._prepare_for_class(inputs_dict, model_class, return_labels=True)
            dict_inputs = self._prepare_for_class(inputs_dict, model_class, return_labels=True)
            check_equivalence(model, tuple_inputs, dict_inputs, {"output_attentions": True})

            tuple_inputs = self._prepare_for_class(inputs_dict, model_class, return_labels=True)
            dict_inputs = self._prepare_for_class(inputs_dict, model_class, return_labels=True)
            check_equivalence(
                model, tuple_inputs, dict_inputs, {"output_hidden_states": True, "output_attentions": True}
            )

Patrick von Platen's avatar
Patrick von Platen committed
815
    def test_inputs_embeds(self):
Sam Shleifer's avatar
Sam Shleifer committed
816

817
818
819
820
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            model = model_class(config)
821
            model.to(torch_device)
thomwolf's avatar
thomwolf committed
822
            model.eval()
823

824
825
826
827
828
829
830
831
832
833
            inputs = copy.deepcopy(self._prepare_for_class(inputs_dict, model_class))
            if not self.is_encoder_decoder:
                input_ids = inputs["input_ids"]
                del inputs["input_ids"]
            else:
                encoder_input_ids = inputs["input_ids"]
                decoder_input_ids = inputs.get("decoder_input_ids", encoder_input_ids)
                del inputs["input_ids"]
                inputs.pop("decoder_input_ids", None)

834
835
            wte = model.get_input_embeddings()
            if not self.is_encoder_decoder:
836
                inputs["inputs_embeds"] = wte(input_ids)
837
            else:
838
839
                inputs["inputs_embeds"] = wte(encoder_input_ids)
                inputs["decoder_inputs_embeds"] = wte(decoder_input_ids)
840

thomwolf's avatar
thomwolf committed
841
            with torch.no_grad():
842
                model(**inputs)
843

844
    def test_lm_head_model_random_no_beam_search_generate(self):
845
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
846
        input_ids = inputs_dict["input_ids"] if "input_ids" in inputs_dict else inputs_dict["inputs"]
847

Patrick von Platen's avatar
Patrick von Platen committed
848
849
850
        # make sure that input_ids is at most of size 15
        input_ids = input_ids[..., :15]

851
        # iterate over all generative models
852
        for model_class in self.all_generative_model_classes:
853
            model = model_class(config).to(torch_device)
Patrick von Platen's avatar
Patrick von Platen committed
854
            model.eval()
855
856

            if config.bos_token_id is None:
857
                # if bos token id is not defined, model needs input_ids
858
                with self.assertRaises(AssertionError):
859
                    model.generate(do_sample=True, max_length=5)
860
                # num_return_sequences = 1
861
                self._check_generated_ids(model.generate(input_ids, do_sample=True))
862
            else:
863
                # num_return_sequences = 1
864
                self._check_generated_ids(model.generate(do_sample=True, max_length=5))
865

866
            with self.assertRaises(AssertionError):
867
                # generating multiple sequences when no beam search generation
868
                # is not allowed as it would always generate the same sequences
869
                model.generate(input_ids, do_sample=False, num_beams=1, num_return_sequences=2)
870

871
872
            # num_return_sequences > 1, sample
            self._check_generated_ids(model.generate(input_ids, do_sample=True, num_return_sequences=2))
873
874

            # check bad words tokens language generation
875
            # create list of 1-seq bad token and list of 2-seq of bad tokens
876
877
878
879
            bad_words_ids = [
                self._generate_random_bad_tokens(1, model.config),
                self._generate_random_bad_tokens(2, model.config),
            ]
880
            output_tokens = model.generate(
881
                input_ids, do_sample=True, bad_words_ids=bad_words_ids, num_return_sequences=2
882
            )
883
            # only count generated tokens
884
885
            generated_ids = output_tokens[:, input_ids.shape[-1] :]
            self.assertFalse(self._check_match_tokens(generated_ids.tolist(), bad_words_ids))
886

887
888
    def test_lm_head_model_random_beam_search_generate(self):
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
889
890
891
        input_ids = (inputs_dict["input_ids"] if "input_ids" in inputs_dict else inputs_dict["inputs"]).to(
            torch_device
        )
892

Patrick von Platen's avatar
Patrick von Platen committed
893
894
895
        # make sure that input_ids is at most of size 15
        input_ids = input_ids[..., :15]

896
        for model_class in self.all_generative_model_classes:
897
            model = model_class(config).to(torch_device)
Patrick von Platen's avatar
Patrick von Platen committed
898
            model.eval()
899
900
901
902
903
904
905
906
907
908
909
910
911

            if config.bos_token_id is None:
                # if bos token id is not defined mobel needs input_ids, num_return_sequences = 1
                self._check_generated_ids(model.generate(input_ids, do_sample=True, num_beams=2))
            else:
                # num_return_sequences = 1
                self._check_generated_ids(model.generate(do_sample=True, max_length=5, num_beams=2))

            with self.assertRaises(AssertionError):
                # generating more sequences than having beams leads is not possible
                model.generate(input_ids, do_sample=False, num_return_sequences=3, num_beams=2)

            # num_return_sequences > 1, sample
Lysandre's avatar
Lysandre committed
912
913
914
915
916
917
918
919
            self._check_generated_ids(
                model.generate(
                    input_ids,
                    do_sample=True,
                    num_beams=2,
                    num_return_sequences=2,
                )
            )
920
921
922
923
924
            # num_return_sequences > 1, greedy
            self._check_generated_ids(model.generate(input_ids, do_sample=False, num_beams=2, num_return_sequences=2))

            # check bad words tokens language generation
            # create list of 1-seq bad token and list of 2-seq of bad tokens
925
926
927
928
            bad_words_ids = [
                self._generate_random_bad_tokens(1, model.config),
                self._generate_random_bad_tokens(2, model.config),
            ]
929
            output_tokens = model.generate(
930
                input_ids, do_sample=False, bad_words_ids=bad_words_ids, num_beams=2, num_return_sequences=2
931
            )
932
            # only count generated tokens
933
934
935
            generated_ids = output_tokens[:, input_ids.shape[-1] :]
            self.assertFalse(self._check_match_tokens(generated_ids.tolist(), bad_words_ids))

936
    def _generate_random_bad_tokens(self, num_bad_tokens: int, config) -> List[int]:
937
        # special tokens cannot be bad tokens
938
        special_tokens = [x for x in [config.bos_token_id, config.eos_token_id, config.pad_token_id] if x is not None]
939
940
941
        # create random bad tokens that are not special tokens
        bad_tokens = []
        while len(bad_tokens) < num_bad_tokens:
942
            token = ids_tensor((1, 1), self.model_tester.vocab_size).squeeze(0).cpu().numpy()[0]
943
944
945
946
            if token not in special_tokens:
                bad_tokens.append(token)
        return bad_tokens

947
    def _check_generated_ids(self, output_ids):
948
949
950
951
        for token_id in output_ids[0].tolist():
            self.assertGreaterEqual(token_id, 0)
            self.assertLess(token_id, self.model_tester.vocab_size)

952
953
954
955
956
957
958
959
960
961
962
963
    def _check_match_tokens(self, generated_ids, bad_words_ids):
        # for all bad word tokens
        for bad_word_ids in bad_words_ids:
            # for all slices in batch
            for generated_ids_slice in generated_ids:
                # for all word idx
                for i in range(len(bad_word_ids), len(generated_ids_slice)):
                    # if tokens match
                    if generated_ids_slice[i - len(bad_word_ids) : i] == bad_word_ids:
                        return True
        return False

964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
    @require_multigpu
    def test_multigpu_data_parallel_forward(self):
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        # some params shouldn't be scattered by nn.DataParallel
        # so just remove them if they are present.
        blacklist_non_batched_params = ["head_mask"]
        for k in blacklist_non_batched_params:
            inputs_dict.pop(k, None)

        # move input tensors to cuda:O
        for k, v in inputs_dict.items():
            if torch.is_tensor(v):
                inputs_dict[k] = v.to(0)

        for model_class in self.all_model_classes:
            model = model_class(config=config)
            model.to(0)
            model.eval()

            # Wrap model in nn.DataParallel
            model = torch.nn.DataParallel(model)
            with torch.no_grad():
987
                _ = model(**self._prepare_for_class(inputs_dict, model_class))
988

989

990
global_rng = random.Random()
thomwolf's avatar
thomwolf committed
991
992


thomwolf's avatar
thomwolf committed
993
def ids_tensor(shape, vocab_size, rng=None, name=None):
994
    #  Creates a random int32 tensor of the shape within the vocab size
thomwolf's avatar
thomwolf committed
995
    if rng is None:
996
        rng = global_rng
thomwolf's avatar
thomwolf committed
997

thomwolf's avatar
thomwolf committed
998
999
1000
    total_dims = 1
    for dim in shape:
        total_dims *= dim
thomwolf's avatar
thomwolf committed
1001

thomwolf's avatar
thomwolf committed
1002
1003
1004
    values = []
    for _ in range(total_dims):
        values.append(rng.randint(0, vocab_size - 1))
thomwolf's avatar
thomwolf committed
1005

1006
    return torch.tensor(data=values, dtype=torch.long, device=torch_device).view(shape).contiguous()
thomwolf's avatar
thomwolf committed
1007
1008


1009
1010
1011
1012
1013
1014
1015
def random_attention_mask(shape, rng=None, name=None):
    attn_mask = ids_tensor(shape, vocab_size=2, rng=None, name=None)
    # make sure that at least one token is attended to for each batch
    attn_mask[:, -1] = 1
    return attn_mask


1016
def floats_tensor(shape, scale=1.0, rng=None, name=None):
Patrick von Platen's avatar
Patrick von Platen committed
1017
    """Creates a random float32 tensor"""
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
    if rng is None:
        rng = global_rng

    total_dims = 1
    for dim in shape:
        total_dims *= dim

    values = []
    for _ in range(total_dims):
        values.append(rng.random() * scale)

1029
    return torch.tensor(data=values, dtype=torch.float, device=torch_device).view(shape).contiguous()
1030
1031


1032
@require_torch
thomwolf's avatar
thomwolf committed
1033
class ModelUtilsTest(unittest.TestCase):
1034
    @slow
Patrick von Platen's avatar
Patrick von Platen committed
1035
    def test_model_from_pretrained(self):
1036
        for model_name in BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
thomwolf's avatar
thomwolf committed
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
            config = BertConfig.from_pretrained(model_name)
            self.assertIsNotNone(config)
            self.assertIsInstance(config, PretrainedConfig)

            model = BertModel.from_pretrained(model_name)
            model, loading_info = BertModel.from_pretrained(model_name, output_loading_info=True)
            self.assertIsNotNone(model)
            self.assertIsInstance(model, PreTrainedModel)
            for value in loading_info.values():
                self.assertEqual(len(value), 0)

            config = BertConfig.from_pretrained(model_name, output_attentions=True, output_hidden_states=True)
            model = BertModel.from_pretrained(model_name, output_attentions=True, output_hidden_states=True)
            self.assertEqual(model.config.output_hidden_states, True)
            self.assertEqual(model.config, config)
1052
1053
1054
1055
1056
1057


@require_torch
class UtilsFunctionsTest(unittest.TestCase):

    # tests whether the top_k_top_p function behaves as expected
Patrick von Platen's avatar
Patrick von Platen committed
1058
    def test_top_k_top_p_filtering(self):
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
        logits = torch.tensor(
            [
                [
                    8.2220991,  # 3rd highest value; idx. 0
                    -0.5620044,
                    5.23229752,
                    4.0386393,
                    -6.8798378,
                    -0.54785802,
                    -3.2012153,
                    2.92777176,
                    1.88171953,
                    7.35341276,  # 5th highest value; idx. 9
                    8.43207833,  # 2nd highest value; idx. 10
                    -9.85711836,
                    -5.96209236,
                    -1.13039161,
                    -7.1115294,
                    -0.8369633,
                    -5.3186408,
                    7.06427407,
                    0.81369344,
                    -0.82023817,
                    -5.9179796,
                    0.58813443,
                    -6.99778438,
                    4.71551189,
                    -0.18771637,
                    7.44020759,  # 4th highest value; idx. 25
                    9.38450987,  # 1st highest value; idx. 26
                    2.12662941,
                    -9.32562038,
                    2.35652522,
                ],  # cummulative prob of 5 highest values <= 0.6
                [
                    0.58425518,
                    4.53139238,
                    -5.57510464,
                    -6.28030699,
                    -7.19529503,
                    -4.02122551,
                    1.39337037,
                    -6.06707057,
                    1.59480517,
                    -9.643119,
                    0.03907799,
                    0.67231762,
                    -8.88206726,
                    6.27115922,  # 4th highest value; idx. 13
                    2.28520723,
                    4.82767506,
                    4.30421368,
                    8.8275313,  # 2nd highest value; idx. 17
                    5.44029958,  # 5th highest value; idx. 18
                    -4.4735794,
                    7.38579536,  # 3rd highest value; idx. 20
                    -2.91051663,
                    2.61946077,
                    -2.5674762,
                    -9.48959302,
                    -4.02922645,
                    -1.35416918,
                    9.67702323,  # 1st highest value; idx. 27
                    -5.89478553,
                    1.85370467,
                ],  # cummulative prob of 5 highest values <= 0.6
            ],
            dtype=torch.float,
            device=torch_device,
        )

        non_inf_expected_idx = torch.tensor(
            [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]],
            dtype=torch.long,
            device=torch_device,
        )  # expected non filtered idx as noted above

        non_inf_expected_output = torch.tensor(
            [
                8.2221,
                7.3534,
                8.4321,
                7.4402,
                9.3845,
                6.2712,
                8.8275,
                5.4403,
                7.3858,
                9.6770,
            ],  # expected non filtered values as noted above
            dtype=torch.float,
            device=torch_device,
        )

        output = top_k_top_p_filtering(logits, top_k=10, top_p=0.6, min_tokens_to_keep=4)
        non_inf_output = output[output != -float("inf")].to(device=torch_device)
        non_inf_idx = (output != -float("inf")).nonzero().to(device=torch_device)

        self.assertTrue(torch.allclose(non_inf_expected_output, non_inf_output, atol=1e-12))
        self.assertTrue(torch.all(torch.eq(non_inf_expected_idx, non_inf_idx)))