[BartTokenizerFast] add prepare_seq2seq_batch (#6543)

tests/test_modeling_bart.py

@@ -38,6 +38,7 @@ if is_torch_available():
         BartForQuestionAnswering,
         BartConfig,
         BartTokenizer,
+        BartTokenizerFast,
         pipeline,
     )
     from transformers.modeling_bart import (
@@ -421,6 +422,10 @@ class BartModelIntegrationTests(unittest.TestCase):
     def default_tokenizer(self):
         return BartTokenizer.from_pretrained("facebook/bart-large")
 
+    @cached_property
+    def default_tokenizer_fast(self):
+        return BartTokenizerFast.from_pretrained("facebook/bart-large")
+
     @slow
     def test_inference_no_head(self):
         model = BartModel.from_pretrained("facebook/bart-large").to(torch_device)
@@ -564,74 +569,82 @@ class BartModelIntegrationTests(unittest.TestCase):
         # TODO(SS): add test case that hits max_length
 
     def test_prepare_seq2seq_batch(self):
-        tokenizer = self.default_tokenizer
+        tokenizers = [self.default_tokenizer, self.default_tokenizer_fast]
         src_text = ["A long paragraph for summrization.", "Another paragraph for summrization."]
         tgt_text = [
             "Summary of the text.",
             "Another summary.",
         ]
         expected_src_tokens = [0, 250, 251, 17818, 13, 32933, 21645, 1258, 4, 2]
-        batch = tokenizer.prepare_seq2seq_batch(
-            src_text, tgt_texts=tgt_text, max_length=len(expected_src_tokens), return_tensors="pt"
-        )
-        self.assertIsInstance(batch, BatchEncoding)
 
-        self.assertEqual((2, 10), batch.input_ids.shape)
-        self.assertEqual((2, 10), batch.attention_mask.shape)
-        result = batch.input_ids.tolist()[0]
-        self.assertListEqual(expected_src_tokens, result)
-        # Test that special tokens are reset
+        for tokenizer in tokenizers:
+            batch = tokenizer.prepare_seq2seq_batch(
+                src_text, tgt_texts=tgt_text, max_length=len(expected_src_tokens), return_tensors="pt"
+            )
+            self.assertIsInstance(batch, BatchEncoding)
+
+            self.assertEqual((2, 10), batch.input_ids.shape)
+            self.assertEqual((2, 10), batch.attention_mask.shape)
+            result = batch.input_ids.tolist()[0]
+            self.assertListEqual(expected_src_tokens, result)
+            # Test that special tokens are reset
 
     def test_empty_target_text(self):
-        tokenizer = self.default_tokenizer
+        tokenizers = [self.default_tokenizer, self.default_tokenizer_fast]
         src_text = ["A long paragraph for summrization.", "Another paragraph for summrization."]
-        batch = tokenizer.prepare_seq2seq_batch(src_text, return_tensors="pt")
-        # check if input_ids are returned and no decoder_input_ids
-        self.assertIn("input_ids", batch)
-        self.assertIn("attention_mask", batch)
-        self.assertNotIn("decoder_input_ids", batch)
-        self.assertNotIn("decoder_attention_mask", batch)
+        for tokenizer in tokenizers:
+            batch = tokenizer.prepare_seq2seq_batch(src_text, return_tensors="pt")
+            # check if input_ids are returned and no decoder_input_ids
+            self.assertIn("input_ids", batch)
+            self.assertIn("attention_mask", batch)
+            self.assertNotIn("decoder_input_ids", batch)
+            self.assertNotIn("decoder_attention_mask", batch)
 
     def test_max_target_length(self):
-        tokenizer = self.default_tokenizer
+        tokenizers = [self.default_tokenizer, self.default_tokenizer_fast]
         src_text = ["A long paragraph for summrization.", "Another paragraph for summrization."]
         tgt_text = [
             "Summary of the text.",
             "Another summary.",
         ]
-        batch = tokenizer.prepare_seq2seq_batch(
-            src_text, tgt_texts=tgt_text, max_target_length=32, padding="max_length", return_tensors="pt"
-        )
-        self.assertEqual(32, batch["decoder_input_ids"].shape[1])
-        self.assertEqual(32, batch["decoder_attention_mask"].shape[1])
+        for tokenizer in tokenizers:
+            batch = tokenizer.prepare_seq2seq_batch(
+                src_text, tgt_texts=tgt_text, max_target_length=32, padding="max_length", return_tensors="pt"
+            )
+            self.assertEqual(32, batch["decoder_input_ids"].shape[1])
+            self.assertEqual(32, batch["decoder_attention_mask"].shape[1])
 
-        # test None max_target_length
-        batch = tokenizer.prepare_seq2seq_batch(
-            src_text, tgt_texts=tgt_text, max_length=32, padding="max_length", return_tensors="pt"
-        )
-        self.assertEqual(32, batch["decoder_input_ids"].shape[1])
-        self.assertEqual(32, batch["decoder_attention_mask"].shape[1])
+            # test None max_target_length
+            batch = tokenizer.prepare_seq2seq_batch(
+                src_text, tgt_texts=tgt_text, max_length=32, padding="max_length", return_tensors="pt"
+            )
+            self.assertEqual(32, batch["decoder_input_ids"].shape[1])
+            self.assertEqual(32, batch["decoder_attention_mask"].shape[1])
 
     def test_outputs_not_longer_than_maxlen(self):
-        tokenizer = self.default_tokenizer
+        tokenizers = [self.default_tokenizer, self.default_tokenizer_fast]
 
-        batch = tokenizer.prepare_seq2seq_batch(["I am a small frog" * 1024, "I am a small frog"], return_tensors="pt")
-        self.assertIsInstance(batch, BatchEncoding)
-        self.assertEqual(batch.input_ids.shape, (2, 1024))
+        for tokenizer in tokenizers:
+            batch = tokenizer.prepare_seq2seq_batch(
+                ["I am a small frog" * 1024, "I am a small frog"], return_tensors="pt"
+            )
+            self.assertIsInstance(batch, BatchEncoding)
+            self.assertEqual(batch.input_ids.shape, (2, 1024))
 
     def test_special_tokens(self):
-        tokenizer = self.default_tokenizer
+        tokenizers = [self.default_tokenizer, self.default_tokenizer_fast]
         src_text = ["A long paragraph for summrization."]
         tgt_text = [
             "Summary of the text.",
         ]
-        batch = tokenizer.prepare_seq2seq_batch(src_text, tgt_texts=tgt_text, return_tensors="pt")
-        input_ids = batch["input_ids"]
-        decoder_input_ids = batch["decoder_input_ids"]
-        self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item())
-        self.assertTrue((decoder_input_ids[:, 0] == tokenizer.bos_token_id).all().item())
-        self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item())
-        self.assertTrue((decoder_input_ids[:, -1] == tokenizer.eos_token_id).all().item())
+        for tokenizer in tokenizers:
+            batch = tokenizer.prepare_seq2seq_batch(src_text, tgt_texts=tgt_text, return_tensors="pt")
+            input_ids = batch["input_ids"]
+            decoder_input_ids = batch["decoder_input_ids"]
+            self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item())
+            self.assertTrue((decoder_input_ids[:, 0] == tokenizer.bos_token_id).all().item())
+            self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item())
+            self.assertTrue((decoder_input_ids[:, -1] == tokenizer.eos_token_id).all().item())
 
 
 @require_torch