remove dependencies of bert-base-uncased model in python unitests (#2)

Co-authored-by: jiaruifang <jiaruifang@tencent.com>

turbo_transformers/python/tests/bert_attention_test.py

@@ -29,10 +29,7 @@
 import unittest
 import sys
 import torch
-import torch.jit
-import torch.onnx
 from transformers.modeling_bert import BertConfig, BertAttention
-from transformers import BertTokenizer
 import os
 
 sys.path.append(os.path.dirname(__file__))
@@ -50,12 +47,8 @@ def init_data(self, use_cuda):
                 torch.set_num_threads(1)
 
             torch.set_grad_enabled(False)
-            tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
-            # Get Torch attention
-            cfg = BertConfig(
-                vocab_size_or_config_json_file=tokenizer.vocab_size,
-                attention_probs_dropout_prob=0.0,
-                hidden_dropout_prob=0.0)
+            cfg = BertConfig(attention_probs_dropout_prob=0.0,
+                             hidden_dropout_prob=0.0)
             torch_attention = BertAttention(cfg)
             torch_attention.eval()
             if use_cuda:

turbo_transformers/python/tests/bert_embedding_test.py

@@ -28,8 +28,6 @@
 import unittest
 import sys
 import torch
-import torch.jit
-from transformers import BertTokenizer
 from transformers.modeling_bert import BertEmbeddings, BertConfig
 import os
 
@@ -44,9 +42,7 @@ def init_data(self, use_cuda: bool):
                 torch.device('cpu:0')
 
             torch.set_grad_enabled(False)
-            self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
-            cfg = BertConfig(
-                vocab_size_or_config_json_file=self.tokenizer.vocab_size)
+            cfg = BertConfig()
             self.torch_embedding = BertEmbeddings(cfg)
 
             self.torch_embedding.eval()
@@ -58,7 +54,7 @@ def init_data(self, use_cuda: bool):
                 self.torch_embedding)
 
             input_ids = torch.randint(low=0,
-                                      high=self.tokenizer.vocab_size - 1,
+                                      high=cfg.vocab_size - 1,
                                       size=(batch_size, seq_length),
                                       dtype=torch.long,
                                       device=test_device)

turbo_transformers/python/tests/bert_encoder_test.py

@@ -29,8 +29,6 @@
 import unittest
 import sys
 import torch
-import torch.jit
-from transformers import BertTokenizer
 from transformers.modeling_bert import BertConfig, BertEncoder
 import os
 
@@ -46,9 +44,7 @@ def init_data(self, use_cuda) -> None:
             torch.set_num_threads(1)
 
         torch.set_grad_enabled(False)
-        self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
-        self.cfg = BertConfig(
-            vocab_size_or_config_json_file=self.tokenizer.vocab_size)
+        self.cfg = BertConfig()
 
         self.torch_encoder_layer = BertEncoder(self.cfg)
         self.torch_encoder_layer.eval()

turbo_transformers/python/tests/bert_intermediate_test.py

@@ -29,7 +29,6 @@
 import sys
 import torch
 import turbo_transformers
-from transformers import BertTokenizer
 from transformers.modeling_bert import BertConfig, BertIntermediate
 import numpy
 import os
@@ -47,9 +46,7 @@ def init_data(self, use_cuda: bool) -> None:
                 torch.set_num_threads(1)
 
             torch.set_grad_enabled(False)
-            self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
-            self.cfg = BertConfig(
-                vocab_size_or_config_json_file=self.tokenizer.vocab_size)
+            self.cfg = BertConfig()
 
             self.torch_intermediate = BertIntermediate(self.cfg)
             if torch.cuda.is_available():

turbo_transformers/python/tests/bert_layer_test.py

@@ -29,9 +29,6 @@
 import unittest
 
 import torch
-import torch.jit
-import torch.onnx
-from transformers import BertTokenizer
 from transformers.modeling_bert import BertConfig, BertLayer
 import sys
 import os
@@ -51,11 +48,8 @@ def init_data(self, use_cuda: bool) -> None:
                 torch.set_num_threads(1)
 
             torch.set_grad_enabled(False)
-            self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
-            self.cfg = BertConfig(
-                vocab_size_or_config_json_file=self.tokenizer.vocab_size,
-                attention_probs_dropout_prob=0.0,
-                hidden_dropout_prob=0.0)
+            self.cfg = BertConfig(attention_probs_dropout_prob=0.0,
+                                  hidden_dropout_prob=0.0)
 
             self.torch_bert_layer = BertLayer(self.cfg)
             self.torch_bert_layer.eval()

