test_modeling_common.py 40.8 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

25
from .utils import require_multigpu, require_torch, slow, torch_device
26

Aymeric Augustin's avatar
Aymeric Augustin committed
27

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

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

44

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

thomwolf's avatar
thomwolf committed
52

53
54
55
56
57
@require_torch
class ModelTesterMixin:

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

66
67
68
69
    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()
Sylvain Gugger's avatar
Sylvain Gugger committed
70
71
                if isinstance(v, torch.Tensor) and v.ndim != 0
                else v
72
73
74
75
                for k, v in inputs_dict.items()
            }
        return inputs_dict

Patrick von Platen's avatar
Patrick von Platen committed
76
    def test_save_load(self):
77
78
79
80
81
82
83
        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():
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
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
thomwolf's avatar
thomwolf committed
224

225
        self._create_and_check_torchscript(config, inputs_dict)
thomwolf's avatar
thomwolf committed
226

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

Patrick von Platen's avatar
Patrick von Platen committed
232
    def test_torchscript_output_hidden_state(self):
233
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
234

235
236
        config.output_hidden_states = True
        self._create_and_check_torchscript(config, inputs_dict)
thomwolf's avatar
thomwolf committed
237

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

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

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

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

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

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

268
269
            model.to(torch_device)
            model.eval()
thomwolf's avatar
thomwolf committed
270

271
272
            loaded_model.to(torch_device)
            loaded_model.eval()
thomwolf's avatar
thomwolf committed
273

274
275
276
277
            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
278

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

285
            self.assertTrue(models_equal)
thomwolf's avatar
thomwolf committed
286

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

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

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

303
304
305
            # 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(
306
                self.model_tester.num_hidden_layers, self.model_tester.num_attention_heads, device=torch_device,
307
308
309
310
            )
            head_mask[0, 0] = 0
            head_mask[-1, :-1] = 0
            head_mask.requires_grad_(requires_grad=True)
311
            inputs = self._prepare_for_class(inputs_dict, model_class).copy()
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
339
340
            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
341
342
    def test_head_pruning(self):
        if not self.test_pruning:
343
344
345
            return

        for model_class in self.all_model_classes:
346
            (config, inputs_dict,) = self.model_tester.prepare_config_and_inputs_for_common()
347

348
349
            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
350

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

364
            attentions = outputs[-1]
365

366
367
368
            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
369

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

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

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

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

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

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

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

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

410
411
            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
412

413
            inputs_dict["output_attentions"] = True
414
            config.output_hidden_states = False
415

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

422
423
424
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
425

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

430
431
432
            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)
433

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

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

441
442
            if "head_mask" in inputs_dict:
                del inputs_dict["head_mask"]
443

444
            inputs_dict["output_attentions"] = True
445
            config.output_hidden_states = False
446

447
448
            heads_to_prune = {0: [0], 1: [1, 2]}
            config.pruned_heads = heads_to_prune
449

450
451
452
            model = model_class(config=config)
            model.to(torch_device)
            model.eval()
453

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

458
459
460
461
            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
462

463
            with tempfile.TemporaryDirectory() as temp_dir_name:
464
465
                model.save_pretrained(temp_dir_name)
                model = model_class.from_pretrained(temp_dir_name)
466
                model.to(torch_device)
thomwolf's avatar
thomwolf committed
467

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

472
473
474
475
            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
476

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

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

484
485
486
487
            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)
488

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

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

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

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

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

Joseph Liu's avatar
Joseph Liu committed
513
514
515
516
517
518
519
520
521
522
523
524
        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
525
    def test_resize_tokens_embeddings(self):
526
        (original_config, inputs_dict,) = self.model_tester.prepare_config_and_inputs_for_common()
Patrick von Platen's avatar
Patrick von Platen committed
527
        if not self.test_resize_embeddings:
528
529
530
531
532
            return

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

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

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

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

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

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

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

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
643
644
645
646
647
648
649
    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

            params_not_tied = list(model_not_tied.parameters())

            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.assertGreater(len(params_not_tied), len(params_tied))
            # 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.assertGreater(len(params_not_tied), len(params_tied))
            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
650
    def test_inputs_embeds(self):
Sam Shleifer's avatar
Sam Shleifer committed
651

652
653
654
655
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            model = model_class(config)
656
            model.to(torch_device)
thomwolf's avatar
thomwolf committed
657
            model.eval()
658

659
660
661
662
663
664
665
666
667
668
            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)

669
670
            wte = model.get_input_embeddings()
            if not self.is_encoder_decoder:
671
                inputs["inputs_embeds"] = wte(input_ids)
672
            else:
673
674
                inputs["inputs_embeds"] = wte(encoder_input_ids)
                inputs["decoder_inputs_embeds"] = wte(decoder_input_ids)
675

thomwolf's avatar
thomwolf committed
676
            with torch.no_grad():
