test_modeling_common.py 40.7 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 os.path
Aymeric Augustin's avatar
Aymeric Augustin committed
18
import random
19
import tempfile
thomwolf's avatar
thomwolf committed
20
import unittest
21
from typing import List
thomwolf's avatar
thomwolf committed
22

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

Aymeric Augustin's avatar
Aymeric Augustin committed
26

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

31
32
33
34
35
36
    from transformers import (
        AdaptiveEmbedding,
        PretrainedConfig,
        PreTrainedModel,
        BertModel,
        BertConfig,
37
        BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
38
        MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
39
        MODEL_FOR_QUESTION_ANSWERING_MAPPING,
40
        top_k_top_p_filtering,
41
    )
thomwolf's avatar
thomwolf committed
42

43

44
45
46
def _config_zero_init(config):
    configs_no_init = copy.deepcopy(config)
    for key in configs_no_init.__dict__.keys():
47
        if "_range" in key or "_std" in key or "initializer_factor" in key:
Lysandre Debut's avatar
Lysandre Debut committed
48
            setattr(configs_no_init, key, 1e-10)
49
50
    return configs_no_init

thomwolf's avatar
thomwolf committed
51

52
53
54
55
56
@require_torch
class ModelTesterMixin:

    model_tester = None
    all_model_classes = ()
57
    all_generative_model_classes = ()
Patrick von Platen's avatar
Patrick von Platen committed
58
59
60
61
    test_torchscript = True
    test_pruning = True
    test_resize_embeddings = True
    test_head_masking = True
62
    test_missing_keys = True
63
64
    is_encoder_decoder = False

65
66
67
68
    def _prepare_for_class(self, inputs_dict, model_class):
        if model_class in MODEL_FOR_MULTIPLE_CHOICE_MAPPING.values():
            return {
                k: v.unsqueeze(1).expand(-1, self.model_tester.num_choices, -1).contiguous()
69
                if isinstance(v, torch.Tensor) and v.ndim > 1
Sylvain Gugger's avatar
Sylvain Gugger committed
70
                else v
71
72
73
74
                for k, v in inputs_dict.items()
            }
        return inputs_dict

Patrick von Platen's avatar
Patrick von Platen committed
75
    def test_save_load(self):
76
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
77
        config.return_dict = True
78
79
80
81
82
83

        for model_class in self.all_model_classes:
            model = model_class(config)
            model.to(torch_device)
            model.eval()
            with torch.no_grad():
84
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
85
            out_2 = outputs[0].cpu().numpy()
86
            out_2[np.isnan(out_2)] = 0
87

88
            with tempfile.TemporaryDirectory() as tmpdirname:
89
90
                model.save_pretrained(tmpdirname)
                model = model_class.from_pretrained(tmpdirname)
91
                model.to(torch_device)
92
                with torch.no_grad():
93
                    after_outputs = model(**self._prepare_for_class(inputs_dict, model_class))
thomwolf's avatar
thomwolf committed
94

95
96
97
                # 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
98
99
                max_diff = np.amax(np.abs(out_1 - out_2))
                self.assertLessEqual(max_diff, 1e-5)
100

Patrick von Platen's avatar
Patrick von Platen committed
101
    def test_initialization(self):
102
103
104
105
106
107
108
109
        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
110
                        ((param.data.mean() * 1e9).round() / 1e9).item(),
111
112
113
                        [0.0, 1.0],
                        msg="Parameter {} of model {} seems not properly initialized".format(name, model_class),
                    )
thomwolf's avatar
thomwolf committed
114

Patrick von Platen's avatar
Patrick von Platen committed
115
    def test_determinism(self):
116
117
118
119
120
121
122
        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():
123
124
                first = model(**self._prepare_for_class(inputs_dict, model_class))[0]
                second = model(**self._prepare_for_class(inputs_dict, model_class))[0]
125
126
127
128
129
130
131
            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)

Patrick von Platen's avatar
Patrick von Platen committed
132
    def test_attention_outputs(self):
133
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
sshleifer's avatar
sshleifer committed
134
        seq_len = getattr(self.model_tester, "seq_length", None)
sshleifer's avatar
sshleifer committed
135
136
        decoder_seq_length = getattr(self.model_tester, "decoder_seq_length", seq_len)
        encoder_seq_length = getattr(self.model_tester, "encoder_seq_length", seq_len)
137
138
        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
139
140
141
        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
142
143

        for model_class in self.all_model_classes:
144
            inputs_dict["output_attentions"] = True
