initial release

README.md

@@ -0,0 +1,32 @@
+---
+language:
+- "ja"
+tags:
+- "japanese"
+- "pos"
+- "dependency-parsing"
+- "modernbert"
+base_model: makiart/jp-ModernBert-large-preview
+datasets:
+- "universal_dependencies"
+license: "mit"
+pipeline_tag: "token-classification"
+widget:
+- text: "全学年にわたって小学校の国語の教科書に挿し絵が用いられている"
+---
+
+# modernbert-large-japanese-unidic-ud-embeds
+
+## Model Description
+
+This is a ModernBERT model pretrained for POS-tagging and dependency-parsing, derived from [jp-ModernBert-large-preview](https://huggingface.co/makiart/jp-ModernBert-large-preview) and [UD_Japanese-GSDLUW](https://github.com/UniversalDependencies/UD_Japanese-GSDLUW).
+
+## How to Use
+
+```py
+from transformers import pipeline
+nlp=pipeline("universal-dependencies","KoichiYasuoka/modernbert-large-japanese-unidic-ud-embeds",trust_remote_code=True)
+print(nlp("全学年にわたって小学校の国語の教科書に挿し絵が用いられている"))
+```
+
+[fugashi](https://pypi.org/project/fugashi) and [unidic-lite](https://pypi.org/project/unidic-lite) are required.

config.json

@@ -0,0 +1,519 @@
+{
+  "architectures": [
+    "ModernBertForTokenClassification"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 2,
+  "classifier_activation": "gelu",
+  "classifier_bias": false,
+  "classifier_dropout": 0.0,
+  "classifier_pooling": "mean",
+  "cls_token_id": 2,
+  "custom_pipelines": {
+    "upos": {
+      "impl": "ud.BellmanFordTokenClassificationPipeline",
+      "pt": "AutoModelForTokenClassification"
+    },
+    "universal-dependencies": {
+      "impl": "ud.UniversalDependenciesPipeline",
+      "pt": "AutoModelForTokenClassification"
+    }
+  },
+  "decoder_bias": true,
+  "deterministic_flash_attn": false,
+  "embedding_dropout": 0.0,
+  "eos_token_id": 3,
+  "global_attn_every_n_layers": 3,
+  "global_rope_theta": 160000.0,
+  "gradient_checkpointing": false,
+  "hidden_activation": "gelu",
+  "hidden_size": 1024,
+  "id2label": {
+    "0": "ADJ",
+    "1": "ADJ.",
+    "2": "ADJ|_",
+    "3": "ADJ|l-acl",
+    "4": "ADJ|l-advcl",
+    "5": "ADJ|l-amod",
+    "6": "ADJ|l-ccomp",
+    "7": "ADJ|l-csubj",
+    "8": "ADJ|l-csubj:outer",
+    "9": "ADJ|l-nmod",
+    "10": "ADJ|l-nsubj",
+    "11": "ADJ|l-obj",
+    "12": "ADJ|l-obl",
+    "13": "ADJ|r-acl",
+    "14": "ADJ|r-amod",
+    "15": "ADJ|r-dep",
+    "16": "ADJ|root",
+    "17": "ADP",
+    "18": "ADP.",
+    "19": "ADP|_",
+    "20": "ADP|l-case",
+    "21": "ADP|r-case",
+    "22": "ADP|r-fixed",
+    "23": "ADV",
+    "24": "ADV.",
+    "25": "ADV|_",
+    "26": "ADV|l-advcl",
+    "27": "ADV|l-advmod",
+    "28": "ADV|l-obj",
+    "29": "ADV|r-dep",
+    "30": "ADV|root",
+    "31": "AUX",
+    "32": "AUX.",
+    "33": "AUX|Polarity=Neg|_",
+    "34": "AUX|Polarity=Neg|r-aux",
+    "35": "AUX|Polarity=Neg|r-fixed",
+    "36": "AUX|_",
+    "37": "AUX|r-aux",
+    "38": "AUX|r-cop",
+    "39": "AUX|r-fixed",
+    "40": "AUX|root",
+    "41": "B-ADJ",
+    "42": "B-ADJ.",
+    "43": "B-ADP",
+    "44": "B-ADP.",
+    "45": "B-ADV",
+    "46": "B-ADV.",
+    "47": "B-AUX",
+    "48": "B-AUX.",
+    "49": "B-CCONJ",
+    "50": "B-CCONJ.",
+    "51": "B-DET",
+    "52": "B-DET.",
+    "53": "B-INTJ",
+    "54": "B-INTJ.",
+    "55": "B-NOUN",
+    "56": "B-NOUN.",
+    "57": "B-NUM",
+    "58": "B-NUM.",
+    "59": "B-PART",
+    "60": "B-PART.",
+    "61": "B-PRON",
+    "62": "B-PRON.",
+    "63": "B-PROPN",
+    "64": "B-PROPN.",
+    "65": "B-PUNCT",
+    "66": "B-PUNCT.",
+    "67": "B-SCONJ",
+    "68": "B-SCONJ.",
+    "69": "B-SYM",
+    "70": "B-SYM.",
+    "71": "B-VERB",
+    "72": "B-VERB.",
+    "73": "B-X",
+    "74": "B-X.",
+    "75": "CCONJ",
+    "76": "CCONJ.",
+    "77": "CCONJ|_",
+    "78": "CCONJ|l-cc",
+    "79": "CCONJ|r-cc",
+    "80": "DET",
+    "81": "DET.",
+    "82": "DET|_",
+    "83": "DET|l-det",
+    "84": "I-ADJ",
+    "85": "I-ADJ.",
+    "86": "I-ADP",
+    "87": "I-ADP.",
+    "88": "I-ADV",
+    "89": "I-ADV.",
+    "90": "I-AUX",
+    "91": "I-AUX.",
+    "92": "I-CCONJ",
+    "93": "I-CCONJ.",
+    "94": "I-DET",
+    "95": "I-DET.",
+    "96": "I-INTJ",
+    "97": "I-INTJ.",
+    "98": "I-NOUN",
+    "99": "I-NOUN.",
+    "100": "I-NUM",
+    "101": "I-NUM.",
+    "102": "I-PART",
+    "103": "I-PART.",
+    "104": "I-PRON",
+    "105": "I-PRON.",
+    "106": "I-PROPN",
+    "107": "I-PROPN.",
+    "108": "I-PUNCT",
+    "109": "I-PUNCT.",
+    "110": "I-SCONJ",
+    "111": "I-SCONJ.",
+    "112": "I-SYM",
+    "113": "I-SYM.",
+    "114": "I-VERB",
+    "115": "I-VERB.",
+    "116": "I-X",
+    "117": "I-X.",
+    "118": "INTJ",
+    "119": "INTJ.",
+    "120": "INTJ|_",
+    "121": "INTJ|l-discourse",
+    "122": "INTJ|r-discourse",
+    "123": "INTJ|root",
+    "124": "NOUN",
+    "125": "NOUN.",
+    "126": "NOUN|Polarity=Neg|_",
+    "127": "NOUN|Polarity=Neg|l-obl",
+    "128": "NOUN|Polarity=Neg|root",
+    "129": "NOUN|_",
+    "130": "NOUN|l-acl",
+    "131": "NOUN|l-advcl",
+    "132": "NOUN|l-ccomp",
+    "133": "NOUN|l-compound",
+    "134": "NOUN|l-csubj",
+    "135": "NOUN|l-csubj:outer",
+    "136": "NOUN|l-nmod",
+    "137": "NOUN|l-nsubj",
+    "138": "NOUN|l-nsubj:outer",
+    "139": "NOUN|l-obj",
+    "140": "NOUN|l-obl",
+    "141": "NOUN|r-compound",
+    "142": "NOUN|r-nmod",
+    "143": "NOUN|r-nsubj",
+    "144": "NOUN|root",
+    "145": "NUM",
+    "146": "NUM.",
+    "147": "NUM|_",
+    "148": "NUM|l-advcl",
+    "149": "NUM|l-compound",
+    "150": "NUM|l-nmod",
+    "151": "NUM|l-nsubj",
+    "152": "NUM|l-nsubj:outer",
+    "153": "NUM|l-nummod",
+    "154": "NUM|l-obj",
+    "155": "NUM|l-obl",
+    "156": "NUM|r-compound",
+    "157": "NUM|root",
+    "158": "PART",
+    "159": "PART.",
+    "160": "PART|_",
+    "161": "PART|l-mark",
+    "162": "PART|r-mark",
+    "163": "PRON",
+    "164": "PRON.",
+    "165": "PRON|_",
+    "166": "PRON|l-acl",
+    "167": "PRON|l-advcl",
+    "168": "PRON|l-nmod",
+    "169": "PRON|l-nsubj",
+    "170": "PRON|l-nsubj:outer",
+    "171": "PRON|l-obj",
+    "172": "PRON|l-obl",
+    "173": "PRON|root",
+    "174": "PROPN",
+    "175": "PROPN.",
+    "176": "PROPN|_",
+    "177": "PROPN|l-acl",
+    "178": "PROPN|l-advcl",
+    "179": "PROPN|l-compound",
+    "180": "PROPN|l-nmod",
+    "181": "PROPN|l-nsubj",
+    "182": "PROPN|l-nsubj:outer",
+    "183": "PROPN|l-obj",
+    "184": "PROPN|l-obl",
+    "185": "PROPN|r-compound",
+    "186": "PROPN|r-nmod",
+    "187": "PROPN|root",
+    "188": "PUNCT",
+    "189": "PUNCT.",
+    "190": "PUNCT|_",
+    "191": "PUNCT|l-punct",
+    "192": "PUNCT|r-punct",
+    "193": "SCONJ",
+    "194": "SCONJ.",
+    "195": "SCONJ|_",
+    "196": "SCONJ|l-dep",
+    "197": "SCONJ|r-fixed",
+    "198": "SCONJ|r-mark",
+    "199": "SYM",
+    "200": "SYM.",
+    "201": "SYM|_",
+    "202": "SYM|l-compound",
+    "203": "SYM|l-dep",
+    "204": "SYM|l-nmod",
+    "205": "SYM|l-obl",
+    "206": "SYM|r-compound",
+    "207": "SYM|r-dep",
+    "208": "VERB",
+    "209": "VERB.",
+    "210": "VERB|_",
+    "211": "VERB|l-acl",
+    "212": "VERB|l-advcl",
+    "213": "VERB|l-ccomp",
+    "214": "VERB|l-compound",
+    "215": "VERB|l-csubj",
+    "216": "VERB|l-csubj:outer",
+    "217": "VERB|l-nmod",
+    "218": "VERB|l-obj",
+    "219": "VERB|l-obl",
+    "220": "VERB|r-acl",
+    "221": "VERB|r-advcl",
+    "222": "VERB|r-compound",
+    "223": "VERB|root",
+    "224": "X",
+    "225": "X.",
+    "226": "X|_",
+    "227": "X|l-nmod",
+    "228": "X|r-dep"
+  },
+  "initializer_cutoff_factor": 2.0,
+  "initializer_range": 0.02,
+  "intermediate_size": 2624,
+  "label2id": {
+    "ADJ": 0,
+    "ADJ.": 1,
+    "ADJ|_": 2,
+    "ADJ|l-acl": 3,
+    "ADJ|l-advcl": 4,
+    "ADJ|l-amod": 5,
+    "ADJ|l-ccomp": 6,
+    "ADJ|l-csubj": 7,
+    "ADJ|l-csubj:outer": 8,
+    "ADJ|l-nmod": 9,
+    "ADJ|l-nsubj": 10,
+    "ADJ|l-obj": 11,
+    "ADJ|l-obl": 12,
+    "ADJ|r-acl": 13,
+    "ADJ|r-amod": 14,
+    "ADJ|r-dep": 15,
+    "ADJ|root": 16,
+    "ADP": 17,
+    "ADP.": 18,
+    "ADP|_": 19,
+    "ADP|l-case": 20,
+    "ADP|r-case": 21,
+    "ADP|r-fixed": 22,
+    "ADV": 23,
+    "ADV.": 24,
+    "ADV|_": 25,
+    "ADV|l-advcl": 26,
+    "ADV|l-advmod": 27,
+    "ADV|l-obj": 28,
+    "ADV|r-dep": 29,
+    "ADV|root": 30,
+    "AUX": 31,
+    "AUX.": 32,
+    "AUX|Polarity=Neg|_": 33,
+    "AUX|Polarity=Neg|r-aux": 34,
+    "AUX|Polarity=Neg|r-fixed": 35,
+    "AUX|_": 36,
+    "AUX|r-aux": 37,
+    "AUX|r-cop": 38,
+    "AUX|r-fixed": 39,
+    "AUX|root": 40,
+    "B-ADJ": 41,
+    "B-ADJ.": 42,
+    "B-ADP": 43,
+    "B-ADP.": 44,
+    "B-ADV": 45,
+    "B-ADV.": 46,
+    "B-AUX": 47,
+    "B-AUX.": 48,
+    "B-CCONJ": 49,
+    "B-CCONJ.": 50,
+    "B-DET": 51,
+    "B-DET.": 52,
+    "B-INTJ": 53,
+    "B-INTJ.": 54,
+    "B-NOUN": 55,
+    "B-NOUN.": 56,
+    "B-NUM": 57,
+    "B-NUM.": 58,
+    "B-PART": 59,
+    "B-PART.": 60,
+    "B-PRON": 61,
+    "B-PRON.": 62,
+    "B-PROPN": 63,
+    "B-PROPN.": 64,
+    "B-PUNCT": 65,
+    "B-PUNCT.": 66,
+    "B-SCONJ": 67,
+    "B-SCONJ.": 68,
+    "B-SYM": 69,
+    "B-SYM.": 70,
+    "B-VERB": 71,
+    "B-VERB.": 72,
+    "B-X": 73,
+    "B-X.": 74,
+    "CCONJ": 75,
+    "CCONJ.": 76,
+    "CCONJ|_": 77,
+    "CCONJ|l-cc": 78,
+    "CCONJ|r-cc": 79,
+    "DET": 80,
+    "DET.": 81,
+    "DET|_": 82,
+    "DET|l-det": 83,
+    "I-ADJ": 84,
+    "I-ADJ.": 85,
+    "I-ADP": 86,
+    "I-ADP.": 87,
+    "I-ADV": 88,
+    "I-ADV.": 89,
+    "I-AUX": 90,
+    "I-AUX.": 91,
+    "I-CCONJ": 92,
+    "I-CCONJ.": 93,
+    "I-DET": 94,
+    "I-DET.": 95,
+    "I-INTJ": 96,
+    "I-INTJ.": 97,
+    "I-NOUN": 98,
+    "I-NOUN.": 99,
+    "I-NUM": 100,
+    "I-NUM.": 101,
+    "I-PART": 102,
+    "I-PART.": 103,
+    "I-PRON": 104,
+    "I-PRON.": 105,
+    "I-PROPN": 106,
+    "I-PROPN.": 107,
+    "I-PUNCT": 108,
+    "I-PUNCT.": 109,
+    "I-SCONJ": 110,
+    "I-SCONJ.": 111,
+    "I-SYM": 112,
+    "I-SYM.": 113,
+    "I-VERB": 114,
+    "I-VERB.": 115,
+    "I-X": 116,
+    "I-X.": 117,
+    "INTJ": 118,
+    "INTJ.": 119,
+    "INTJ|_": 120,
+    "INTJ|l-discourse": 121,
+    "INTJ|r-discourse": 122,
+    "INTJ|root": 123,
+    "NOUN": 124,
+    "NOUN.": 125,
+    "NOUN|Polarity=Neg|_": 126,
+    "NOUN|Polarity=Neg|l-obl": 127,
+    "NOUN|Polarity=Neg|root": 128,
+    "NOUN|_": 129,
+    "NOUN|l-acl": 130,
+    "NOUN|l-advcl": 131,
+    "NOUN|l-ccomp": 132,
+    "NOUN|l-compound": 133,
+    "NOUN|l-csubj": 134,
+    "NOUN|l-csubj:outer": 135,
+    "NOUN|l-nmod": 136,
+    "NOUN|l-nsubj": 137,
+    "NOUN|l-nsubj:outer": 138,
+    "NOUN|l-obj": 139,
+    "NOUN|l-obl": 140,
+    "NOUN|r-compound": 141,
+    "NOUN|r-nmod": 142,
+    "NOUN|r-nsubj": 143,
+    "NOUN|root": 144,
+    "NUM": 145,
+    "NUM.": 146,
+    "NUM|_": 147,
+    "NUM|l-advcl": 148,
+    "NUM|l-compound": 149,
+    "NUM|l-nmod": 150,
+    "NUM|l-nsubj": 151,
+    "NUM|l-nsubj:outer": 152,
+    "NUM|l-nummod": 153,
+    "NUM|l-obj": 154,
+    "NUM|l-obl": 155,
+    "NUM|r-compound": 156,
+    "NUM|root": 157,
+    "PART": 158,
+    "PART.": 159,
+    "PART|_": 160,
+    "PART|l-mark": 161,
+    "PART|r-mark": 162,
+    "PRON": 163,
+    "PRON.": 164,
+    "PRON|_": 165,
+    "PRON|l-acl": 166,
+    "PRON|l-advcl": 167,
+    "PRON|l-nmod": 168,
+    "PRON|l-nsubj": 169,
+    "PRON|l-nsubj:outer": 170,
+    "PRON|l-obj": 171,
+    "PRON|l-obl": 172,
+    "PRON|root": 173,
+    "PROPN": 174,
+    "PROPN.": 175,
+    "PROPN|_": 176,
+    "PROPN|l-acl": 177,
+    "PROPN|l-advcl": 178,
+    "PROPN|l-compound": 179,
+    "PROPN|l-nmod": 180,
+    "PROPN|l-nsubj": 181,
+    "PROPN|l-nsubj:outer": 182,
+    "PROPN|l-obj": 183,
+    "PROPN|l-obl": 184,
+    "PROPN|r-compound": 185,
+    "PROPN|r-nmod": 186,
+    "PROPN|root": 187,
+    "PUNCT": 188,
+    "PUNCT.": 189,
+    "PUNCT|_": 190,
+    "PUNCT|l-punct": 191,
+    "PUNCT|r-punct": 192,
+    "SCONJ": 193,
+    "SCONJ.": 194,
+    "SCONJ|_": 195,
+    "SCONJ|l-dep": 196,
+    "SCONJ|r-fixed": 197,
+    "SCONJ|r-mark": 198,
+    "SYM": 199,
+    "SYM.": 200,
+    "SYM|_": 201,
+    "SYM|l-compound": 202,
+    "SYM|l-dep": 203,
+    "SYM|l-nmod": 204,
+    "SYM|l-obl": 205,
+    "SYM|r-compound": 206,
+    "SYM|r-dep": 207,
+    "VERB": 208,
+    "VERB.": 209,
+    "VERB|_": 210,
+    "VERB|l-acl": 211,
+    "VERB|l-advcl": 212,
+    "VERB|l-ccomp": 213,
+    "VERB|l-compound": 214,
+    "VERB|l-csubj": 215,
+    "VERB|l-csubj:outer": 216,
+    "VERB|l-nmod": 217,
+    "VERB|l-obj": 218,
+    "VERB|l-obl": 219,
+    "VERB|r-acl": 220,
+    "VERB|r-advcl": 221,
+    "VERB|r-compound": 222,
+    "VERB|root": 223,
+    "X": 224,
+    "X.": 225,
+    "X|_": 226,
+    "X|l-nmod": 227,
+    "X|r-dep": 228
+  },
+  "layer_norm_eps": 1e-05,
+  "local_attention": 128,
+  "local_rope_theta": 10000.0,
+  "max_position_embeddings": 8192,
+  "mlp_bias": false,
+  "mlp_dropout": 0.0,
+  "model_type": "modernbert",
+  "norm_bias": false,
+  "norm_eps": 1e-05,
+  "num_attention_heads": 16,
+  "num_hidden_layers": 28,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "reference_compile": true,
+  "repad_logits_with_grad": false,
+  "sep_token_id": 3,
+  "sparse_pred_ignore_index": -100,
+  "sparse_prediction": false,
+  "tokenizer_class": "BertJapaneseTokenizer",
+  "torch_dtype": "float32",
+  "transformers_version": "4.48.3",
+  "vocab_size": 50368
+}

maker.py

@@ -0,0 +1,109 @@
+#! /usr/bin/python3
+src="makiart/jp-ModernBert-large-preview"
+tgt="KoichiYasuoka/modernbert-large-japanese-unidic-ud-embeds"
+url="https://github.com/UniversalDependencies/UD_Japanese-GSDLUW"
+import os
+d=os.path.basename(url)
+os.system("test -d "+d+" || git clone --depth=1 "+url)
+os.system("for F in train dev test ; do cp "+d+"/*-$F.conllu $F.conllu ; done")
+class UDEmbedsDataset(object):
+  def __init__(self,conllu,tokenizer,embeddings=None):
+    self.conllu=open(conllu,"r",encoding="utf-8")
+    self.tokenizer=tokenizer
+    self.embeddings=embeddings
+    self.seeks=[0]
+    label=set(["SYM","SYM.","SYM|_"])
+    dep=set()
+    s=self.conllu.readline()
+    while s!="":
+      if s=="\n":
+        self.seeks.append(self.conllu.tell())
+      else:
+        w=s.split("\t")
+        if len(w)==10:
+          if w[0].isdecimal():
+            p=w[3]
+            q="" if w[5]=="_" else "|"+w[5]
+            d=("|" if w[6]=="0" else "|l-" if int(w[0])<int(w[6]) else "|r-")+w[7]
+            for k in [p,p+".","B-"+p,"B-"+p+".","I-"+p,"I-"+p+".",p+q+"|_",p+q+d]:
+              label.add(k)
+      s=self.conllu.readline()
+    self.label2id={l:i for i,l in enumerate(sorted(label))}
+  def __call__(*args):
+    lid={l:i for i,l in enumerate(sorted(set(sum([list(t.label2id) for t in args],[]))))}
+    for t in args:
+      t.label2id=lid
+    return lid
+  def __del__(self):
+    self.conllu.close()
+  __len__=lambda self:(len(self.seeks)-1)*2
+  def __getitem__(self,i):
+    self.conllu.seek(self.seeks[int(i/2)])
+    z,c,t,s=i%2,[],[""],False
+    while t[0]!="\n":
+      t=self.conllu.readline().split("\t") 
+      if len(t)==10 and t[0].isdecimal():
+        if s:
+           t[1]=" "+t[1]
+        c.append(t)
+        s=t[9].find("SpaceAfter=No")<0
+    x=[True if t[6]=="0" or int(t[6])>j or sum([1 if int(c[i][6])==j+1 else 0 for i in range(j+1,len(c))])>0 else False for j,t in enumerate(c)]
+    v=self.tokenizer([t[1] for t in c],add_special_tokens=False)["input_ids"]
+    if z==0:
+      ids,upos=[self.tokenizer.cls_token_id],["SYM."]
+      for i,(j,k) in enumerate(zip(v,c)):
+        if j==[]:
+          j=[self.tokenizer.unk_token_id]
+        p=k[3] if x[i] else k[3]+"."
+        ids+=j
+        upos+=[p] if len(j)==1 else ["B-"+p]+["I-"+p]*(len(j)-1)
+      ids.append(self.tokenizer.sep_token_id)
+      upos.append("SYM.")
+      emb=self.embeddings
+    else:
+      import torch
+      if len(x)<127:
+        x=[True]*len(x)
+      else:
+        w=sum([len(x)-i+1 if b else 0 for i,b in enumerate(x)])+1
+        for i in range(len(x)):
+          if x[i]==False and w+len(x)-i<8192:
+            x[i]=True
+            w+=len(x)-i+1
+      p=[t[3] if t[5]=="_" else t[3]+"|"+t[5] for i,t in enumerate(c)]
+      d=[t[7] if t[6]=="0" else "l-"+t[7] if int(t[0])<int(t[6]) else "r-"+t[7] for t in c]
+      ids,upos=[-1],["SYM|_"]
+      for i in range(len(x)):
+        if x[i]:
+          ids.append(i)
+          upos.append(p[i]+"|"+d[i] if c[i][6]=="0" else p[i]+"|_")
+          for j in range(i+1,len(x)):
+            ids.append(j)
+            upos.append(p[j]+"|"+d[j] if int(c[j][6])==i+1 else p[i]+"|"+d[i] if int(c[i][6])==j+1 else p[j]+"|_")
+          ids.append(-1)
+          upos.append("SYM|_")
+      with torch.no_grad():
+        m=[]
+        for j in v:
+          if j==[]:
+            j=[self.tokenizer.unk_token_id]
+          m.append(self.embeddings[j,:].sum(axis=0))
+        m.append(self.embeddings[self.tokenizer.sep_token_id,:])
+        emb=torch.stack(m)
+    return{"inputs_embeds":emb[ids[:8192],:],"labels":[self.label2id[p] for p in upos[:8192]]}
+from transformers import AutoTokenizer,AutoConfig,AutoModelForTokenClassification,DefaultDataCollator,TrainingArguments,Trainer
+from tokenizers.pre_tokenizers import Sequence,Split
+from tokenizers import Regex
+tkz=AutoTokenizer.from_pretrained(src)
+trainDS=UDEmbedsDataset("train.conllu",tkz)
+devDS=UDEmbedsDataset("dev.conllu",tkz)
+testDS=UDEmbedsDataset("test.conllu",tkz)
+lid=trainDS(devDS,testDS)
+cfg=AutoConfig.from_pretrained(src,num_labels=len(lid),label2id=lid,id2label={i:l for l,i in lid.items()},ignore_mismatched_sizes=True,trust_remote_code=True)
+mdl=AutoModelForTokenClassification.from_pretrained(src,config=cfg,ignore_mismatched_sizes=True,trust_remote_code=True)
+trainDS.embeddings=mdl.get_input_embeddings().weight
+arg=TrainingArguments(num_train_epochs=3,per_device_train_batch_size=1,dataloader_pin_memory=False,output_dir=tgt,overwrite_output_dir=True,save_total_limit=2,learning_rate=5e-05,warmup_ratio=0.1,save_safetensors=False)
+trn=Trainer(args=arg,data_collator=DefaultDataCollator(),model=mdl,train_dataset=trainDS)
+trn.train()
+trn.save_model(tgt)
+tkz.save_pretrained(tgt)

mecab.py

@@ -0,0 +1,34 @@
+from transformers import BertTokenizerFast
+from transformers.models.bert_japanese.tokenization_bert_japanese import MecabTokenizer
+
+class MecabPreTokenizer(MecabTokenizer):
+  def mecab_split(self,i,normalized_string):
+    t=str(normalized_string)
+    e=0
+    z=[]
+    for c in self.tokenize(t):
+      s=t.find(c,e)
+      e=e if s<0 else s+len(c)
+      z.append((0,0) if s<0 else (s,e))
+    return [normalized_string[s:e] for s,e in z if e>0]
+  def pre_tokenize(self,pretok):
+    pretok.split(self.mecab_split)
+
+class BertMecabTokenizerFast(BertTokenizerFast):
+  def __init__(self,vocab_file,do_lower_case=False,tokenize_chinese_chars=False,**kwargs):
+    from tokenizers import pre_tokenizers,normalizers
+    super().__init__(vocab_file=vocab_file,do_lower_case=do_lower_case,tokenize_chinese_chars=tokenize_chinese_chars,**kwargs)
+    d=kwargs["mecab_kwargs"] if "mecab_kwargs" in kwargs else {"mecab_dic":"ipadic"}
+    self._tokenizer.normalizer=normalizers.Sequence([normalizers.Nmt(),normalizers.NFKC()])
+    self.custom_pre_tokenizer=pre_tokenizers.Sequence([pre_tokenizers.PreTokenizer.custom(MecabPreTokenizer(**d)),pre_tokenizers.BertPreTokenizer()])
+    self._tokenizer.pre_tokenizer=self.custom_pre_tokenizer
+  def save_pretrained(self,save_directory,**kwargs):
+    import os
+    import shutil
+    from tokenizers.pre_tokenizers import Metaspace
+    self._auto_map={"AutoTokenizer":[None,"mecab.BertMecabTokenizerFast"]}
+    self._tokenizer.pre_tokenizer=Metaspace()
+    super().save_pretrained(save_directory,**kwargs)
+    self._tokenizer.pre_tokenizer=self.custom_pre_tokenizer
+    shutil.copy(os.path.abspath(__file__),os.path.join(save_directory,"mecab.py"))
+

pytorch_model.bin

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

special_tokens_map.json

@@ -0,0 +1,37 @@
+{
+  "cls_token": {
+    "content": "[CLS]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "[MASK]",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "[PAD]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "[SEP]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "[UNK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer_config.json

@@ -0,0 +1,71 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "[MASK]",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "auto_map": {
+    "AutoTokenizer": ["BertJapaneseTokenizer","mecab.BertMecabTokenizerFast"]
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_lower_case": false,
+  "do_subword_tokenize": true,
+  "do_word_tokenize": true,
+  "extra_special_tokens": {},
+  "jumanpp_kwargs": null,
+  "mask_token": "[MASK]",
+  "mecab_kwargs": {
+    "mecab_dic": "unidic_lite"
+  },
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 1000000000000000019884624838656,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "subword_tokenizer_type": "wordpiece",
+  "sudachi_kwargs": null,
+  "tokenizer_class": "BertJapaneseTokenizer",
+  "unk_token": "[UNK]",
+  "word_tokenizer_type": "mecab"
+}

ud.py

@@ -0,0 +1,150 @@
+import numpy
+from transformers import TokenClassificationPipeline
+
+class BellmanFordTokenClassificationPipeline(TokenClassificationPipeline):
+  def __init__(self,**kwargs):
+    super().__init__(**kwargs)
+    x=self.model.config.label2id
+    y=[k for k in x if k.find("|")<0 and not k.startswith("I-")]
+    self.transition=numpy.full((len(x),len(x)),-numpy.inf)
+    for k,v in x.items():
+      if k.find("|")<0:
+        for j in ["I-"+k[2:]] if k.startswith("B-") else [k]+y if k.startswith("I-") else y:
+          self.transition[v,x[j]]=0
+  def check_model_type(self,supported_models):
+    pass
+  def postprocess(self,model_outputs,**kwargs):
+    if "logits" not in model_outputs:
+      return self.postprocess(model_outputs[0],**kwargs)
+    return self.bellman_ford_token_classification(model_outputs,**kwargs)
+  def bellman_ford_token_classification(self,model_outputs,**kwargs):
+    m=model_outputs["logits"][0].numpy()
+    e=numpy.exp(m-numpy.max(m,axis=-1,keepdims=True))
+    z=e/e.sum(axis=-1,keepdims=True)
+    for i in range(m.shape[0]-1,0,-1):
+      m[i-1]+=numpy.max(m[i]+self.transition,axis=1)
+    k=[numpy.argmax(m[0]+self.transition[0])]
+    for i in range(1,m.shape[0]):
+      k.append(numpy.argmax(m[i]+self.transition[k[-1]]))
+    w=[{"entity":self.model.config.id2label[j],"start":s,"end":e,"score":z[i,j]} for i,((s,e),j) in enumerate(zip(model_outputs["offset_mapping"][0].tolist(),k)) if s<e]
+    if "aggregation_strategy" in kwargs and kwargs["aggregation_strategy"]!="none":
+      for i,t in reversed(list(enumerate(w))):
+        p=t.pop("entity")
+        if p.startswith("I-"):
+          w[i-1]["score"]=min(w[i-1]["score"],t["score"])
+          w[i-1]["end"]=w.pop(i)["end"]
+        elif p.startswith("B-"):
+          t["entity_group"]=p[2:]
+        else:
+          t["entity_group"]=p
+    for t in w:
+      t["text"]=model_outputs["sentence"][t["start"]:t["end"]]
+    return w
+
+class UniversalDependenciesPipeline(BellmanFordTokenClassificationPipeline):
+  def __init__(self,**kwargs):
+    kwargs["aggregation_strategy"]="simple"
+    super().__init__(**kwargs)
+    x=self.model.config.label2id
+    self.root=numpy.full((len(x)),-numpy.inf)
+    self.left_arc=numpy.full((len(x)),-numpy.inf)
+    self.right_arc=numpy.full((len(x)),-numpy.inf)
+    for k,v in x.items():
+      if k.endswith("|root"):
+        self.root[v]=0
+      elif k.find("|l-")>0:
+        self.left_arc[v]=0
+      elif k.find("|r-")>0:
+        self.right_arc[v]=0
+  def postprocess(self,model_outputs,**kwargs):
+    import torch
+    kwargs["aggregation_strategy"]="simple"
+    if "logits" not in model_outputs:
+      return self.postprocess(model_outputs[0],**kwargs)
+    w=self.bellman_ford_token_classification(model_outputs,**kwargs)
+    off=[(t["start"],t["end"]) for t in w]
+    for i,(s,e) in reversed(list(enumerate(off))):
+      if s<e:
+        d=w[i]["text"]
+        j=len(d)-len(d.lstrip())
+        if j>0:
+          d=d.lstrip()
+          off[i]=(off[i][0]+j,off[i][1])
+        j=len(d)-len(d.rstrip())
+        if j>0:
+          d=d.rstrip()
+          off[i]=(off[i][0],off[i][1]-j)
+        if d.strip()=="":
+          off.pop(i)
+          w.pop(i)
+    v=self.tokenizer([t["text"] for t in w],add_special_tokens=False)
+    x=[not t["entity_group"].endswith(".") for t in w]
+    if len(x)<127:
+      x=[True]*len(x)
+    else:
+      k=sum([len(x)-i+1 if b else 0 for i,b in enumerate(x)])+1
+      for i in numpy.argsort(numpy.array([t["score"] for t in w])):
+        if x[i]==False and k+len(x)-i<8192:
+          x[i]=True
+          k+=len(x)-i+1
+    ids=[-1]
+    for i in range(len(x)):
+      if x[i]:
+        ids.append(i)
+        for j in range(i+1,len(x)):
+          ids.append(j)
+        ids.append(-1)
+    with torch.no_grad():
+      e=self.model.get_input_embeddings().weight
+      m=[]
+      for j in v["input_ids"]:
+        if j==[]:
+          j=[self.tokenizer.unk_token_id]
+        m.append(e[j,:].sum(axis=0))
+      m.append(e[self.tokenizer.sep_token_id,:])
+      m=torch.stack(m).to(self.device)
+      e=self.model(inputs_embeds=torch.unsqueeze(m[ids,:],0))
+    m=e.logits[0].cpu().numpy()
+    e=numpy.full((len(x),len(x),m.shape[-1]),m.min())
+    k=1
+    for i in range(len(x)):
+      if x[i]:
+        e[i,i]=m[k]+self.root
+        k+=1
+        for j in range(1,len(x)-i):
+          e[i+j,i]=m[k]+self.left_arc
+          e[i,i+j]=m[k]+self.right_arc
+          k+=1
+        k+=1
+    m,p=numpy.max(e,axis=2),numpy.argmax(e,axis=2)
+    h=self.chu_liu_edmonds(m)
+    z=[i for i,j in enumerate(h) if i==j]
+    if len(z)>1:
+      k,h=z[numpy.argmax(m[z,z])],numpy.min(m)-numpy.max(m)
+      m[:,z]+=[[0 if j in z and (i!=j or i==k) else h for i in z] for j in range(m.shape[0])]
+      h=self.chu_liu_edmonds(m)
+    q=[self.model.config.id2label[p[j,i]].split("|") for i,j in enumerate(h)]
+    t=model_outputs["sentence"].replace("\n"," ")
+    u="# text = "+t+"\n"
+    for i,(s,e) in enumerate(off):
+      u+="\t".join([str(i+1),t[s:e],"_",q[i][0],"_","_" if len(q[i])<3 else "|".join(q[i][1:-1]),str(0 if h[i]==i else h[i]+1),"root" if q[i][-1]=="root" else q[i][-1][2:],"_","_" if i+1<len(off) and e<off[i+1][0] else "SpaceAfter=No"])+"\n"
+    return u+"\n"
+  def chu_liu_edmonds(self,matrix):
+    h=numpy.argmax(matrix,axis=0)
+    x=[-1 if i==j else j for i,j in enumerate(h)]
+    for b in [lambda x,i,j:-1 if i not in x else x[i],lambda x,i,j:-1 if j<0 else x[j]]:
+      y=[]
+      while x!=y:
+        y=list(x)
+        for i,j in enumerate(x):
+          x[i]=b(x,i,j)
+      if max(x)<0:
+        return h
+    y,x=[i for i,j in enumerate(x) if j==max(x)],[i for i,j in enumerate(x) if j<max(x)]
+    z=matrix-numpy.max(matrix,axis=0)
+    m=numpy.block([[z[x,:][:,x],numpy.max(z[x,:][:,y],axis=1).reshape(len(x),1)],[numpy.max(z[y,:][:,x],axis=0),numpy.max(z[y,y])]])
+    k=[j if i==len(x) else x[j] if j<len(x) else y[numpy.argmax(z[y,x[i]])] for i,j in enumerate(self.chu_liu_edmonds(m))]
+    h=[j if i in y else k[x.index(i)] for i,j in enumerate(h)]
+    i=y[numpy.argmax(z[x[k[-1]],y] if k[-1]<len(x) else z[y,y])]
+    h[i]=x[k[-1]] if k[-1]<len(x) else i
+    return h