initial release

README.md

@@ -0,0 +1,33 @@
+---
+language:
+- "lzh"
+tags:
+- "classical chinese"
+- "literary chinese"
+- "ancient chinese"
+- "token-classification"
+- "pos"
+- "dependency-parsing"
+base_model: KoichiYasuoka/modernbert-large-classical-chinese
+datasets:
+- "universal_dependencies"
+license: "apache-2.0"
+pipeline_tag: "token-classification"
+widget:
+- text: "孟子見梁惠王"
+---
+
+# modernbert-large-classical-chinese-ud-triangular
+
+## Model Description
+
+This is a ModernBERT model pretrained on Classical Chinese texts for POS-tagging and dependency-parsing (using `goeswith` for subwords), derived from [modernbert-large-classical-chinese](https://huggingface.co/KoichiYasuoka/modernbert-large-classical-chinese) and [UD_Classical_Chinese-Kyoto](https://github.com/UniversalDependencies/UD_Classical_Chinese-Kyoto).
+
+## How to Use
+
+```py
+from transformers import pipeline
+nlp=pipeline("universal-dependencies","KoichiYasuoka/modernbert-large-classical-chinese-ud-triangular",trust_remote_code=True,aggregation_strategy="simple")
+print(nlp("孟子見梁惠王"))
+```
+

maker.py

@@ -0,0 +1,99 @@
+#! /usr/bin/python3
+src="KoichiYasuoka/modernbert-large-classical-chinese"
+tgt="KoichiYasuoka/modernbert-large-classical-chinese-ud-triangular"
+url="https://github.com/UniversalDependencies/UD_Classical_Chinese-Kyoto"
+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 UDTriangularDataset(object):
+  def __init__(self,conllu,tokenizer):
+    self.conllu=open(conllu,"r",encoding="utf-8")
+    self.tokenizer=tokenizer
+    self.seeks=[0]
+    label=set(["SYM|x","X|x"])
+    dep=set(["X|x|r-goeswith"])
+    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]
+            label.add(p+"|o"+q)
+            label.add(p+"|x"+q)
+            dep.add(p+"|o"+q+d)
+            dep.add(p+"|x"+q+d)
+      s=self.conllu.readline()
+    lid={l:i for i,l in enumerate(sorted(label))}
+    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=self.seeks[i]
+    self.conllu.seek(s)
+    c,t=[],[""]
+    while t[0]!="\n":
+      t=self.conllu.readline().split("\t") 
+      if len(t)==10 and t[0].isdecimal():
+        c.append(t)
+    v=self.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)]
+    x=["o" if k>i or sum([1 if j==i+1 else 0 for j in h[i+1:]])>0 else "x" for i,k in enumerate(h)]
+    p=[t[3]+"|"+x[i] if t[5]=="_" else t[3]+"|"+x[i]+"|"+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]
+    v=sum(v,[])
+    ids=[self.tokenizer.cls_token_id]
+    upos=["SYM|x"]
+    for i,k in enumerate(v):
+      if len(v)<127 or x[i]=="o":
+        ids.append(k)
+        upos.append(p[i]+"|"+d[i] if h[i]==i+1 else p[i])
+        for j in range(i+1,len(v)):
+          ids.append(v[j])
+          upos.append(p[j]+"|"+d[j] if h[j]==i+1 else p[i]+"|"+d[i] if h[i]==j+1 else p[j])
+        ids.append(self.tokenizer.sep_token_id)
+        upos.append("SYM|x")
+    i=0
+    while len(ids)>8192:
+      try:
+        i=ids.index(self.tokenizer.sep_token_id,ids.index(self.tokenizer.sep_token_id,i+1)+1)-1
+      except:
+        break
+      while len(ids)>8192 and ids[i]!=self.tokenizer.sep_token_id:
+        if upos[i].endswith("|x"):
+          ids.pop(i)
+          upos.pop(i)
+          i-=1
+        else:
+          break
+    return {"input_ids":ids[:8192],"labels":[self.label2id[p] for p in upos[:8192]]}
+from transformers import AutoTokenizer,AutoConfig,AutoModelForTokenClassification,DataCollatorForTokenClassification,TrainingArguments,Trainer
+tkz=AutoTokenizer.from_pretrained(src)
+trainDS=UDTriangularDataset("train.conllu",tkz)
+devDS=UDTriangularDataset("dev.conllu",tkz)
+testDS=UDTriangularDataset("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)
+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=DataCollatorForTokenClassification(tkz),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:bb8e8df139fa73232c28276261dbe9972cb560002cbff876a414c0a849dc04b9
+size 1485600194

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": 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,68 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": false,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 1000000000000000019884624838656,
+  "never_split": [
+    "[CLS]",
+    "[PAD]",
+    "[SEP]",
+    "[UNK]",
+    "[MASK]"
+  ],
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": false,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizerFast",
+  "unk_token": "[UNK]"
+}