Joseph Liu's avatar
Joseph Liu committed
145
            inputs_dict["output_hidden_states"] = False
146
147
148
149
            model = model_class(config)
            model.to(torch_device)
            model.eval()
            with torch.no_grad():
150
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
151
            attentions = outputs[-1]
152
153
154
155
156
157
158
159
160
            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():
Sylvain Gugger's avatar
Sylvain Gugger committed
161
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
162
            attentions = outputs[-1]
163
            self.assertEqual(len(attentions), self.model_tester.num_hidden_layers)
Patrick von Platen's avatar
Patrick von Platen committed
164
165
166
167
168
169
170
171
172
173
174

            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],
                )
175
            out_len = len(outputs)
thomwolf's avatar
thomwolf committed
176

177
            if self.is_encoder_decoder:
178
                correct_outlen = 4
Sam Shleifer's avatar
Sam Shleifer committed
179
                decoder_attention_idx = 1
180

181
182
183
184
185
186
187
                # 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
188
189
190
191
192
                    decoder_attention_idx += 1
                self.assertEqual(out_len, correct_outlen)

                decoder_attentions = outputs[decoder_attention_idx]
                self.assertIsInstance(decoder_attentions, (list, tuple))
193
                self.assertEqual(len(decoder_attentions), self.model_tester.num_hidden_layers)
thomwolf's avatar
thomwolf committed
194
                self.assertListEqual(
195
196
                    list(decoder_attentions[0].shape[-3:]),
                    [self.model_tester.num_attention_heads, decoder_seq_length, decoder_key_length],
197
                )
thomwolf's avatar
thomwolf committed
198

199
            # Check attention is always last and order is fine
200
            inputs_dict["output_attentions"] = True
Joseph Liu's avatar
Joseph Liu committed
201
            inputs_dict["output_hidden_states"] = True
202
203
204
205
            model = model_class(config)
            model.to(torch_device)
            model.eval()
            with torch.no_grad():
206
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
207
208
209
210
            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
211
212
213
214
215
216
217
218
219
220
            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
221

Patrick von Platen's avatar
Patrick von Platen committed
222
    def test_torchscript(self):
223
224
        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
225

Patrick von Platen's avatar
Patrick von Platen committed
226
    def test_torchscript_output_attentions(self):
227
228
229
        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
230

Patrick von Platen's avatar
Patrick von Platen committed
231
    def test_torchscript_output_hidden_state(self):
232
233
234
        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
235

236
    def _create_and_check_torchscript(self, config, inputs_dict):
Patrick von Platen's avatar
Patrick von Platen committed
237
        if not self.test_torchscript:
238
            return
239

240
241
242
243
244
245
        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()
246
            inputs = self._prepare_for_class(inputs_dict, model_class)["input_ids"]  # Let's keep only input_ids
thomwolf's avatar
thomwolf committed
247

248
249
250
251
            try:
                traced_gpt2 = torch.jit.trace(model, inputs)
            except RuntimeError:
                self.fail("Couldn't trace module.")
thomwolf's avatar
thomwolf committed
252

253
            with tempfile.TemporaryDirectory() as tmp_dir_name:
254
                pt_file_name = os.path.join(tmp_dir_name, "traced_model.pt")
thomwolf's avatar
thomwolf committed
255

256
257
258
259
                try:
                    torch.jit.save(traced_gpt2, pt_file_name)
                except Exception:
                    self.fail("Couldn't save module.")
thomwolf's avatar
thomwolf committed
260

261
262
263
264
                try:
                    loaded_model = torch.jit.load(pt_file_name)
                except Exception:
                    self.fail("Couldn't load module.")
LysandreJik's avatar
LysandreJik committed
265

266
267
            model.to(torch_device)
            model.eval()
thomwolf's avatar
thomwolf committed
268

269
270
            loaded_model.to(torch_device)
            loaded_model.eval()
thomwolf's avatar
thomwolf committed
271

272
273
274
275
            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
276

277
            models_equal = True
278
279
            for layer_name, p1 in model_state_dict.items():
                p2 = loaded_model_state_dict[layer_name]
280
281
                if p1.data.ne(p2.data).sum() > 0:
                    models_equal = False
thomwolf's avatar
thomwolf committed
282

283
            self.assertTrue(models_equal)
thomwolf's avatar
thomwolf committed
284

Patrick von Platen's avatar
Patrick von Platen committed
285
286
    def test_headmasking(self):
        if not self.test_head_masking:
287
            return
288

