first commit

README.md

@@ -0,0 +1,103 @@
+---
+language: ja
+license: cc-by-sa-4.0
+library_name: transformers
+tags:
+  - deberta
+  - deberta-v2
+  - fill-mask
+datasets:
+  - wikipedia
+  - cc100
+  - oscar
+metrics:
+  - accuracy
+mask_token: "[MASK]"
+widget:
+    - text: "京都大学で自然言語処理を[MASK]する。"
+---
+
+# Model Card for Japanese DeBERTa V2 base
+
+## Model description
+
+This is a Japanese DeBERTa V2 base model pre-trained on Japanese Wikipedia, the Japanese portion of CC-100, and the Japanese portion of OSCAR.
+
+## How to use
+
+You can use this model for masked language modeling as follows:
+
+```python
+from transformers import AutoTokenizer, AutoModelForMaskedLM
+tokenizer = AutoTokenizer.from_pretrained('ku-nlp/deberta-v2-base-japanese', trust_remote_code=True)
+model = AutoModelForMaskedLM.from_pretrained('ku-nlp/deberta-v2-base-japanese')
+
+sentence = '京都大学で自然言語処理を[MASK]する。'
+encoding = tokenizer(sentence, return_tensors='pt')
+...
+```
+
+You can also fine-tune this model on downstream tasks.
+
+## Tokenization
+
+~~The input text should be segmented into words by [Juman++](https://github.com/ku-nlp/jumanpp) in advance. [Juman++ 2.0.0-rc3](https://github.com/ku-nlp/jumanpp/releases/tag/v2.0.0-rc3) was used for pre-training. Each word is tokenized into subwords by [sentencepiece](https://github.com/google/sentencepiece).~~
+
+UPDATE: The input text is internally segmented by [Juman++](https://github.com/ku-nlp/jumanpp) within `DebertaV2JumanppTokenizer(Fast)`, so there's no need to segment it in advance. To use `DebertaV2JumanppTokenizer(Fast)`, you need to install [Juman++ 2.0.0-rc3](https://github.com/ku-nlp/jumanpp/releases/tag/v2.0.0-rc3) and [rhoknp](https://github.com/ku-nlp/rhoknp).
+
+## Training data
+
+We used the following corpora for pre-training:
+
+- Japanese Wikipedia (as of 20221020, 3.2GB, 27M sentences, 1.3M documents)
+- Japanese portion of CC-100 (85GB, 619M sentences, 66M documents)
+- Japanese portion of OSCAR (54GB, 326M sentences, 25M documents)
+
+Note that we filtered out documents annotated with "header", "footer", or "noisy" tags in OSCAR.
+Also note that Japanese Wikipedia was duplicated 10 times to make the total size of the corpus comparable to that of CC-100 and OSCAR. As a result, the total size of the training data is 171GB.
+
+## Training procedure
+
+We first segmented texts in the corpora into words using [Juman++](https://github.com/ku-nlp/jumanpp).
+Then, we built a sentencepiece model with 32000 tokens including words ([JumanDIC](https://github.com/ku-nlp/JumanDIC)) and subwords induced by the unigram language model of [sentencepiece](https://github.com/google/sentencepiece).
+
+We tokenized the segmented corpora into subwords using the sentencepiece model and trained the Japanese DeBERTa model using [transformers](https://github.com/huggingface/transformers) library.
+The training took three weeks using 8 NVIDIA A100-SXM4-40GB GPUs.
+
+The following hyperparameters were used during pre-training:
+
+- learning_rate: 2e-4
+- per_device_train_batch_size: 44
+- distributed_type: multi-GPU
+- num_devices: 8
+- gradient_accumulation_steps: 6
+- total_train_batch_size: 2,112
+- max_seq_length: 512
+- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-06
+- lr_scheduler_type: linear schedule with warmup
+- training_steps: 500,000
+- warmup_steps: 10,000
+
+The accuracy of the trained model on the masked language modeling task was 0.779.
+The evaluation set consists of 5,000 randomly sampled documents from each of the training corpora.
+
+## Fine-tuning on NLU tasks
+
+We fine-tuned the following models and evaluated them on the dev set of JGLUE.
+We tuned learning rate and training epochs for each model and task following [the JGLUE paper](https://www.jstage.jst.go.jp/article/jnlp/30/1/30_63/_pdf/-char/ja).
+
+| Model                         | MARC-ja/acc | JSTS/pearson | JSTS/spearman | JNLI/acc | JSQuAD/EM | JSQuAD/F1 | JComQA/acc |
+|-------------------------------|-------------|--------------|---------------|----------|-----------|-----------|------------|
+| Waseda RoBERTa base           | 0.965       | 0.913        | 0.876         | 0.905    | 0.853     | 0.916     | 0.853      |
+| Waseda RoBERTa large (seq512) | 0.969       | 0.925        | 0.890         | 0.928    | 0.910     | 0.955     | 0.900      |
+| LUKE Japanese base*           | 0.965       | 0.916        | 0.877         | 0.912    | -         | -         | 0.842      |
+| LUKE Japanese large*          | 0.965       | 0.932        | 0.902         | 0.927    | -         | -         | 0.893      |
+| DeBERTaV2 base                | 0.970       | 0.922        | 0.886         | 0.922    | 0.899     | 0.951     | 0.873      |
+| DeBERTaV2 large               | 0.968       | 0.925        | 0.892         | 0.924    | 0.912     | 0.959     | 0.890      |
+
+*The scores of LUKE are from [the official repository](https://github.com/studio-ousia/luke).
+
+## Acknowledgments
+
+This work was supported by Joint Usage/Research Center for Interdisciplinary Large-scale Information Infrastructures (JHPCN) through General Collaboration Project no. jh221004, "Developing a Platform for Constructing and Sharing of Large-Scale Japanese Language Models".
+For training models, we used the mdx: a platform for the data-driven future.

config.json

@@ -0,0 +1,37 @@
+{
+  "architectures": [
+    "DebertaV2ForMaskedLM"
+  ],
+  "attention_head_size": 64,
+  "attention_probs_dropout_prob": 0.1,
+  "conv_act": "gelu",
+  "conv_kernel_size": 3,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-07,
+  "max_position_embeddings": 512,
+  "max_relative_positions": -1,
+  "model_type": "deberta-v2",
+  "norm_rel_ebd": "layer_norm",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "pooler_dropout": 0,
+  "pooler_hidden_act": "gelu",
+  "pooler_hidden_size": 768,
+  "pos_att_type": [
+    "p2c",
+    "c2p"
+  ],
+  "position_biased_input": false,
+  "position_buckets": 256,
+  "relative_attention": true,
+  "share_att_key": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.23.1",
+  "type_vocab_size": 0,
+  "vocab_size": 32000
+}

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57fb86bf188376f5d1230e5835270f9e7bb00e5db5aaedfb9445df7b571ba9c3
+size 548197213

special_tokens_map.json

@@ -0,0 +1,9 @@
+{
+  "bos_token": "[CLS]",
+  "cls_token": "[CLS]",
+  "eos_token": "[SEP]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

spm.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c111c16e2e52366dcac46b886e40650bb843fe2938a65f5970271fc5697a127
+size 805061

tokenization_deberta_v2_jumanpp.py

@@ -0,0 +1,30 @@
+from transformers import DebertaV2Tokenizer
+
+
+class DebertaV2JumanppTokenizer(DebertaV2Tokenizer):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.juman_tokenizer = JumanppTokenizer()
+
+    def prepare_for_tokenization(self, text, is_split_into_words=False, **kwargs) -> tuple[str, dict]:
+        text = self.juman_tokenizer.tokenize(text)
+
+        add_prefix_space = kwargs.pop("add_prefix_space", False)
+        if is_split_into_words or add_prefix_space:
+            text = " " + text
+        return (text, kwargs)
+
+
+class JumanppTokenizer:
+    def __init__(self):
+        try:
+            import rhoknp
+        except ImportError:
+            raise ImportError(
+                "You need to install rhoknp to use JumanppPreTokenizer. "
+                "See https://github.com/ku-nlp/rhoknp for installation."
+            )
+        self.juman = rhoknp.Jumanpp()
+
+    def tokenize(self, text: str) -> str:
+        return " ".join([morpheme.surf for morpheme in self.juman.apply_to_sentence(text).morphemes])

tokenization_deberta_v2_jumanpp_fast.py

@@ -0,0 +1,64 @@
+import copy
+
+from tokenizers import NormalizedString, PreTokenizedString, normalizers, pre_tokenizers
+from transformers import DebertaV2TokenizerFast
+
+
+class DebertaV2JumanppTokenizerFast(DebertaV2TokenizerFast):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.juman_normalizer = normalizers.Sequence(
+            [
+                # cf. https://github.com/ku-nlp/rhoknp/blob/v1.3.0/src/rhoknp/units/sentence.py#L36
+                normalizers.Replace("\r", ""),
+                normalizers.Replace("\n", ""),
+                # cf. https://github.com/ku-nlp/jumanpp/blob/v2.0.0-rc3/src/jumandic/shared/juman_format.cc#L44-L61
+                normalizers.Replace("\t", "\\t"),
+                normalizers.Replace(" ", "　"),
+                normalizers.Replace('"', "”"),
+                normalizers.Replace("<", "＜"),
+                normalizers.Replace(">", "＞"),
+            ]
+        )
+        self.juman_pre_tokenizer = pre_tokenizers.PreTokenizer.custom(JumanppPreTokenizer())
+
+        self.default_normalizer = copy.deepcopy(self.backend_tokenizer.normalizer)
+        self.default_pre_tokenizer = copy.deepcopy(self.backend_tokenizer.pre_tokenizer)
+
+        self.backend_tokenizer.normalizer = normalizers.Sequence(
+            [self.juman_normalizer, self.backend_tokenizer.normalizer]
+        )
+        self.backend_tokenizer.pre_tokenizer = pre_tokenizers.Sequence(
+            [self.juman_pre_tokenizer, self.backend_tokenizer.pre_tokenizer]
+        )
+
+    def save_pretrained(self, *args, **kwargs):
+        self.backend_tokenizer.normalizer = self.default_normalizer
+        self.backend_tokenizer.pre_tokenizer = self.default_pre_tokenizer
+        super().save_pretrained(*args, **kwargs)
+
+        self.backend_tokenizer.normalizer = normalizers.Sequence(
+            [self.juman_normalizer, self.backend_tokenizer.normalizer]
+        )
+        self.backend_tokenizer.pre_tokenizer = pre_tokenizers.Sequence(
+            [self.juman_pre_tokenizer, self.backend_tokenizer.pre_tokenizer]
+        )
+
+
+class JumanppPreTokenizer:
+    def __init__(self):
+        try:
+            import rhoknp
+        except ImportError:
+            raise ImportError(
+                "You need to install rhoknp to use JumanppPreTokenizer. "
+                "See https://github.com/ku-nlp/rhoknp for installation."
+            )
+        self.juman = rhoknp.Jumanpp()
+
+    def pre_tokenize(self, pretok: PreTokenizedString):
+        pretok.split(self.jumanpp_split)
+
+    def jumanpp_split(self, i: int, normalized_string: NormalizedString) -> list[NormalizedString]:
+        offsets = [morpheme.span for morpheme in self.juman.apply_to_sentence(str(normalized_string)).morphemes]
+        return [normalized_string[offset[0]:offset[1]] for offset in offsets]

tokenizer_config.json

@@ -0,0 +1,21 @@
+{
+  "bos_token": "[CLS]",
+  "cls_token": "[CLS]",
+  "do_lower_case": false,
+  "eos_token": "[SEP]",
+  "keep_accents": true,
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "sp_model_kwargs": {},
+  "special_tokens_map_file": null,
+  "split_by_punct": false,
+  "tokenizer_class": "DebertaV2JumanppTokenizer",
+  "unk_token": "[UNK]",
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_deberta_v2_jumanpp.DebertaV2JumanppTokenizer",
+      "tokenization_deberta_v2_jumanpp_fast.DebertaV2JumanppTokenizerFast"
+    ]
+  }
+}