ud.py

@@ -0,0 +1,121 @@
+import numpy
+from transformers import TokenClassificationPipeline
+
+class UniversalDependenciesPipeline(TokenClassificationPipeline):
+  def __init__(self,**kwargs):
+    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 check_model_type(self,supported_models):
+    pass
+  def postprocess(self,model_outputs,**kwargs):
+    import torch
+    if "logits" not in model_outputs:
+      return "".join(self.postprocess(x,**kwargs) for x in model_outputs)
+    m=model_outputs["logits"][0].cpu().numpy()
+    k=numpy.argmax(m,axis=1).tolist()
+    x=[self.model.config.id2label[i].split("|")[1]=="o" for i in k[1:-1]]
+    v=model_outputs["input_ids"][0].tolist()
+    off=model_outputs["offset_mapping"][0].tolist()
+    for i,(s,e) in reversed(list(enumerate(off))):
+      if s<e:
+        d=model_outputs["sentence"][s:e]
+        j=len(d)-len(d.lstrip())
+        if j>0:
+          d=d.lstrip()
+          off[i][0]+=j
+        j=len(d)-len(d.rstrip())
+        if j>0:
+          d=d.rstrip()
+          off[i][1]-=j
+        if d.strip()=="":
+          off.pop(i)
+          v.pop(i)
+          x.pop(i-1)
+    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 numpy.argsort(numpy.max(m,axis=1)[1:-1]):
+        if x[i]==False and w+len(x)-i<8192:
+          x[i]=True
+          w+=len(x)-i+1
+    w=[self.tokenizer.cls_token_id]
+    for i,j in enumerate(x):
+      if j:
+        w+=v[i+1:]
+    with torch.no_grad():
+      e=self.model(input_ids=torch.tensor([w]).to(self.device))
+    m=e.logits[0].cpu().numpy()
+    w=len(v)-2
+    e=numpy.full((w,w,m.shape[-1]),m.min())
+    k=1
+    for i in range(w):
+      if x[i]:
+        e[i,i]=m[k]+self.root
+        k+=1
+        for j in range(1,w-i):
+          e[i+j,i]=m[k]+self.left_arc
+          e[i,i+j]=m[k]+self.right_arc
+          k+=1
+        k+=1
+    g=self.model.config.label2id["X|x|r-goeswith"]
+    m,r=numpy.max(e,axis=2),numpy.tri(e.shape[0])
+    for i in range(e.shape[0]):
+      for j in range(i+2,e.shape[1]):
+        r[i,j]=1
+        if numpy.argmax(e[i,j-1])==g and numpy.argmax(m[:,j-1])==i:
+          r[i,j]=r[i,j-1]
+    e[:,:,g]+=numpy.where(r==0,0,-numpy.inf)
+    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)
+    v=[(s,e) for s,e in off 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]=="r-goeswith" and set([t[-1] for t in q[h[i]+1:i+1]])=={"r-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)
+        elif v[i-1][1]>v[i][0]:
+          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],t[s:e],q[i][0],"_","_" if len(q[i])<4 else "|".join(q[i][2:-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(v) and e<v[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