289
290
291
        global_rng.seed(42)
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
        global_rng.seed()
LysandreJik's avatar
LysandreJik committed
292

293
        inputs_dict["output_attentions"] = True
294
295
296
297
298
299
        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
300

301
302
303
            # 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(
304
                self.model_tester.num_hidden_layers, self.model_tester.num_attention_heads, device=torch_device,
305
306
307
308
            )
            head_mask[0, 0] = 0
            head_mask[-1, :-1] = 0
            head_mask.requires_grad_(requires_grad=True)
309
            inputs = self._prepare_for_class(inputs_dict, model_class).copy()
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
            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
339
340
    def test_head_pruning(self):
        if not self.test_pruning:
341
342
343
            return

        for model_class in self.all_model_classes:
344
            (config, inputs_dict,) = self.model_tester.prepare_config_and_inputs_for_common()
345

346
347
            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
348

349
            inputs_dict["output_attentions"] = True
350
351
352
353
            config.output_hidden_states = False
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
354
355
356
357
            heads_to_prune = {
                0: list(range(1, self.model_tester.num_attention_heads)),
                -1: [0],
            }
358
359
            model.prune_heads(heads_to_prune)
            with torch.no_grad():
360
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
361

362
            attentions = outputs[-1]
363

364
365
366
            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
367

Patrick von Platen's avatar
Patrick von Platen committed
368
369
    def test_head_pruning_save_load_from_pretrained(self):
        if not self.test_pruning:
370
            return
LysandreJik's avatar
LysandreJik committed
371

372
        for model_class in self.all_model_classes:
373
            (config, inputs_dict,) = self.model_tester.prepare_config_and_inputs_for_common()
374
375
376

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

378
            inputs_dict["output_attentions"] = True
379
380
381
382
            config.output_hidden_states = False
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
383
384
385
386
            heads_to_prune = {
                0: list(range(1, self.model_tester.num_attention_heads)),
                -1: [0],
            }
387
            model.prune_heads(heads_to_prune)
388

389
            with tempfile.TemporaryDirectory() as temp_dir_name:
390
391
                model.save_pretrained(temp_dir_name)
                model = model_class.from_pretrained(temp_dir_name)
392
                model.to(torch_device)
393

394
            with torch.no_grad():
395
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
396
397
398
399
            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)
400

Patrick von Platen's avatar
Patrick von Platen committed
401
402
    def test_head_pruning_save_load_from_config_init(self):
        if not self.test_pruning:
403
            return
404

405
        for model_class in self.all_model_classes:
406
            (config, inputs_dict,) = self.model_tester.prepare_config_and_inputs_for_common()
407

408
409
            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
410

411
            inputs_dict["output_attentions"] = True
412
            config.output_hidden_states = False
413

414
415
416
417
            heads_to_prune = {
                0: list(range(1, self.model_tester.num_attention_heads)),
                -1: [0],
            }
418
            config.pruned_heads = heads_to_prune
419

420
421
422
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
423

424
            with torch.no_grad():
425
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
426
            attentions = outputs[-1]
427

428
429
430
            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)
431

Patrick von Platen's avatar
Patrick von Platen committed
432
433
    def test_head_pruning_integration(self):
        if not self.test_pruning:
434
            return
435

436
        for model_class in self.all_model_classes:
437
            (config, inputs_dict,) = self.model_tester.prepare_config_and_inputs_for_common()
438

439
440
            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
441

442
            inputs_dict["output_attentions"] = True
443
            config.output_hidden_states = False
444

445
446
            heads_to_prune = {0: [0], 1: [1, 2]}
            config.pruned_heads = heads_to_prune
447

448
449
450
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
451

452
            with torch.no_grad():
453
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
454
            attentions = outputs[-1]
455

456
457
458
459
            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
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)
thomwolf's avatar
thomwolf committed
465

466
            with torch.no_grad():
467
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
468
            attentions = outputs[-1]
LysandreJik's avatar
LysandreJik committed
469

470
471
472
473
            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
474

475
476
            heads_to_prune = {0: [0], 2: [1, 2]}
            model.prune_heads(heads_to_prune)
477

478
            with torch.no_grad():
479
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
480
            attentions = outputs[-1]
481

482
483
484
485
            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)
486

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

Patrick von Platen's avatar
Patrick von Platen committed
489
    def test_hidden_states_output(self):
Joseph Liu's avatar
Joseph Liu committed
490
        def check_hidden_states_output(inputs_dict, config, model_class):
491
            model = model_class(config)
492
            model.to(torch_device)
