test_modeling_tf_xlm.py 12 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 2018 The Google AI Language Team Authors.
#
# 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

thomwolf's avatar
thomwolf committed
16

17
18
import unittest

19
from transformers import is_tf_available
20
from transformers.testing_utils import require_tf, slow
thomwolf's avatar
thomwolf committed
21

22
from .test_configuration_common import ConfigTester
23
from .test_modeling_tf_common import TFModelTesterMixin, ids_tensor
Aymeric Augustin's avatar
Aymeric Augustin committed
24
25


thomwolf's avatar
thomwolf committed
26
27
if is_tf_available():
    import tensorflow as tf
28

29
    from transformers import (
30
31
        TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFXLMForMultipleChoice,
32
        TFXLMForQuestionAnsweringSimple,
33
        TFXLMForSequenceClassification,
34
        TFXLMForTokenClassification,
35
36
37
        TFXLMModel,
        TFXLMWithLMHeadModel,
        XLMConfig,
38
39
    )

thomwolf's avatar
thomwolf committed
40

41
42
class TFXLMModelTester:
    def __init__(
Lysandre's avatar
Lysandre committed
43
44
        self,
        parent,
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
    ):
        self.parent = parent
        self.batch_size = 13
        self.seq_length = 7
        self.is_training = True
        self.use_input_lengths = True
        self.use_token_type_ids = True
        self.use_labels = True
        self.gelu_activation = True
        self.sinusoidal_embeddings = False
        self.causal = False
        self.asm = False
        self.n_langs = 2
        self.vocab_size = 99
        self.n_special = 0
        self.hidden_size = 32
        self.num_hidden_layers = 5
        self.num_attention_heads = 4
        self.hidden_dropout_prob = 0.1
        self.attention_probs_dropout_prob = 0.1
        self.max_position_embeddings = 512
        self.type_vocab_size = 16
        self.type_sequence_label_size = 2
        self.initializer_range = 0.02
        self.num_labels = 3
        self.num_choices = 4
        self.summary_type = "last"
        self.use_proj = True
        self.scope = None
        self.bos_token_id = 0

    def prepare_config_and_inputs(self):
        input_ids = ids_tensor([self.batch_size, self.seq_length], self.vocab_size)
        input_mask = ids_tensor([self.batch_size, self.seq_length], 2, dtype=tf.float32)

        input_lengths = None
        if self.use_input_lengths:
            input_lengths = (
                ids_tensor([self.batch_size], vocab_size=2) + self.seq_length - 2
            )  # small variation of seq_length

        token_type_ids = None
        if self.use_token_type_ids:
            token_type_ids = ids_tensor([self.batch_size, self.seq_length], self.n_langs)

        sequence_labels = None
        token_labels = None
        is_impossible_labels = None
        if self.use_labels:
            sequence_labels = ids_tensor([self.batch_size], self.type_sequence_label_size)
            token_labels = ids_tensor([self.batch_size, self.seq_length], self.num_labels)
            is_impossible_labels = ids_tensor([self.batch_size], 2, dtype=tf.float32)