677
                model(**inputs)
678

679
    def test_lm_head_model_random_no_beam_search_generate(self):
680
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
681
        input_ids = inputs_dict["input_ids"] if "input_ids" in inputs_dict else inputs_dict["inputs"]
682

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

686
        # iterate over all generative models
687
        for model_class in self.all_generative_model_classes:
688
            model = model_class(config).to(torch_device)
Patrick von Platen's avatar
Patrick von Platen committed
689
            model.eval()
690
691

            if config.bos_token_id is None:
692
                # if bos token id is not defined, model needs input_ids
693
                with self.assertRaises(AssertionError):
694
                    model.generate(do_sample=True, max_length=5)
695
                # num_return_sequences = 1
696
                self._check_generated_ids(model.generate(input_ids, do_sample=True))
697
            else:
698
                # num_return_sequences = 1
699
                self._check_generated_ids(model.generate(do_sample=True, max_length=5))
700

701
            with self.assertRaises(AssertionError):
702
                # generating multiple sequences when no beam search generation
703
704
705
                # is not allowed as it would always generate the same sequences
                model.generate(input_ids, do_sample=False, num_return_sequences=2)

706
707
            # num_return_sequences > 1, sample
            self._check_generated_ids(model.generate(input_ids, do_sample=True, num_return_sequences=2))
708
709

            # check bad words tokens language generation
710
            # create list of 1-seq bad token and list of 2-seq of bad tokens
711
712
713
714
            bad_words_ids = [
                self._generate_random_bad_tokens(1, model.config),
                self._generate_random_bad_tokens(2, model.config),
            ]
715
            output_tokens = model.generate(
716
                input_ids, do_sample=True, bad_words_ids=bad_words_ids, num_return_sequences=2
717
            )
718
            # only count generated tokens
719
720
            generated_ids = output_tokens[:, input_ids.shape[-1] :]
            self.assertFalse(self._check_match_tokens(generated_ids.tolist(), bad_words_ids))
721

722
723
    def test_lm_head_model_random_beam_search_generate(self):
        config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common()
724
725
726
        input_ids = (inputs_dict["input_ids"] if "input_ids" in inputs_dict else inputs_dict["inputs"]).to(
            torch_device
        )
727

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

731
        for model_class in self.all_generative_model_classes:
732
            model = model_class(config).to(torch_device)
Patrick von Platen's avatar
Patrick von Platen committed
733
            model.eval()
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752

            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
753
754
755
756
            bad_words_ids = [
                self._generate_random_bad_tokens(1, model.config),
                self._generate_random_bad_tokens(2, model.config),
            ]
757
            output_tokens = model.generate(
758
                input_ids, do_sample=False, bad_words_ids=bad_words_ids, num_beams=2, num_return_sequences=2
759
            )
760
            # only count generated tokens
761
762
763
            generated_ids = output_tokens[:, input_ids.shape[-1] :]
            self.assertFalse(self._check_match_tokens(generated_ids.tolist(), bad_words_ids))

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

775
    def _check_generated_ids(self, output_ids):
776
777
778
779
        for token_id in output_ids[0].tolist():
            self.assertGreaterEqual(token_id, 0)
            self.assertLess(token_id, self.model_tester.vocab_size)

780
781
782
783
784
785
786
787
788
789
790
791
    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

792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
    @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():
                _ = model(**inputs_dict)

817

818
global_rng = random.Random()
thomwolf's avatar
thomwolf committed
819
820


thomwolf's avatar
thomwolf committed
821
def ids_tensor(shape, vocab_size, rng=None, name=None):
822
    #  Creates a random int32 tensor of the shape within the vocab size
thomwolf's avatar
thomwolf committed
823
    if rng is None:
824
        rng = global_rng
thomwolf's avatar
thomwolf committed
825

thomwolf's avatar
thomwolf committed
826
827
828
    total_dims = 1
    for dim in shape:
        total_dims *= dim
thomwolf's avatar
thomwolf committed
829

thomwolf's avatar
thomwolf committed
830
831
832
    values = []
    for _ in range(total_dims):
        values.append(rng.randint(0, vocab_size - 1))
thomwolf's avatar
thomwolf committed
833

834
    return torch.tensor(data=values, dtype=torch.long, device=torch_device).view(shape).contiguous()
thomwolf's avatar
thomwolf committed
835
836


837
def floats_tensor(shape, scale=1.0, rng=None, name=None):
Patrick von Platen's avatar
Patrick von Platen committed
838
    """Creates a random float32 tensor"""
839
840
841
842
843
844
845
846
847
848
849
    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)

850
    return torch.tensor(data=values, dtype=torch.float, device=torch_device).view(shape).contiguous()
851
852


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


@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
879
    def test_top_k_top_p_filtering(self):
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
973
974
975
976
977
978
979
        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)))