thomwolf's avatar
thomwolf committed
493
            model.eval()
Joseph Liu's avatar
Joseph Liu committed
494

thomwolf's avatar
thomwolf committed
495
            with torch.no_grad():
496
                outputs = model(**self._prepare_for_class(inputs_dict, model_class))
497
            hidden_states = outputs[-1]
Patrick von Platen's avatar
Patrick von Platen committed
498

Joseph Liu's avatar
Joseph Liu committed
499
            self.assertEqual(len(hidden_states), self.model_tester.num_hidden_layers + 1)
Patrick von Platen's avatar
Patrick von Platen committed
500
501
502
503
504
505
506
            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

507
            self.assertListEqual(
Patrick von Platen's avatar
Patrick von Platen committed
508
                list(hidden_states[0].shape[-2:]), [seq_length, self.model_tester.hidden_size],
509
            )
thomwolf's avatar
thomwolf committed
510

Joseph Liu's avatar
Joseph Liu committed
511
512
513
514
515
516
517
518
519
520
521
522
        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)

Patrick von Platen's avatar
Patrick von Platen committed
523
    def test_resize_tokens_embeddings(self):
524
        (original_config, inputs_dict,) = self.model_tester.prepare_config_and_inputs_for_common()
Patrick von Platen's avatar
Patrick von Platen committed
525
        if not self.test_resize_embeddings:
526
527
528
529
530
            return

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

Patrick von Platen's avatar
Patrick von Platen committed
533
534
535
            if self.model_tester.is_training is False:
                model.eval()

536
537
538
539
540
541
542
543
544
545
            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)
546
            # Check that the model can still do a forward pass successfully (every parameter should be resized)
547
            model(**self._prepare_for_class(inputs_dict, model_class))
548
549
550
551
552
553
554

            # 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)

555
556
557
            # 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)
558
            model(**self._prepare_for_class(inputs_dict, model_class))
559

560
561
562
563
564
565
566
567
            # 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
568
    def test_model_common_attributes(self):
569
570
571
572
573
574
575
576
577
        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))

578
    def test_correct_missing_keys(self):
579
580
        if not self.test_missing_keys:
            return
581
582
583
584
585
586
587
588
589
590
591
592
593
594
        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)

595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
    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))

Patrick von Platen's avatar
Patrick von Platen committed
643
    def test_inputs_embeds(self):
Sam Shleifer's avatar
Sam Shleifer committed
644

645
646
647
648
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            model = model_class(config)
649
            model.to(torch_device)
thomwolf's avatar
thomwolf committed
650
            model.eval()
651

652
653
654
655
656
657
658
659
660
661
            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)

662
663
            wte = model.get_input_embeddings()
            if not self.is_encoder_decoder:
664
                inputs["inputs_embeds"] = wte(input_ids)
665
            else:
666
667
                inputs["inputs_embeds"] = wte(encoder_input_ids)
                inputs["decoder_inputs_embeds"] = wte(decoder_input_ids)
668

thomwolf's avatar
thomwolf committed
669
            with torch.no_grad():
670
                model(**inputs)
671

672
    def test_lm_head_model_random_no_beam_search_generate(self):
673
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
674
        input_ids = inputs_dict["input_ids"] if "input_ids" in inputs_dict else inputs_dict["inputs"]
675

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

679
        # iterate over all generative models
680
        for model_class in self.all_generative_model_classes:
681
            model = model_class(config).to(torch_device)
Patrick von Platen's avatar
Patrick von Platen committed
682
            model.eval()
683
684

            if config.bos_token_id is None:
685
                # if bos token id is not defined, model needs input_ids
686
                with self.assertRaises(AssertionError):
687
                    model.generate(do_sample=True, max_length=5)
688
                # num_return_sequences = 1
689
                self._check_generated_ids(model.generate(input_ids, do_sample=True))
690
            else:
691
                # num_return_sequences = 1
692
                self._check_generated_ids(model.generate(do_sample=True, max_length=5))
693

694
            with self.assertRaises(AssertionError):
695
                # generating multiple sequences when no beam search generation
696
697
698
                # is not allowed as it would always generate the same sequences
                model.generate(input_ids, do_sample=False, num_return_sequences=2)

699
700
            # num_return_sequences > 1, sample
            self._check_generated_ids(model.generate(input_ids, do_sample=True, num_return_sequences=2))
701
702

            # check bad words tokens language generation
703
            # create list of 1-seq bad token and list of 2-seq of bad tokens
