Refactor FLAX tests (#9034)

2020-12-10 15:57:39 -05:00
parent 1310e1a758
commit 8d4bb02056
4 changed files with 294 additions and 110 deletions
--- a/tests/test_modeling_flax_roberta.py
+++ b/tests/test_modeling_flax_roberta.py
@@ -14,70 +14,98 @@

 import unittest

-from numpy import ndarray
+from transformers import RobertaConfig, is_flax_available
+from transformers.testing_utils import require_flax

-from transformers import RobertaTokenizerFast, TensorType, is_flax_available, is_torch_available
-from transformers.testing_utils import require_flax, require_torch
+from .test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


 if is_flax_available():
-    import os
-
-    os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.12"  # assumed parallelism: 8
-
-    import jax
    from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel

-if is_torch_available():
-    import torch

-    from transformers.models.roberta.modeling_roberta import RobertaModel
+class FlaxRobertaModelTester(unittest.TestCase):
+    def __init__(
+        self,
+        parent,
+        batch_size=13,
+        seq_length=7,
+        is_training=True,
+        use_attention_mask=True,
+        use_token_type_ids=True,
+        use_labels=True,
+        vocab_size=99,
+        hidden_size=32,
+        num_hidden_layers=5,
+        num_attention_heads=4,
+        intermediate_size=37,
+        hidden_act="gelu",
+        hidden_dropout_prob=0.1,
+        attention_probs_dropout_prob=0.1,
+        max_position_embeddings=512,
+        type_vocab_size=16,
+        type_sequence_label_size=2,
+        initializer_range=0.02,
+    ):
+        self.parent = parent
+        self.batch_size = batch_size
+        self.seq_length = seq_length
+        self.is_training = is_training
+        self.use_attention_mask = use_attention_mask
+        self.use_token_type_ids = use_token_type_ids
+        self.use_labels = use_labels
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.intermediate_size = intermediate_size
+        self.hidden_act = hidden_act
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.max_position_embeddings = max_position_embeddings
+        self.type_vocab_size = type_vocab_size
+        self.type_sequence_label_size = type_sequence_label_size
+        self.initializer_range = initializer_range
+
+    def prepare_config_and_inputs(self):
+        input_ids = ids_tensor([self.batch_size, self.seq_length], self.vocab_size)
+
+        attention_mask = None
+        if self.use_attention_mask:
+            attention_mask = random_attention_mask([self.batch_size, self.seq_length])
+
+        token_type_ids = None
+        if self.use_token_type_ids:
+            token_type_ids = ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size)
+
+        config = RobertaConfig(
+            vocab_size=self.vocab_size,
+            hidden_size=self.hidden_size,
+            num_hidden_layers=self.num_hidden_layers,
+            num_attention_heads=self.num_attention_heads,
+            intermediate_size=self.intermediate_size,
+            hidden_act=self.hidden_act,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.max_position_embeddings,
+            type_vocab_size=self.type_vocab_size,
+            is_decoder=False,
+            initializer_range=self.initializer_range,
+        )
+
+        return config, input_ids, token_type_ids, attention_mask
+
+    def prepare_config_and_inputs_for_common(self):
+        config_and_inputs = self.prepare_config_and_inputs()
+        config, input_ids, token_type_ids, attention_mask = config_and_inputs
+        inputs_dict = {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": attention_mask}
+        return config, inputs_dict


@require_flax
-@require_torch
-class FlaxRobertaModelTest(unittest.TestCase):
-    def assert_almost_equals(self, a: ndarray, b: ndarray, tol: float):
-        diff = (a - b).sum()
-        self.assertLessEqual(diff, tol, f"Difference between torch and flax is {diff} (>= {tol})")
+class FlaxRobertaModelTest(FlaxModelTesterMixin, unittest.TestCase):

-    def test_from_pytorch(self):
-        with torch.no_grad():
-            with self.subTest("roberta-base"):
-                tokenizer = RobertaTokenizerFast.from_pretrained("roberta-base")
-                fx_model = FlaxRobertaModel.from_pretrained("roberta-base")
-                pt_model = RobertaModel.from_pretrained("roberta-base")
+    all_model_classes = (FlaxRobertaModel,) if is_flax_available() else ()

-                # Check for simple input
-                pt_inputs = tokenizer.encode_plus("This is a simple input", return_tensors=TensorType.PYTORCH)
-                fx_inputs = tokenizer.encode_plus("This is a simple input", return_tensors=TensorType.JAX)
-                pt_outputs = pt_model(**pt_inputs)
-                fx_outputs = fx_model(**fx_inputs)
-
-                self.assertEqual(len(fx_outputs), len(pt_outputs), "Output lengths differ between Flax and PyTorch")
-
-                for fx_output, pt_output in zip(fx_outputs, pt_outputs.to_tuple()):
-                    self.assert_almost_equals(fx_output, pt_output.numpy(), 5e-3)
-
-    def test_multiple_sequences(self):
-        tokenizer = RobertaTokenizerFast.from_pretrained("roberta-base")
-        model = FlaxRobertaModel.from_pretrained("roberta-base")
-
-        sequences = ["this is an example sentence", "this is another", "and a third one"]
-        encodings = tokenizer(sequences, return_tensors=TensorType.JAX, padding=True, truncation=True)
-
-        @jax.jit
-        def model_jitted(input_ids, attention_mask=None, token_type_ids=None):
-            return model(input_ids, attention_mask, token_type_ids)
-
-        with self.subTest("JIT Disabled"):
-            with jax.disable_jit():
-                tokens, pooled = model_jitted(**encodings)
-                self.assertEqual(tokens.shape, (3, 7, 768))
-                self.assertEqual(pooled.shape, (3, 768))
-
-        with self.subTest("JIT Enabled"):
-            jitted_tokens, jitted_pooled = model_jitted(**encodings)
-
-            self.assertEqual(jitted_tokens.shape, (3, 7, 768))
-            self.assertEqual(jitted_pooled.shape, (3, 768))
+    def setUp(self):
+        self.model_tester = FlaxRobertaModelTester(self)