97
            choice_labels = ids_tensor([self.batch_size], self.num_choices)
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

        config = XLMConfig(
            vocab_size=self.vocab_size,
            n_special=self.n_special,
            emb_dim=self.hidden_size,
            n_layers=self.num_hidden_layers,
            n_heads=self.num_attention_heads,
            dropout=self.hidden_dropout_prob,
            attention_dropout=self.attention_probs_dropout_prob,
            gelu_activation=self.gelu_activation,
            sinusoidal_embeddings=self.sinusoidal_embeddings,
            asm=self.asm,
            causal=self.causal,
            n_langs=self.n_langs,
            max_position_embeddings=self.max_position_embeddings,
            initializer_range=self.initializer_range,
            summary_type=self.summary_type,
            use_proj=self.use_proj,
            bos_token_id=self.bos_token_id,
Sylvain Gugger's avatar
Sylvain Gugger committed
117
            return_dict=True,
118
119
120
        )

        return (
121
122
123
124
125
126
127
            config,
            input_ids,
            token_type_ids,
            input_lengths,
            sequence_labels,
            token_labels,
            is_impossible_labels,
128
            choice_labels,
129
            input_mask,
130
131
132
133
134
135
136
137
138
139
140
        )

    def create_and_check_xlm_model(
        self,
        config,
        input_ids,
        token_type_ids,
        input_lengths,
        sequence_labels,
        token_labels,
        is_impossible_labels,
141
        choice_labels,
142
143
144
145
        input_mask,
    ):
        model = TFXLMModel(config=config)
        inputs = {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
Sylvain Gugger's avatar
Sylvain Gugger committed
146
        result = model(inputs)
147
148

        inputs = [input_ids, input_mask]
Sylvain Gugger's avatar
Sylvain Gugger committed
149
        result = model(inputs)
150
        self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size))
151
152
153
154
155
156
157
158
159
160

    def create_and_check_xlm_lm_head(
        self,
        config,
        input_ids,
        token_type_ids,
        input_lengths,
        sequence_labels,
        token_labels,
        is_impossible_labels,
161
        choice_labels,
162
163
164
165
166
167
168
        input_mask,
    ):
        model = TFXLMWithLMHeadModel(config)

        inputs = {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
        outputs = model(inputs)

Sylvain Gugger's avatar
Sylvain Gugger committed
169
        result = outputs
170

171
        self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size))
172
173
174
175
176
177
178
179
180
181

    def create_and_check_xlm_qa(
        self,
        config,
        input_ids,
        token_type_ids,
        input_lengths,
        sequence_labels,
        token_labels,
        is_impossible_labels,
182
        choice_labels,
183
184
185
186
187
188
        input_mask,
    ):
        model = TFXLMForQuestionAnsweringSimple(config)

        inputs = {"input_ids": input_ids, "lengths": input_lengths}

Sylvain Gugger's avatar
Sylvain Gugger committed
189
        result = model(inputs)
190

191
192
        self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length))
        self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length))
193
194
195
196
197
198
199
200
201
202

    def create_and_check_xlm_sequence_classif(
        self,
        config,
        input_ids,
        token_type_ids,
        input_lengths,
        sequence_labels,
        token_labels,
        is_impossible_labels,
203
        choice_labels,
204
205
206
207
208
209
        input_mask,
    ):
        model = TFXLMForSequenceClassification(config)

        inputs = {"input_ids": input_ids, "lengths": input_lengths}

Sylvain Gugger's avatar
Sylvain Gugger committed
210
        result = model(inputs)
211

212
        self.parent.assertEqual(result.logits.shape, (self.batch_size, self.type_sequence_label_size))
213

214
215
216
217
218
219
220
221
222
    def create_and_check_xlm_for_token_classification(
        self,
        config,
        input_ids,
        token_type_ids,
        input_lengths,
        sequence_labels,
        token_labels,
        is_impossible_labels,
223
        choice_labels,
224
225
226
227
228
        input_mask,
    ):
        config.num_labels = self.num_labels
        model = TFXLMForTokenClassification(config=config)
        inputs = {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
Sylvain Gugger's avatar
Sylvain Gugger committed
229
        result = model(inputs)
230
        self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels))
231

232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
    def create_and_check_xlm_for_multiple_choice(
        self,
        config,
        input_ids,
        token_type_ids,
        input_lengths,
        sequence_labels,
        token_labels,
        is_impossible_labels,
        choice_labels,
        input_mask,
    ):
        config.num_choices = self.num_choices
        model = TFXLMForMultipleChoice(config=config)
        multiple_choice_inputs_ids = tf.tile(tf.expand_dims(input_ids, 1), (1, self.num_choices, 1))
        multiple_choice_input_mask = tf.tile(tf.expand_dims(input_mask, 1), (1, self.num_choices, 1))
        multiple_choice_token_type_ids = tf.tile(tf.expand_dims(token_type_ids, 1), (1, self.num_choices, 1))
        inputs = {
            "input_ids": multiple_choice_inputs_ids,
            "attention_mask": multiple_choice_input_mask,
            "token_type_ids": multiple_choice_token_type_ids,
        }