704
705
706
707
            bad_words_ids = [
                self._generate_random_bad_tokens(1, model.config),
                self._generate_random_bad_tokens(2, model.config),
            ]
708
            output_tokens = model.generate(
709
                input_ids, do_sample=True, bad_words_ids=bad_words_ids, num_return_sequences=2
710
            )
711
            # only count generated tokens
712
713
            generated_ids = output_tokens[:, input_ids.shape[-1] :]
            self.assertFalse(self._check_match_tokens(generated_ids.tolist(), bad_words_ids))
714

715
716
    def test_lm_head_model_random_beam_search_generate(self):
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
717
718
719
        input_ids = (inputs_dict["input_ids"] if "input_ids" in inputs_dict else inputs_dict["inputs"]).to(
            torch_device
        )
720

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

724
        for model_class in self.all_generative_model_classes:
725
            model = model_class(config).to(torch_device)
Patrick von Platen's avatar
Patrick von Platen committed
726
            model.eval()
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745

            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
            self._check_generated_ids(model.generate(input_ids, do_sample=True, num_beams=2, num_return_sequences=2,))
            # 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
746
747
748
749
            bad_words_ids = [
                self._generate_random_bad_tokens(1, model.config),
                self._generate_random_bad_tokens(2, model.config),
            ]
750
            output_tokens = model.generate(
751
                input_ids, do_sample=False, bad_words_ids=bad_words_ids, num_beams=2, num_return_sequences=2
752
            )
753
            # only count generated tokens
754
755
756
            generated_ids = output_tokens[:, input_ids.shape[-1] :]
            self.assertFalse(self._check_match_tokens(generated_ids.tolist(), bad_words_ids))

757
    def _generate_random_bad_tokens(self, num_bad_tokens: int, config) -> List[int]:
758
        # special tokens cannot be bad tokens
759
        special_tokens = [x for x in [config.bos_token_id, config.eos_token_id, config.pad_token_id] if x is not None]
760
761
762
        # create random bad tokens that are not special tokens
        bad_tokens = []
        while len(bad_tokens) < num_bad_tokens:
763
            token = ids_tensor((1, 1), self.model_tester.vocab_size).squeeze(0).cpu().numpy()[0]
764
765
766
767
            if token not in special_tokens:
                bad_tokens.append(token)
        return bad_tokens

768
    def _check_generated_ids(self, output_ids):
769
770
771
772
        for token_id in output_ids[0].tolist():
            self.assertGreaterEqual(token_id, 0)
            self.assertLess(token_id, self.model_tester.vocab_size)

773
774
775
776
777
778
779
780
781
782
783
784
    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

785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
    @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():
808
                _ = model(**self._prepare_for_class(inputs_dict, model_class))
809

810

811
global_rng = random.Random()
thomwolf's avatar
thomwolf committed
812
813


thomwolf's avatar
thomwolf committed
814
def ids_tensor(shape, vocab_size, rng=None, name=None):
815
    #  Creates a random int32 tensor of the shape within the vocab size
thomwolf's avatar
thomwolf committed
816
    if rng is None:
817
        rng = global_rng
thomwolf's avatar
thomwolf committed
818

thomwolf's avatar
thomwolf committed
819
820
821
    total_dims = 1
    for dim in shape:
        total_dims *= dim
thomwolf's avatar
thomwolf committed
822

thomwolf's avatar
thomwolf committed
823
824
825
    values = []
    for _ in range(total_dims):
        values.append(rng.randint(0, vocab_size - 1))
thomwolf's avatar
thomwolf committed
826

827
    return torch.tensor(data=values, dtype=torch.long, device=torch_device).view(shape).contiguous()
thomwolf's avatar
thomwolf committed
828
829


830
def floats_tensor(shape, scale=1.0, rng=None, name=None):
Patrick von Platen's avatar
Patrick von Platen committed
831
    """Creates a random float32 tensor"""
832
833
834
835
836
837
838
839
840
841
842
    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)

843
    return torch.tensor(data=values, dtype=torch.float, device=torch_device).view(shape).contiguous()
844
845


846
@require_torch
thomwolf's avatar
thomwolf committed
847
class ModelUtilsTest(unittest.TestCase):
848
    @slow
Patrick von Platen's avatar
Patrick von Platen committed
849
    def test_model_from_pretrained(self):
850
        for model_name in BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
thomwolf's avatar
thomwolf committed
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
            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)
866
867
868
869
870
871


@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
872
    def test_top_k_top_p_filtering(self):
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
        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)))