turbo_transformers/python/tests/bert_model_test.py

@@ -26,8 +26,7 @@
 
 import unittest
 import torch
-from transformers import BertTokenizer
-from transformers.modeling_bert import BertModel
+from transformers.modeling_bert import BertModel, BertConfig
 import numpy
 import turbo_transformers
 import sys
@@ -39,45 +38,45 @@
 
 class TestBertModel(unittest.TestCase):
     def init_data(self, use_cuda) -> None:
-        model_id = "bert-base-uncased"
         torch.set_grad_enabled(False)
         torch.set_num_threads(1)
         self.test_device = torch.device('cuda:0') if use_cuda else \
             torch.device('cpu:0')
 
-        self.tokenizer = BertTokenizer.from_pretrained(model_id)
-        self.torch_model = BertModel.from_pretrained(model_id)
+        self.cfg = BertConfig()
+        self.torch_model = BertModel(self.cfg)
         self.torch_model.eval()
 
         if torch.cuda.is_available():
             self.torch_model.to(self.test_device)
 
-        self.turbo_model = turbo_transformers.BertModel.from_pretrained(
-            model_id, self.test_device)
+        self.turbo_model = turbo_transformers.BertModel.from_torch(
+            self.torch_model, self.test_device)
 
-        self.turbo_pooler_model = turbo_transformers.BertModelWithPooler.from_pretrained(
-            model_id, self.test_device)
+        self.turbo_pooler_model = turbo_transformers.BertModelWithPooler.from_torch(
+            self.torch_model, self.test_device)
 
     def check_torch_and_turbo(self, use_cuda, use_pooler):
         self.init_data(use_cuda)
         num_iter = 2
-        device = "GPU" if use_cuda else "CPU"
-        input_ids = self.tokenizer.encode('测试一下bert模型的性能和精度是不是符合要求?')
-        input_ids = torch.tensor([input_ids],
-                                 dtype=torch.long,
-                                 device=self.test_device)
+        device_name = "GPU" if use_cuda else "CPU"
+        input_ids = torch.randint(low=0,
+                                  high=self.cfg.vocab_size - 1,
+                                  size=(2, 32),
+                                  dtype=torch.long,
+                                  device=self.test_device)
 
         torch_model = lambda: self.torch_model(input_ids)
         torch_result, torch_qps, torch_time = \
             test_helper.run_model(torch_model, use_cuda, num_iter)
-        print(f'BertModel Plain PyTorch({device}) QPS {torch_qps}')
+        print(f'BertModel Plain PyTorch({device_name}) QPS {torch_qps}')
 
         turbo_model = (
             lambda: self.turbo_pooler_model(input_ids)) if use_pooler else (
                 lambda: self.turbo_model(input_ids))
         turbo_result, turbo_qps, turbo_time = \
             test_helper.run_model(turbo_model, use_cuda, num_iter)
-        print(f'BertModel TurboTransformer({device}) QPS {turbo_qps}')
+        print(f'BertModel TurboTransformer({device_name}) QPS {turbo_qps}')
 
         torch_result_final = (torch_result[1]).cpu().numpy(
         ) if use_pooler else torch_result[0][:, 0].cpu().numpy()

turbo_transformers/python/tests/bert_output_test.py

@@ -29,8 +29,6 @@
 import unittest
 import io
 import torch
-import torch.jit
-from transformers import BertTokenizer
 from transformers.modeling_bert import BertConfig, BertOutput
 import sys
 import os
@@ -48,9 +46,7 @@ def init_data(self, use_cuda) -> None:
                 torch.set_num_threads(1)
 
             torch.set_grad_enabled(False)
-            self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
-            self.cfg = BertConfig(
-                vocab_size_or_config_json_file=self.tokenizer.vocab_size)
+            self.cfg = BertConfig()
             self.intermediate_size = self.cfg.intermediate_size  # 3072;
             self.hidden_size = self.cfg.hidden_size  # 768
             self.torch_bertout = BertOutput(self.cfg)

turbo_transformers/python/tests/bert_pooler_test.py

@@ -48,8 +48,7 @@ def init_data(self, use_cuda: bool) -> None:
 
             torch.set_grad_enabled(False)
             self.tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
-            self.cfg = BertConfig(
-                vocab_size_or_config_json_file=self.tokenizer.vocab_size)
+            self.cfg = BertConfig()
 
             self.torch_pooler = BertPooler(self.cfg)
             if torch.cuda.is_available():