Sylvain Gugger's avatar
Sylvain Gugger committed
254
        result = model(inputs)
255
        self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices))
256

257
258
259
    def prepare_config_and_inputs_for_common(self):
        config_and_inputs = self.prepare_config_and_inputs()
        (
260
261
262
263
264
265
266
            config,
            input_ids,
            token_type_ids,
            input_lengths,
            sequence_labels,
            token_labels,
            is_impossible_labels,
267
            choice_labels,
268
            input_mask,
269
270
271
272
273
274
275
276
        ) = config_and_inputs
        inputs_dict = {
            "input_ids": input_ids,
            "token_type_ids": token_type_ids,
            "langs": token_type_ids,
            "lengths": input_lengths,
        }
        return config, inputs_dict
thomwolf's avatar
thomwolf committed
277
278


279
280
@require_tf
class TFXLMModelTest(TFModelTesterMixin, unittest.TestCase):
281

282
    all_model_classes = (
283
284
285
286
287
288
        (
            TFXLMModel,
            TFXLMWithLMHeadModel,
            TFXLMForSequenceClassification,
            TFXLMForQuestionAnsweringSimple,
            TFXLMForTokenClassification,
289
            TFXLMForMultipleChoice,
290
        )
291
292
293
294
295
296
        if is_tf_available()
        else ()
    )
    all_generative_model_classes = (
        (TFXLMWithLMHeadModel,) if is_tf_available() else ()
    )  # TODO (PVP): Check other models whether language generation is also applicable
thomwolf's avatar
thomwolf committed
297
298

    def setUp(self):
299
        self.model_tester = TFXLMModelTester(self)
thomwolf's avatar
thomwolf committed
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
        self.config_tester = ConfigTester(self, config_class=XLMConfig, emb_dim=37)

    def test_config(self):
        self.config_tester.run_common_tests()

    def test_xlm_model(self):
        config_and_inputs = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_model(*config_and_inputs)

    def test_xlm_lm_head(self):
        config_and_inputs = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_lm_head(*config_and_inputs)

    def test_xlm_qa(self):
        config_and_inputs = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_qa(*config_and_inputs)

    def test_xlm_sequence_classif(self):
        config_and_inputs = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_sequence_classif(*config_and_inputs)

321
322
323
324
    def test_for_token_classification(self):
        config_and_inputs = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_for_token_classification(*config_and_inputs)

325
326
327
328
    def test_for_multiple_choice(self):
        config_and_inputs = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_xlm_for_multiple_choice(*config_and_inputs)

329
    @slow
thomwolf's avatar
thomwolf committed
330
    def test_model_from_pretrained(self):
331
        for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
332
            model = TFXLMModel.from_pretrained(model_name)
thomwolf's avatar
thomwolf committed
333
            self.assertIsNotNone(model)
patrickvonplaten's avatar
patrickvonplaten committed
334
335


336
@require_tf
patrickvonplaten's avatar
patrickvonplaten committed
337
338
339
340
class TFXLMModelLanguageGenerationTest(unittest.TestCase):
    @slow
    def test_lm_generate_xlm_mlm_en_2048(self):
        model = TFXLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048")
341
        input_ids = tf.convert_to_tensor([[14, 447]], dtype=tf.int32)  # the president
patrickvonplaten's avatar
patrickvonplaten committed
342
343
        expected_output_ids = [
            14,
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
            14,
            447,
        ]  # the president the president the president the president the president the president the president the president the president the president
        # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
Patrick von Platen's avatar
Patrick von Platen committed
365
366
        output_ids = model.generate(input_ids, do_sample=False)
        self.assertListEqual(output_ids[0].numpy().tolist(), expected_output_ids)