initial release

README.md

@@ -0,0 +1,30 @@
+---
+language:
+- "ja"
+tags:
+- "japanese"
+- "wikipedia"
+- "cc100"
+- "pos"
+- "dependency-parsing"
+datasets:
+- "universal_dependencies"
+license: "cc-by-sa-4.0"
+pipeline_tag: "token-classification"
+---
+
+# roberta-base-japanese-juman-ud-goeswith
+
+## Model Description
+
+This is a RoBERTa model pretrained on Japanese Wikipedia and CC-100 texts for POS-tagging and dependency-parsing (using `goeswith` for subwords), derived from [roberta-base-japanese](https://huggingface.co/nlp-waseda/roberta-base-japanese).
+
+## How to Use
+
+```
+from transformers import pipeline
+nlp=pipeline("universal-dependencies","KoichiYasuoka/roberta-base-japanese-juman-ud-goeswith",trust_remote_code=True,aggregation_strategy="simple")
+print(nlp("全学年にわたって小学校の国語の教科書に挿し絵が用いられている"))
+```
+
+[fugashi](https://pypi.org/project/fugashi) is required.

config.json

@@ -0,0 +1,329 @@
+{
+  "architectures": [
+    "RobertaForTokenClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 2,
+  "classifier_dropout": null,
+  "custom_pipelines": {
+    "universal-dependencies": {
+      "impl": "ud.UniversalDependenciesPipeline"
+    }
+  },
+  "eos_token_id": 3,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "-|_|dep",
+    "1": "ADJ|Polarity=Neg|acl",
+    "2": "ADJ|Polarity=Neg|advcl",
+    "3": "ADJ|Polarity=Neg|ccomp",
+    "4": "ADJ|Polarity=Neg|root",
+    "5": "ADJ|_|acl",
+    "6": "ADJ|_|advcl",
+    "7": "ADJ|_|amod",
+    "8": "ADJ|_|ccomp",
+    "9": "ADJ|_|compound",
+    "10": "ADJ|_|csubj",
+    "11": "ADJ|_|dep",
+    "12": "ADJ|_|iobj",
+    "13": "ADJ|_|nmod",
+    "14": "ADJ|_|nsubj",
+    "15": "ADJ|_|obj",
+    "16": "ADJ|_|obl",
+    "17": "ADJ|_|parataxis",
+    "18": "ADJ|_|root",
+    "19": "ADP|_|case",
+    "20": "ADP|_|dislocated",
+    "21": "ADP|_|fixed",
+    "22": "ADP|_|mark",
+    "23": "ADP|_|root",
+    "24": "ADV|_|advcl",
+    "25": "ADV|_|advmod",
+    "26": "ADV|_|compound",
+    "27": "ADV|_|dislocated",
+    "28": "ADV|_|iobj",
+    "29": "ADV|_|nmod",
+    "30": "ADV|_|nsubj",
+    "31": "ADV|_|obj",
+    "32": "ADV|_|obl",
+    "33": "ADV|_|root",
+    "34": "AUX|Polarity=Neg|aux",
+    "35": "AUX|_|acl",
+    "36": "AUX|_|advcl",
+    "37": "AUX|_|aux",
+    "38": "AUX|_|ccomp",
+    "39": "AUX|_|conj",
+    "40": "AUX|_|cop",
+    "41": "AUX|_|fixed",
+    "42": "AUX|_|iobj",
+    "43": "AUX|_|obj",
+    "44": "AUX|_|obl",
+    "45": "AUX|_|root",
+    "46": "CCONJ|_|advmod",
+    "47": "CCONJ|_|case",
+    "48": "CCONJ|_|cc",
+    "49": "CCONJ|_|ccomp",
+    "50": "CCONJ|_|fixed",
+    "51": "CCONJ|_|mark",
+    "52": "DET|_|det",
+    "53": "DET|_|nsubj",
+    "54": "DET|_|obl",
+    "55": "DET|_|root",
+    "56": "INTJ|_|discourse",
+    "57": "INTJ|_|root",
+    "58": "NOUN|Polarity=Neg|compound",
+    "59": "NOUN|_|acl",
+    "60": "NOUN|_|advcl",
+    "61": "NOUN|_|advmod",
+    "62": "NOUN|_|appos",
+    "63": "NOUN|_|ccomp",
+    "64": "NOUN|_|compound",
+    "65": "NOUN|_|conj",
+    "66": "NOUN|_|csubj",
+    "67": "NOUN|_|dislocated",
+    "68": "NOUN|_|iobj",
+    "69": "NOUN|_|list",
+    "70": "NOUN|_|nmod",
+    "71": "NOUN|_|nsubj",
+    "72": "NOUN|_|obj",
+    "73": "NOUN|_|obl",
+    "74": "NOUN|_|parataxis",
+    "75": "NOUN|_|root",
+    "76": "NUM|_|advcl",
+    "77": "NUM|_|dislocated",
+    "78": "NUM|_|iobj",
+    "79": "NUM|_|nmod",
+    "80": "NUM|_|nsubj",
+    "81": "NUM|_|nummod",
+    "82": "NUM|_|obj",
+    "83": "NUM|_|obl",
+    "84": "NUM|_|root",
+    "85": "PART|_|acl",
+    "86": "PART|_|advcl",
+    "87": "PART|_|amod",
+    "88": "PART|_|case",
+    "89": "PART|_|conj",
+    "90": "PART|_|iobj",
+    "91": "PART|_|mark",
+    "92": "PART|_|nmod",
+    "93": "PART|_|nsubj",
+    "94": "PART|_|obj",
+    "95": "PART|_|obl",
+    "96": "PART|_|root",
+    "97": "PRON|_|acl",
+    "98": "PRON|_|advcl",
+    "99": "PRON|_|compound",
+    "100": "PRON|_|discourse",
+    "101": "PRON|_|dislocated",
+    "102": "PRON|_|iobj",
+    "103": "PRON|_|nmod",
+    "104": "PRON|_|nsubj",
+    "105": "PRON|_|obj",
+    "106": "PRON|_|obl",
+    "107": "PRON|_|root",
+    "108": "PROPN|_|acl",
+    "109": "PROPN|_|advcl",
+    "110": "PROPN|_|compound",
+    "111": "PROPN|_|dislocated",
+    "112": "PROPN|_|iobj",
+    "113": "PROPN|_|nmod",
+    "114": "PROPN|_|nsubj",
+    "115": "PROPN|_|obj",
+    "116": "PROPN|_|obl",
+    "117": "PROPN|_|root",
+    "118": "PROPN|_|vocative",
+    "119": "PUNCT|_|punct",
+    "120": "SCONJ|_|advcl",
+    "121": "SCONJ|_|fixed",
+    "122": "SCONJ|_|mark",
+    "123": "SYM|_|compound",
+    "124": "SYM|_|nmod",
+    "125": "SYM|_|nsubj",
+    "126": "SYM|_|obl",
+    "127": "SYM|_|punct",
+    "128": "VERB|_|acl",
+    "129": "VERB|_|advcl",
+    "130": "VERB|_|aux",
+    "131": "VERB|_|ccomp",
+    "132": "VERB|_|compound",
+    "133": "VERB|_|conj",
+    "134": "VERB|_|csubj",
+    "135": "VERB|_|dislocated",
+    "136": "VERB|_|fixed",
+    "137": "VERB|_|iobj",
+    "138": "VERB|_|nmod",
+    "139": "VERB|_|nsubj",
+    "140": "VERB|_|obj",
+    "141": "VERB|_|obl",
+    "142": "VERB|_|parataxis",
+    "143": "VERB|_|root",
+    "144": "X|_|dep",
+    "145": "X|_|goeswith",
+    "146": "X|_|nmod"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "-|_|dep": 0,
+    "ADJ|Polarity=Neg|acl": 1,
+    "ADJ|Polarity=Neg|advcl": 2,
+    "ADJ|Polarity=Neg|ccomp": 3,
+    "ADJ|Polarity=Neg|root": 4,
+    "ADJ|_|acl": 5,
+    "ADJ|_|advcl": 6,
+    "ADJ|_|amod": 7,
+    "ADJ|_|ccomp": 8,
+    "ADJ|_|compound": 9,
+    "ADJ|_|csubj": 10,
+    "ADJ|_|dep": 11,
+    "ADJ|_|iobj": 12,
+    "ADJ|_|nmod": 13,
+    "ADJ|_|nsubj": 14,
+    "ADJ|_|obj": 15,
+    "ADJ|_|obl": 16,
+    "ADJ|_|parataxis": 17,
+    "ADJ|_|root": 18,
+    "ADP|_|case": 19,
+    "ADP|_|dislocated": 20,
+    "ADP|_|fixed": 21,
+    "ADP|_|mark": 22,
+    "ADP|_|root": 23,
+    "ADV|_|advcl": 24,
+    "ADV|_|advmod": 25,
+    "ADV|_|compound": 26,
+    "ADV|_|dislocated": 27,
+    "ADV|_|iobj": 28,
+    "ADV|_|nmod": 29,
+    "ADV|_|nsubj": 30,
+    "ADV|_|obj": 31,
+    "ADV|_|obl": 32,
+    "ADV|_|root": 33,
+    "AUX|Polarity=Neg|aux": 34,
+    "AUX|_|acl": 35,
+    "AUX|_|advcl": 36,
+    "AUX|_|aux": 37,
+    "AUX|_|ccomp": 38,
+    "AUX|_|conj": 39,
+    "AUX|_|cop": 40,
+    "AUX|_|fixed": 41,
+    "AUX|_|iobj": 42,
+    "AUX|_|obj": 43,
+    "AUX|_|obl": 44,
+    "AUX|_|root": 45,
+    "CCONJ|_|advmod": 46,
+    "CCONJ|_|case": 47,
+    "CCONJ|_|cc": 48,
+    "CCONJ|_|ccomp": 49,
+    "CCONJ|_|fixed": 50,
+    "CCONJ|_|mark": 51,
+    "DET|_|det": 52,
+    "DET|_|nsubj": 53,
+    "DET|_|obl": 54,
+    "DET|_|root": 55,
+    "INTJ|_|discourse": 56,
+    "INTJ|_|root": 57,
+    "NOUN|Polarity=Neg|compound": 58,
+    "NOUN|_|acl": 59,
+    "NOUN|_|advcl": 60,
+    "NOUN|_|advmod": 61,
+    "NOUN|_|appos": 62,
+    "NOUN|_|ccomp": 63,
+    "NOUN|_|compound": 64,
+    "NOUN|_|conj": 65,
+    "NOUN|_|csubj": 66,
+    "NOUN|_|dislocated": 67,
+    "NOUN|_|iobj": 68,
+    "NOUN|_|list": 69,
+    "NOUN|_|nmod": 70,
+    "NOUN|_|nsubj": 71,
+    "NOUN|_|obj": 72,
+    "NOUN|_|obl": 73,
+    "NOUN|_|parataxis": 74,
+    "NOUN|_|root": 75,
+    "NUM|_|advcl": 76,
+    "NUM|_|dislocated": 77,
+    "NUM|_|iobj": 78,
+    "NUM|_|nmod": 79,
+    "NUM|_|nsubj": 80,
+    "NUM|_|nummod": 81,
+    "NUM|_|obj": 82,
+    "NUM|_|obl": 83,
+    "NUM|_|root": 84,
+    "PART|_|acl": 85,
+    "PART|_|advcl": 86,
+    "PART|_|amod": 87,
+    "PART|_|case": 88,
+    "PART|_|conj": 89,
+    "PART|_|iobj": 90,
+    "PART|_|mark": 91,
+    "PART|_|nmod": 92,
+    "PART|_|nsubj": 93,
+    "PART|_|obj": 94,
+    "PART|_|obl": 95,
+    "PART|_|root": 96,
+    "PRON|_|acl": 97,
+    "PRON|_|advcl": 98,
+    "PRON|_|compound": 99,
+    "PRON|_|discourse": 100,
+    "PRON|_|dislocated": 101,
+    "PRON|_|iobj": 102,
+    "PRON|_|nmod": 103,
+    "PRON|_|nsubj": 104,
+    "PRON|_|obj": 105,
+    "PRON|_|obl": 106,
+    "PRON|_|root": 107,
+    "PROPN|_|acl": 108,
+    "PROPN|_|advcl": 109,
+    "PROPN|_|compound": 110,
+    "PROPN|_|dislocated": 111,
+    "PROPN|_|iobj": 112,
+    "PROPN|_|nmod": 113,
+    "PROPN|_|nsubj": 114,
+    "PROPN|_|obj": 115,
+    "PROPN|_|obl": 116,
+    "PROPN|_|root": 117,
+    "PROPN|_|vocative": 118,
+    "PUNCT|_|punct": 119,
+    "SCONJ|_|advcl": 120,
+    "SCONJ|_|fixed": 121,
+    "SCONJ|_|mark": 122,
+    "SYM|_|compound": 123,
+    "SYM|_|nmod": 124,
+    "SYM|_|nsubj": 125,
+    "SYM|_|obl": 126,
+    "SYM|_|punct": 127,
+    "VERB|_|acl": 128,
+    "VERB|_|advcl": 129,
+    "VERB|_|aux": 130,
+    "VERB|_|ccomp": 131,
+    "VERB|_|compound": 132,
+    "VERB|_|conj": 133,
+    "VERB|_|csubj": 134,
+    "VERB|_|dislocated": 135,
+    "VERB|_|fixed": 136,
+    "VERB|_|iobj": 137,
+    "VERB|_|nmod": 138,
+    "VERB|_|nsubj": 139,
+    "VERB|_|obj": 140,
+    "VERB|_|obl": 141,
+    "VERB|_|parataxis": 142,
+    "VERB|_|root": 143,
+    "X|_|dep": 144,
+    "X|_|goeswith": 145,
+    "X|_|nmod": 146
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 514,
+  "model_type": "roberta",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "float32",
+  "transformers_version": "4.26.1",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 32000
+}

maker.py

@@ -0,0 +1,51 @@
+#! /usr/bin/python3
+src="nlp-waseda/roberta-base-japanese"
+tgt="KoichiYasuoka/roberta-base-japanese-juman-ud-goeswith"
+url="https://github.com/KoichiYasuoka/SuPar-UniDic/raw/main/suparunidic/suparmodels/ja_gsd_modern.conllu"
+import os
+f=os.path.basename(url)
+os.system("test -f "+f+" || curl -LO "+url)
+class UDgoeswithDataset(object):
+  def __init__(self,conllu,tokenizer):
+    self.ids,self.tags,label=[],[],set()
+    with open(conllu,"r",encoding="utf-8") as r:
+      cls,sep,msk=tokenizer.cls_token_id,tokenizer.sep_token_id,tokenizer.mask_token_id
+      dep,c="-|_|dep",[]
+      for s in r:
+        t=s.split("\t")
+        if len(t)==10 and t[0].isdecimal():
+          c.append(t)
+        elif c!=[] and s.strip()=="":
+          v=tokenizer([t[1] for t in c],add_special_tokens=False)["input_ids"]
+          for i in range(len(v)-1,-1,-1):
+            for j in range(1,len(v[i])):
+              c.insert(i+1,[c[i][0],"_","_","X","_","_",c[i][0],"goeswith","_","_"])
+          y=["0"]+[t[0] for t in c]
+          h=[i if t[6]=="0" else y.index(t[6]) for i,t in enumerate(c,1)]
+          p,v=[t[3]+"|"+t[5]+"|"+t[7] for t in c],sum(v,[])
+          self.ids.append([cls]+v+[sep])
+          self.tags.append([dep]+p+[dep])
+          label=set(sum([self.tags[-1],list(label)],[]))
+          for i,k in enumerate(v):
+            self.ids.append([cls]+v[0:i]+[msk]+v[i+1:]+[sep,k])
+            self.tags.append([dep]+[t if h[j]==i+1 else dep for j,t in enumerate(p)]+[dep,dep])
+          c=[]
+    self.label2id={l:i for i,l in enumerate(sorted(label))}
+  def __call__(*args):
+    label=set(sum([list(t.label2id) for t in args],[]))
+    lid={l:i for i,l in enumerate(sorted(label))}
+    for t in args:
+      t.label2id=lid
+    return lid
+  __len__=lambda self:len(self.ids)
+  __getitem__=lambda self,i:{"input_ids":self.ids[i],"labels":[self.label2id[t] for t in self.tags[i]]}
+from transformers import AutoTokenizer,AutoConfig,AutoModelForTokenClassification,DataCollatorForTokenClassification,TrainingArguments,Trainer
+tkz=AutoTokenizer.from_pretrained(src)
+trainDS=UDgoeswithDataset(f,tkz)
+lid=trainDS.label2id
+cfg=AutoConfig.from_pretrained(src,num_labels=len(lid),label2id=lid,id2label={i:l for l,i in lid.items()})
+arg=TrainingArguments(num_train_epochs=3,per_device_train_batch_size=32,output_dir="/tmp",overwrite_output_dir=True,save_total_limit=2,learning_rate=5e-05,warmup_ratio=0.1)
+trn=Trainer(args=arg,data_collator=DataCollatorForTokenClassification(tkz),model=AutoModelForTokenClassification.from_pretrained(src,config=cfg),train_dataset=trainDS)
+trn.train()
+trn.save_model(tgt)
+tkz.save_pretrained(tgt)

mecab-jumandic-utf8.zip

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

pytorch_model.bin

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

special_tokens_map.json

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

spiece.model

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

tokenizer_config.json

@@ -0,0 +1,26 @@
+{
+  "auto_map": {"AutoTokenizer":["ud.BertJapaneseTokenizer","ud.JumanAlbertTokenizerFast"]},
+  "bos_token": "[CLS]",
+  "cls_token": "[CLS]",
+  "do_lower_case": false,
+  "eos_token": "[SEP]",
+  "keep_accents": true,
+  "mask_token": {
+    "__type": "AddedToken",
+    "content": "[MASK]",
+    "lstrip": true,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "model_max_length": 514,
+  "pad_token": "[PAD]",
+  "remove_space": true,
+  "sep_token": "[SEP]",
+  "sp_model_kwargs": {},
+  "special_tokens_map_file": null,
+  "subword_tokenizer_type": "sentencepiece",
+  "tokenizer_class": "JumanAlbertTokenizerFast",
+  "unk_token": "[UNK]",
+  "word_tokenizer_type": "jumanpp"
+}

ud.py

@@ -0,0 +1,107 @@
+import os
+from transformers import TokenClassificationPipeline,AlbertTokenizerFast,BertJapaneseTokenizer
+from transformers.models.bert_japanese.tokenization_bert_japanese import MecabTokenizer
+try:
+  from transformers.utils import cached_file
+except:
+  from transformers.file_utils import cached_path,hf_bucket_url
+  cached_file=lambda x,y:os.path.join(x,y) if os.path.isdir(x) else cached_path(hf_bucket_url(x,y))
+
+class UniversalDependenciesPipeline(TokenClassificationPipeline):
+  def _forward(self,model_inputs):
+    import torch
+    v=model_inputs["input_ids"][0].tolist()
+    with torch.no_grad():
+      e=self.model(input_ids=torch.tensor([v[0:i]+[self.tokenizer.mask_token_id]+v[i+1:]+[j] for i,j in enumerate(v[1:-1],1)],device=self.device))
+    return {"logits":e.logits[:,1:-2,:],**model_inputs}
+  def postprocess(self,model_outputs,**kwargs):
+    import numpy
+    e=model_outputs["logits"].numpy()
+    r=[1 if i==0 else -1 if j.endswith("|root") else 0 for i,j in sorted(self.model.config.id2label.items())]
+    e+=numpy.where(numpy.add.outer(numpy.identity(e.shape[0]),r)==0,0,numpy.nan)
+    g=self.model.config.label2id["X|_|goeswith"]
+    r=numpy.tri(e.shape[0])
+    for i in range(e.shape[0]):
+      for j in range(i+2,e.shape[1]):
+        r[i,j]=r[i,j-1] if numpy.nanargmax(e[i,j-1])==g else 1
+    e[:,:,g]+=numpy.where(r==0,0,numpy.nan)
+    m,p=numpy.nanmax(e,axis=2),numpy.nanargmax(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.nanargmax(m[z,z])],numpy.nanmin(m)-numpy.nanmax(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)
+    v=[(s,e) for s,e in model_outputs["offset_mapping"][0].tolist() if s<e]
+    q=[self.model.config.id2label[p[j,i]].split("|") for i,j in enumerate(h)]
+    if "aggregation_strategy" in kwargs and kwargs["aggregation_strategy"]!="none":
+      for i,j in reversed(list(enumerate(q[1:],1))):
+        if j[-1]=="goeswith" and set([t[-1] for t in q[h[i]+1:i+1]])=={"goeswith"}:
+          h=[b if i>b else b-1 for a,b in enumerate(h) if i!=a]
+          v[i-1]=(v[i-1][0],v.pop(i)[1])
+          q.pop(i)
+    t=model_outputs["sentence"].replace("\n"," ")
+    u="# text = "+t+"\n"
+    for i,(s,e) in enumerate(v):
+      u+="\t".join([str(i+1),t[s:e],"_",q[i][0],"_","|".join(q[i][1:-1]),str(0 if h[i]==i else h[i]+1),q[i][-1],"_","_" if i+1<len(v) and e<v[i+1][0] else "SpaceAfter=No"])+"\n"
+    return u+"\n"
+  def chu_liu_edmonds(self,matrix):
+    import numpy
+    h=numpy.nanargmax(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.nanmax(matrix,axis=0)
+    m=numpy.block([[z[x,:][:,x],numpy.nanmax(z[x,:][:,y],axis=1).reshape(len(x),1)],[numpy.nanmax(z[y,:][:,x],axis=0),numpy.nanmax(z[y,y])]])
+    k=[j if i==len(x) else x[j] if j<len(x) else y[numpy.nanargmax(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.nanargmax(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
+
+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 JumanAlbertTokenizerFast(AlbertTokenizerFast):
+  def __init__(self,**kwargs):
+    from tokenizers.pre_tokenizers import PreTokenizer,Metaspace,Sequence
+    super().__init__(**kwargs)
+    d,r="/var/lib/mecab/dic/juman-utf8","/etc/mecabrc"
+    if not (os.path.isdir(d) and os.path.isfile(r)):
+      import zipfile
+      import tempfile
+      self.dicdir=tempfile.TemporaryDirectory()
+      d=self.dicdir.name
+      with zipfile.ZipFile(cached_file(self.name_or_path,"mecab-jumandic-utf8.zip")) as z:
+        z.extractall(d)
+      r=os.path.join(d,"mecabrc")
+      with open(r,"w",encoding="utf-8") as w:
+        print("dicdir =",d,file=w)
+    self.custom_pre_tokenizer=Sequence([PreTokenizer.custom(MecabPreTokenizer(mecab_dic=None,mecab_option="-d "+d+" -r "+r)),Metaspace()])
+    self._tokenizer.pre_tokenizer=self.custom_pre_tokenizer
+  def save_pretrained(self,save_directory,**kwargs):
+    import shutil
+    from tokenizers.pre_tokenizers import Metaspace
+    self._auto_map={"AutoTokenizer":["ud.BertJapaneseTokenizer","ud.JumanAlbertTokenizerFast"]}
+    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,"ud.py"))
+    shutil.copy(cached_file(self.name_or_path,"mecab-jumandic-utf8.zip"),os.path.join(save_directory,"mecab-jumandic-utf8.zip"))