release after the tokenizer refined

README.md

@@ -0,0 +1,30 @@
+---
+language:
+- "ja"
+tags:
+- "japanese"
+- "pos"
+- "dependency-parsing"
+base_model: rinna/japanese-gpt2-small
+datasets:
+- "universal_dependencies"
+license: "mit"
+pipeline_tag: "token-classification"
+widget:
+- text: "全学年にわたって小学校の国語の教科書に挿し絵が用いられている"
+---
+
+# rinna-gpt2-small-japanese-ud-causal
+
+## Model Description
+
+This is a GPT-2 model pretrained for POS-tagging and dependency-parsing, derived from [japanese-gpt2-small](https://huggingface.co/rinna/japanese-gpt2-small)  refined for [UD_Japanese-GSDLUW](https://github.com/UniversalDependencies/UD_Japanese-GSDLUW).
+
+## How to Use
+
+```
+from transformers import pipeline
+nlp=pipeline("universal-dependencies","KoichiYasuoka/rinna-gpt2-small-japanese-ud-causal",trust_remote_code=True)
+print(nlp("全学年にわたって小学校の国語の教科書に挿し絵が用いられている"))
+```
+

config.json

@@ -0,0 +1,378 @@
+{
+  "activation_function": "gelu_new",
+  "architectures": [
+    "GPT2ForTokenClassification"
+  ],
+  "attn_pdrop": 0.1,
+  "bos_token_id": 1,
+  "custom_pipelines": {
+    "upos": {
+      "impl": "ud.BellmanFordTokenClassificationPipeline",
+      "pt": "AutoModelForTokenClassification"
+    },
+    "universal-dependencies": {
+      "impl": "ud.UniversalDependenciesCausalPipeline",
+      "pt": "AutoModelForTokenClassification"
+    }
+  },
+  "embd_pdrop": 0.1,
+  "eos_token_id": 2,
+  "gradient_checkpointing": false,
+  "id2label": {
+    "0": "ADJ",
+    "1": "ADJ|l-acl",
+    "2": "ADJ|l-advcl",
+    "3": "ADJ|l-amod",
+    "4": "ADJ|l-ccomp",
+    "5": "ADJ|l-csubj",
+    "6": "ADJ|l-csubj:outer",
+    "7": "ADJ|l-nmod",
+    "8": "ADJ|l-nsubj",
+    "9": "ADJ|l-obj",
+    "10": "ADJ|l-obl",
+    "11": "ADJ|r-acl",
+    "12": "ADJ|r-amod",
+    "13": "ADJ|r-dep",
+    "14": "ADJ|root",
+    "15": "ADP",
+    "16": "ADP|l-case",
+    "17": "ADP|r-case",
+    "18": "ADP|r-fixed",
+    "19": "ADV",
+    "20": "ADV|l-advcl",
+    "21": "ADV|l-advmod",
+    "22": "ADV|l-obj",
+    "23": "ADV|r-dep",
+    "24": "ADV|root",
+    "25": "AUX",
+    "26": "AUX|Polarity=Neg",
+    "27": "AUX|Polarity=Neg|r-aux",
+    "28": "AUX|Polarity=Neg|r-fixed",
+    "29": "AUX|r-aux",
+    "30": "AUX|r-cop",
+    "31": "AUX|r-fixed",
+    "32": "AUX|root",
+    "33": "B-ADJ",
+    "34": "B-ADP",
+    "35": "B-ADV",
+    "36": "B-AUX",
+    "37": "B-AUX|Polarity=Neg",
+    "38": "B-CCONJ",
+    "39": "B-DET",
+    "40": "B-INTJ",
+    "41": "B-NOUN",
+    "42": "B-NOUN|Polarity=Neg",
+    "43": "B-NUM",
+    "44": "B-PART",
+    "45": "B-PRON",
+    "46": "B-PROPN",
+    "47": "B-PUNCT",
+    "48": "B-SCONJ",
+    "49": "B-SYM",
+    "50": "B-VERB",
+    "51": "B-X",
+    "52": "CCONJ",
+    "53": "CCONJ|l-cc",
+    "54": "CCONJ|r-cc",
+    "55": "DET",
+    "56": "DET|l-det",
+    "57": "I-ADJ",
+    "58": "I-ADP",
+    "59": "I-ADV",
+    "60": "I-AUX",
+    "61": "I-AUX|Polarity=Neg",
+    "62": "I-CCONJ",
+    "63": "I-DET",
+    "64": "I-INTJ",
+    "65": "I-NOUN",
+    "66": "I-NOUN|Polarity=Neg",
+    "67": "I-NUM",
+    "68": "I-PART",
+    "69": "I-PRON",
+    "70": "I-PROPN",
+    "71": "I-PUNCT",
+    "72": "I-SCONJ",
+    "73": "I-SYM",
+    "74": "I-VERB",
+    "75": "I-X",
+    "76": "INTJ",
+    "77": "INTJ|l-discourse",
+    "78": "INTJ|r-discourse",
+    "79": "INTJ|root",
+    "80": "NOUN",
+    "81": "NOUN|Polarity=Neg",
+    "82": "NOUN|Polarity=Neg|l-obl",
+    "83": "NOUN|Polarity=Neg|root",
+    "84": "NOUN|l-acl",
+    "85": "NOUN|l-advcl",
+    "86": "NOUN|l-ccomp",
+    "87": "NOUN|l-compound",
+    "88": "NOUN|l-csubj",
+    "89": "NOUN|l-csubj:outer",
+    "90": "NOUN|l-nmod",
+    "91": "NOUN|l-nsubj",
+    "92": "NOUN|l-nsubj:outer",
+    "93": "NOUN|l-obj",
+    "94": "NOUN|l-obl",
+    "95": "NOUN|r-compound",
+    "96": "NOUN|r-nmod",
+    "97": "NOUN|r-nsubj",
+    "98": "NOUN|root",
+    "99": "NUM",
+    "100": "NUM|l-advcl",
+    "101": "NUM|l-compound",
+    "102": "NUM|l-nmod",
+    "103": "NUM|l-nsubj",
+    "104": "NUM|l-nsubj:outer",
+    "105": "NUM|l-nummod",
+    "106": "NUM|l-obj",
+    "107": "NUM|l-obl",
+    "108": "NUM|r-compound",
+    "109": "NUM|root",
+    "110": "PART",
+    "111": "PART|l-mark",
+    "112": "PART|r-mark",
+    "113": "PRON",
+    "114": "PRON|l-acl",
+    "115": "PRON|l-advcl",
+    "116": "PRON|l-nmod",
+    "117": "PRON|l-nsubj",
+    "118": "PRON|l-nsubj:outer",
+    "119": "PRON|l-obj",
+    "120": "PRON|l-obl",
+    "121": "PRON|root",
+    "122": "PROPN",
+    "123": "PROPN|l-acl",
+    "124": "PROPN|l-advcl",
+    "125": "PROPN|l-compound",
+    "126": "PROPN|l-nmod",
+    "127": "PROPN|l-nsubj",
+    "128": "PROPN|l-nsubj:outer",
+    "129": "PROPN|l-obj",
+    "130": "PROPN|l-obl",
+    "131": "PROPN|r-compound",
+    "132": "PROPN|r-nmod",
+    "133": "PROPN|root",
+    "134": "PUNCT",
+    "135": "PUNCT|l-punct",
+    "136": "PUNCT|r-punct",
+    "137": "SCONJ",
+    "138": "SCONJ|l-dep",
+    "139": "SCONJ|r-fixed",
+    "140": "SCONJ|r-mark",
+    "141": "SYM",
+    "142": "SYM|l-compound",
+    "143": "SYM|l-dep",
+    "144": "SYM|l-nmod",
+    "145": "SYM|l-obl",
+    "146": "SYM|r-compound",
+    "147": "SYM|r-dep",
+    "148": "VERB",
+    "149": "VERB|l-acl",
+    "150": "VERB|l-advcl",
+    "151": "VERB|l-ccomp",
+    "152": "VERB|l-compound",
+    "153": "VERB|l-csubj",
+    "154": "VERB|l-csubj:outer",
+    "155": "VERB|l-nmod",
+    "156": "VERB|l-obj",
+    "157": "VERB|l-obl",
+    "158": "VERB|r-acl",
+    "159": "VERB|r-advcl",
+    "160": "VERB|r-compound",
+    "161": "VERB|root",
+    "162": "X",
+    "163": "X|l-nmod",
+    "164": "X|r-dep"
+  },
+  "initializer_range": 0.02,
+  "label2id": {
+    "ADJ": 0,
+    "ADJ|l-acl": 1,
+    "ADJ|l-advcl": 2,
+    "ADJ|l-amod": 3,
+    "ADJ|l-ccomp": 4,
+    "ADJ|l-csubj": 5,
+    "ADJ|l-csubj:outer": 6,
+    "ADJ|l-nmod": 7,
+    "ADJ|l-nsubj": 8,
+    "ADJ|l-obj": 9,
+    "ADJ|l-obl": 10,
+    "ADJ|r-acl": 11,
+    "ADJ|r-amod": 12,
+    "ADJ|r-dep": 13,
+    "ADJ|root": 14,
+    "ADP": 15,
+    "ADP|l-case": 16,
+    "ADP|r-case": 17,
+    "ADP|r-fixed": 18,
+    "ADV": 19,
+    "ADV|l-advcl": 20,
+    "ADV|l-advmod": 21,
+    "ADV|l-obj": 22,
+    "ADV|r-dep": 23,
+    "ADV|root": 24,
+    "AUX": 25,
+    "AUX|Polarity=Neg": 26,
+    "AUX|Polarity=Neg|r-aux": 27,
+    "AUX|Polarity=Neg|r-fixed": 28,
+    "AUX|r-aux": 29,
+    "AUX|r-cop": 30,
+    "AUX|r-fixed": 31,
+    "AUX|root": 32,
+    "B-ADJ": 33,
+    "B-ADP": 34,
+    "B-ADV": 35,
+    "B-AUX": 36,
+    "B-AUX|Polarity=Neg": 37,
+    "B-CCONJ": 38,
+    "B-DET": 39,
+    "B-INTJ": 40,
+    "B-NOUN": 41,
+    "B-NOUN|Polarity=Neg": 42,
+    "B-NUM": 43,
+    "B-PART": 44,
+    "B-PRON": 45,
+    "B-PROPN": 46,
+    "B-PUNCT": 47,
+    "B-SCONJ": 48,
+    "B-SYM": 49,
+    "B-VERB": 50,
+    "B-X": 51,
+    "CCONJ": 52,
+    "CCONJ|l-cc": 53,
+    "CCONJ|r-cc": 54,
+    "DET": 55,
+    "DET|l-det": 56,
+    "I-ADJ": 57,
+    "I-ADP": 58,
+    "I-ADV": 59,
+    "I-AUX": 60,
+    "I-AUX|Polarity=Neg": 61,
+    "I-CCONJ": 62,
+    "I-DET": 63,
+    "I-INTJ": 64,
+    "I-NOUN": 65,
+    "I-NOUN|Polarity=Neg": 66,
+    "I-NUM": 67,
+    "I-PART": 68,
+    "I-PRON": 69,
+    "I-PROPN": 70,
+    "I-PUNCT": 71,
+    "I-SCONJ": 72,
+    "I-SYM": 73,
+    "I-VERB": 74,
+    "I-X": 75,
+    "INTJ": 76,
+    "INTJ|l-discourse": 77,
+    "INTJ|r-discourse": 78,
+    "INTJ|root": 79,
+    "NOUN": 80,
+    "NOUN|Polarity=Neg": 81,
+    "NOUN|Polarity=Neg|l-obl": 82,
+    "NOUN|Polarity=Neg|root": 83,
+    "NOUN|l-acl": 84,
+    "NOUN|l-advcl": 85,
+    "NOUN|l-ccomp": 86,
+    "NOUN|l-compound": 87,
+    "NOUN|l-csubj": 88,
+    "NOUN|l-csubj:outer": 89,
+    "NOUN|l-nmod": 90,
+    "NOUN|l-nsubj": 91,
+    "NOUN|l-nsubj:outer": 92,
+    "NOUN|l-obj": 93,
+    "NOUN|l-obl": 94,
+    "NOUN|r-compound": 95,
+    "NOUN|r-nmod": 96,
+    "NOUN|r-nsubj": 97,
+    "NOUN|root": 98,
+    "NUM": 99,
+    "NUM|l-advcl": 100,
+    "NUM|l-compound": 101,
+    "NUM|l-nmod": 102,
+    "NUM|l-nsubj": 103,
+    "NUM|l-nsubj:outer": 104,
+    "NUM|l-nummod": 105,
+    "NUM|l-obj": 106,
+    "NUM|l-obl": 107,
+    "NUM|r-compound": 108,
+    "NUM|root": 109,
+    "PART": 110,
+    "PART|l-mark": 111,
+    "PART|r-mark": 112,
+    "PRON": 113,
+    "PRON|l-acl": 114,
+    "PRON|l-advcl": 115,
+    "PRON|l-nmod": 116,
+    "PRON|l-nsubj": 117,
+    "PRON|l-nsubj:outer": 118,
+    "PRON|l-obj": 119,
+    "PRON|l-obl": 120,
+    "PRON|root": 121,
+    "PROPN": 122,
+    "PROPN|l-acl": 123,
+    "PROPN|l-advcl": 124,
+    "PROPN|l-compound": 125,
+    "PROPN|l-nmod": 126,
+    "PROPN|l-nsubj": 127,
+    "PROPN|l-nsubj:outer": 128,
+    "PROPN|l-obj": 129,
+    "PROPN|l-obl": 130,
+    "PROPN|r-compound": 131,
+    "PROPN|r-nmod": 132,
+    "PROPN|root": 133,
+    "PUNCT": 134,
+    "PUNCT|l-punct": 135,
+    "PUNCT|r-punct": 136,
+    "SCONJ": 137,
+    "SCONJ|l-dep": 138,
+    "SCONJ|r-fixed": 139,
+    "SCONJ|r-mark": 140,
+    "SYM": 141,
+    "SYM|l-compound": 142,
+    "SYM|l-dep": 143,
+    "SYM|l-nmod": 144,
+    "SYM|l-obl": 145,
+    "SYM|r-compound": 146,
+    "SYM|r-dep": 147,
+    "VERB": 148,
+    "VERB|l-acl": 149,
+    "VERB|l-advcl": 150,
+    "VERB|l-ccomp": 151,
+    "VERB|l-compound": 152,
+    "VERB|l-csubj": 153,
+    "VERB|l-csubj:outer": 154,
+    "VERB|l-nmod": 155,
+    "VERB|l-obj": 156,
+    "VERB|l-obl": 157,
+    "VERB|r-acl": 158,
+    "VERB|r-advcl": 159,
+    "VERB|r-compound": 160,
+    "VERB|root": 161,
+    "X": 162,
+    "X|l-nmod": 163,
+    "X|r-dep": 164
+  },
+  "layer_norm_epsilon": 1e-05,
+  "model_type": "gpt2",
+  "n_ctx": 1024,
+  "n_embd": 768,
+  "n_head": 12,
+  "n_inner": 3072,
+  "n_layer": 12,
+  "n_positions": 1024,
+  "reorder_and_upcast_attn": false,
+  "resid_pdrop": 0.1,
+  "scale_attn_by_inverse_layer_idx": false,
+  "scale_attn_weights": true,
+  "summary_activation": null,
+  "summary_first_dropout": 0.1,
+  "summary_proj_to_labels": true,
+  "summary_type": "cls_index",
+  "summary_use_proj": true,
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "torch_dtype": "float32",
+  "transformers_version": "4.44.1",
+  "use_cache": true,
+  "vocab_size": 32000
+}

maker.py

@@ -0,0 +1,125 @@
+#! /usr/bin/python3
+src="rinna/japanese-gpt2-small"
+tgt="KoichiYasuoka/rinna-gpt2-small-japanese-ud-causal"
+url="https://github.com/UniversalDependencies/UD_Japanese-GSDLUW"
+
+import os,json
+from transformers import AutoTokenizer,PreTrainedTokenizerFast,AutoConfig,GPT2ForTokenClassification,DefaultDataCollator,TrainingArguments,Trainer
+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")
+tkz=AutoTokenizer.from_pretrained(src,add_prefix_space=False,legacy=False,model_max_length=1024)
+tkz.save_pretrained("tmpdir")
+d=json.loads(tkz.backend_tokenizer.to_str())
+d["normalizer"]["normalizers"].append({"type":"Lowercase"})
+form=set()
+with open("train.conllu","r",encoding="utf-8") as r:
+  for s in r:
+    w=s.split("\t")
+    if len(w)==10 and w[0].isdecimal():
+      form.add(w[1])
+for t in d["model"]["vocab"]:
+  if t[0] not in form:
+    t[1]*=len(t[0])
+tkz.backend_tokenizer.from_str(json.dumps(d)).save("tmpdir/tokenizer.json")
+tkz=PreTrainedTokenizerFast.from_pretrained("tmpdir")
+
+class UDCausalDataset(object):
+  def __init__(self,conllu,tokenizer,embeddings=None):
+    self.conllu=open(conllu,"r",encoding="utf-8")
+    self.tokenizer=tokenizer
+    self.embeddings=embeddings
+    self.max_tokens=3
+    self.seeks=[(0,0)]
+    label=set(["SYM"])
+    dep=set()
+    s=self.conllu.readline()
+    while s!="":
+      if s=="\n":
+        self.seeks.append((self.conllu.tell(),0))
+      else:
+        w=s.split("\t")
+        if len(w)==10:
+          if w[0].isdecimal():
+            p=w[3] if w[5]=="_" else w[3]+"|"+w[5]
+            label.add(p)
+            dep.add(p+("|" if w[6]=="0" else "|l-" if int(w[0])<int(w[6]) else "|r-")+w[7])
+            self.seeks.append((self.seeks[-1][0],int(w[0])))
+            self.max_tokens=max(self.max_tokens,int(w[0])*2+1)
+      s=self.conllu.readline()
+    lid={}
+    for i,l in enumerate(sorted(label)):
+      lid[l],lid["B-"+l],lid["I-"+l]=i*3,i*3+1,i*3+2
+    for i,d in enumerate(sorted(dep),len(lid)):
+      lid[d]=i
+    self.label2id=lid
+  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
+  def __getitem__(self,i):
+    s,t=self.seeks[i]
+    self.conllu.seek(s)
+    form,upos,deps,w=[],[],[],[""]
+    while w[0]!="\n":
+      w=self.conllu.readline().split("\t")
+      if len(w)==10:
+        form.append(w[1])
+        if w[0].isdecimal():
+          upos.append(w[3] if w[5]=="_" else w[3]+"|"+w[5])
+          deps.append((int(w[6]),w[7]))
+    v=self.tokenizer(form,add_special_tokens=False)
+    if t==0:
+      i,u=[],[]
+      for j,(x,y) in enumerate(zip(v["input_ids"],upos)):
+        if x!=[]:
+          i+=x
+          u+=[y] if len(x)==1 else ["B-"+y]+["I-"+y]*(len(x)-1)
+      emb=self.embeddings
+      pad=self.tokenizer.pad_token_id
+    else:
+      import torch
+      m=[]
+      for x in v["input_ids"]:
+        if x==[]:
+          m.append(self.embeddings[self.tokenizer.unk_token_id,:])
+        else:
+          m.append(self.embeddings[x,:].sum(axis=0))
+      m.append(self.embeddings[self.tokenizer.sep_token_id,:])
+      m.append(self.embeddings[self.tokenizer.pad_token_id,:])
+      emb=torch.stack(m)
+      i,u=list(range(len(upos)+1)),upos+["SYM"]
+      i.append(t-1)
+      k,d=deps[t-1]
+      u.append(upos[t-1]+"|"+d if k==0 else upos[t-1])
+      for j in range(t,len(upos)):
+        i.append(j)
+        a,b=deps[j]
+        u.append(upos[j]+"|r-"+b if a==t else upos[t-1]+"|l-"+d if j+1==k else upos[j])
+      pad=-1
+    j=self.max_tokens-len(i)
+    if j>0:
+      ids=i+[pad]*j
+      upos=u+["SYM"]*j
+    else:
+      ids=i[0:self.max_tokens]
+      upos=u[0:self.max_tokens]
+    return {"inputs_embeds":emb[ids,:],"labels":[self.label2id[p] for p in upos]}
+
+trainDS=UDCausalDataset("train.conllu",tkz)
+devDS=UDCausalDataset("dev.conllu",tkz)
+testDS=UDCausalDataset("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)
+mdl=GPT2ForTokenClassification.from_pretrained(src,config=cfg,ignore_mismatched_sizes=True)
+trainDS.embeddings=mdl.get_input_embeddings().weight
+trainDS.max_tokens=min(trainDS.max_tokens,cfg.max_position_embeddings)
+arg=TrainingArguments(num_train_epochs=3,per_device_train_batch_size=32,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)

pytorch_model.bin

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

special_tokens_map.json

@@ -0,0 +1,51 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "[CLS]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "[MASK]",
+    "lstrip": false,
+    "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,76 @@
+{
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "5": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "6": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [],
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "eos_token": "</s>",
+  "extra_ids": 0,
+  "legacy": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 1024,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "unk_token": "<unk>"
+}

ud.py

@@ -0,0 +1,141 @@
+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.startswith("B-") or not (k.startswith("I-") or k.endswith("|root") or k.find("|l-")>0 or k.find("|r-")>0)]
+    self.transition=numpy.full((len(x),len(x)),numpy.nan)
+    for k,v in x.items():
+      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)
+    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.nanmax(m[i]+self.transition,axis=1)
+    k=[numpy.nanargmax(m[0]+self.transition[0])]
+    for i in range(1,m.shape[0]):
+      k.append(numpy.nanargmax(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 UniversalDependenciesCausalPipeline(BellmanFordTokenClassificationPipeline):
+  def __init__(self,**kwargs):
+    kwargs["aggregation_strategy"]="simple"
+    super().__init__(**kwargs)
+    x=self.model.config.label2id
+    self.root=numpy.full((len(x)),numpy.nan)
+    self.left_arc=numpy.full((len(x)),numpy.nan)
+    self.right_arc=numpy.full((len(x)),numpy.nan)
+    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
+    if "logits" not in model_outputs:
+      return self.postprocess(model_outputs[0],**kwargs)
+    m=model_outputs["logits"][0].numpy()
+    for i in range(m.shape[0]-1,0,-1):
+      m[i-1]+=numpy.nanmax(m[i]+self.transition,axis=1)
+    k=[numpy.nanargmax(m[0]+self.transition[0])]
+    for i in range(1,m.shape[0]):
+      k.append(numpy.nanargmax(m[i]+self.transition[k[-1]]))
+    w=[{"entity":self.model.config.id2label[j],"start":s,"end":e} for i,((s,e),j) in enumerate(zip(model_outputs["offset_mapping"][0].tolist(),k)) if s<e]
+    for i,t in reversed(list(enumerate(w))):
+      p=t.pop("entity")
+      if p.startswith("I-"):
+        w[i-1]["end"]=max(w.pop(i)["end"],w[i-1]["end"])
+      elif i>0 and w[i-1]["end"]>w[i]["start"]:
+        w[i-1]["end"]=max(w.pop(i)["end"],w[i-1]["end"])
+      elif p.startswith("B-"):
+        t["entity_group"]=p[2:]
+      else:
+        t["entity_group"]=p
+    d=[model_outputs["sentence"][t["start"]:t["end"]] for t in w]
+    for i in range(len(d)-1,-1,-1):
+      if d[i].startswith(" "):
+        j=len(d[i])-len(d[i].lstrip())
+        d[i]=d[i].lstrip()
+        w[i]["start"]+=j
+      if d[i].endswith(" "):
+        j=len(d[i])-len(d[i].rstrip())
+        d[i]=d[i].rstrip()
+        w[i]["end"]-=j
+      if d[i].strip()=="":
+        d.pop(i)
+        w.pop(i)
+    v=self.tokenizer(d,add_special_tokens=False)
+    e=self.model.get_input_embeddings().weight
+    m=[]
+    for x in v["input_ids"]:
+      if x==[]:
+        x=[self.tokenizer.unk_token_id]
+      m.append(e[x,:].sum(axis=0))
+    m.append(e[self.tokenizer.sep_token_id,:])
+    m.append(e[self.tokenizer.pad_token_id,:])
+    m=torch.stack(m).to(self.device)
+    k=list(range(len(d)+1))
+    e=[]
+    with torch.no_grad():
+      for i in range(len(d)):
+        e.append(self.model(inputs_embeds=torch.unsqueeze(m[k+list(range(i,len(d)))+[-1]*i,:],0)).logits[0,-len(d):,:])
+    e=torch.stack(e).cpu().numpy()
+    for i in range(len(d)):
+      for j in range(i):
+        e[-j-1,-i-1],e[-i-1,-j-1]=e[-i-1,i-j]+self.left_arc,e[-i-1,i-j]+self.right_arc
+      e[-i-1,-i-1]=e[-i-1,0]+self.root
+    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)
+    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,j in enumerate(d):
+      u+="\t".join([str(i+1),j,"_",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(d) and w[i]["end"]<w[i+1]["start"] else "SpaceAfter=No"])+"\n"
+    return u+"\n"
+  def chu_liu_edmonds(self,matrix):
+    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