initial release

README.md

@@ -0,0 +1,32 @@
+---
+language:
+- "ja"
+tags:
+- "japanese"
+- "token-classification"
+- "pos"
+base_model: nlp-waseda/gpt2-small-japanese
+datasets:
+- "universal_dependencies"
+license: "cc-by-sa-4.0"
+pipeline_tag: "token-classification"
+widget:
+- text: "国境の長いトンネルを抜けると雪国であった。"
+---
+
+# gpt2-small-japanese-juman-upos
+
+## Model Description
+
+This is a GPT-2 model for POS-tagging, derived from [gpt2-small-japanese](https://huggingface.co/nlp-waseda/gpt2-small-japanese). Every word is tagged by [UPOS](https://universaldependencies.org/u/pos/) (Universal Part-Of-Speech) and [FEATS](https://universaldependencies.org/u/feat/).
+
+## How to Use
+
+```py
+from transformers import pipeline
+nlp=pipeline("upos","KoichiYasuoka/gpt2-small-japanese-juman-upos",trust_remote_code=True,aggregation_strategy="simple")
+print(nlp("国境の長いトンネルを抜けると雪国であった。"))
+```
+
+[fugashi](https://pypi.org/project/fugashi) is required.
+

config.json

@@ -0,0 +1,162 @@
+{
+  "activation_function": "gelu_new",
+  "architectures": [
+    "GPT2ForTokenClassification"
+  ],
+  "attn_pdrop": 0.1,
+  "bos_token_id": 2,
+  "custom_pipelines": {
+    "upos": {
+      "impl": "upos.BellmanFordTokenClassificationPipeline",
+      "pt": "AutoModelForTokenClassification"
+    }
+  },
+  "embd_pdrop": 0.1,
+  "eos_token_id": 2,
+  "id2label": {
+    "0": "ADJ",
+    "1": "B-ADJ",
+    "2": "I-ADJ",
+    "3": "ADJ|Polarity=Neg",
+    "4": "B-ADJ|Polarity=Neg",
+    "5": "I-ADJ|Polarity=Neg",
+    "6": "ADP",
+    "7": "B-ADP",
+    "8": "I-ADP",
+    "9": "ADV",
+    "10": "B-ADV",
+    "11": "I-ADV",
+    "12": "AUX",
+    "13": "B-AUX",
+    "14": "I-AUX",
+    "15": "AUX|Polarity=Neg",
+    "16": "B-AUX|Polarity=Neg",
+    "17": "I-AUX|Polarity=Neg",
+    "18": "CCONJ",
+    "19": "B-CCONJ",
+    "20": "I-CCONJ",
+    "21": "DET",
+    "22": "B-DET",
+    "23": "I-DET",
+    "24": "INTJ",
+    "25": "B-INTJ",
+    "26": "I-INTJ",
+    "27": "NOUN",
+    "28": "B-NOUN",
+    "29": "I-NOUN",
+    "30": "NOUN|Polarity=Neg",
+    "31": "B-NOUN|Polarity=Neg",
+    "32": "I-NOUN|Polarity=Neg",
+    "33": "NUM",
+    "34": "B-NUM",
+    "35": "I-NUM",
+    "36": "PART",
+    "37": "B-PART",
+    "38": "I-PART",
+    "39": "PRON",
+    "40": "B-PRON",
+    "41": "I-PRON",
+    "42": "PROPN",
+    "43": "B-PROPN",
+    "44": "I-PROPN",
+    "45": "PUNCT",
+    "46": "B-PUNCT",
+    "47": "I-PUNCT",
+    "48": "SCONJ",
+    "49": "B-SCONJ",
+    "50": "I-SCONJ",
+    "51": "SYM",
+    "52": "B-SYM",
+    "53": "I-SYM",
+    "54": "VERB",
+    "55": "B-VERB",
+    "56": "I-VERB",
+    "57": "X",
+    "58": "B-X",
+    "59": "I-X"
+  },
+  "initializer_range": 0.02,
+  "label2id": {
+    "ADJ": 0,
+    "ADJ|Polarity=Neg": 3,
+    "ADP": 6,
+    "ADV": 9,
+    "AUX": 12,
+    "AUX|Polarity=Neg": 15,
+    "B-ADJ": 1,
+    "B-ADJ|Polarity=Neg": 4,
+    "B-ADP": 7,
+    "B-ADV": 10,
+    "B-AUX": 13,
+    "B-AUX|Polarity=Neg": 16,
+    "B-CCONJ": 19,
+    "B-DET": 22,
+    "B-INTJ": 25,
+    "B-NOUN": 28,
+    "B-NOUN|Polarity=Neg": 31,
+    "B-NUM": 34,
+    "B-PART": 37,
+    "B-PRON": 40,
+    "B-PROPN": 43,
+    "B-PUNCT": 46,
+    "B-SCONJ": 49,
+    "B-SYM": 52,
+    "B-VERB": 55,
+    "B-X": 58,
+    "CCONJ": 18,
+    "DET": 21,
+    "I-ADJ": 2,
+    "I-ADJ|Polarity=Neg": 5,
+    "I-ADP": 8,
+    "I-ADV": 11,
+    "I-AUX": 14,
+    "I-AUX|Polarity=Neg": 17,
+    "I-CCONJ": 20,
+    "I-DET": 23,
+    "I-INTJ": 26,
+    "I-NOUN": 29,
+    "I-NOUN|Polarity=Neg": 32,
+    "I-NUM": 35,
+    "I-PART": 38,
+    "I-PRON": 41,
+    "I-PROPN": 44,
+    "I-PUNCT": 47,
+    "I-SCONJ": 50,
+    "I-SYM": 53,
+    "I-VERB": 56,
+    "I-X": 59,
+    "INTJ": 24,
+    "NOUN": 27,
+    "NOUN|Polarity=Neg": 30,
+    "NUM": 33,
+    "PART": 36,
+    "PRON": 39,
+    "PROPN": 42,
+    "PUNCT": 45,
+    "SCONJ": 48,
+    "SYM": 51,
+    "VERB": 54,
+    "X": 57
+  },
+  "layer_norm_epsilon": 1e-05,
+  "model_type": "gpt2",
+  "n_embd": 768,
+  "n_head": 12,
+  "n_inner": null,
+  "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": "JumanReformerTokenizerFast",
+  "torch_dtype": "float32",
+  "transformers_version": "4.44.0",
+  "use_cache": true,
+  "vocab_size": 32000
+}

juman.py

@@ -0,0 +1,49 @@
+import os
+from transformers import ReformerTokenizerFast
+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 MecabPreTokenizer(MecabTokenizer):
+  def mecab_split(self,i,normalized_string):
+    t=str(normalized_string)
+    z=[]
+    e=0
+    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 JumanReformerTokenizerFast(ReformerTokenizerFast):
+  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":[None,"juman.JumanReformerTokenizerFast"]}
+    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,"juman.py"))
+    shutil.copy(cached_file(self.name_or_path,"mecab-jumandic-utf8.zip"),os.path.join(save_directory,"mecab-jumandic-utf8.zip"))
+

maker.py

@@ -0,0 +1,68 @@
+#! /usr/bin/python3
+src="nlp-waseda/gpt2-small-japanese"
+tgt="KoichiYasuoka/gpt2-small-japanese-juman-upos"
+
+import os
+from transformers import AutoTokenizer,AutoConfig,GPT2ForTokenClassification,DataCollatorForTokenClassification,TrainingArguments,Trainer
+os.system("test -f ja_gsd_modern.conllu || curl -LO https://github.com/KoichiYasuoka/SuPar-UniDic/raw/main/suparunidic/suparmodels/ja_gsd_modern.conllu")
+
+class UPOSFileDataset(object):
+  def __init__(self,conllu,tokenizer):
+    self.conllu=open(conllu,"r",encoding="utf-8")
+    self.tokenizer=tokenizer
+    self.seeks=[0]
+    label=set(["SYM"])
+    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():
+            label.add(w[3] if w[5]=="_" else w[3]+"|"+w[5])
+      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
+    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):
+    self.conllu.seek(self.seeks[i])
+    form,upos=[],[]
+    while self.conllu.tell()<self.seeks[i+1]:
+      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])
+    v=self.tokenizer(form,add_special_tokens=False)
+    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)
+    if len(i)<self.tokenizer.model_max_length-3:
+      ids=i
+      upos=u
+    else:
+      ids=i[0:self.tokenizer.model_max_length-2]
+      upos=u[0:self.tokenizer.model_max_length-2]
+    return {"input_ids":ids,"labels":[self.label2id[t] for t in upos]}
+
+tkz=AutoTokenizer.from_pretrained(src,cls_token="<s>",sep_token="<s>",mask_token="<unk>",pad_token="</s>",model_max_length=1024)
+trainDS=UPOSFileDataset("ja_gsd_modern.conllu",tkz)
+lid=trainDS.label2id
+cfg=AutoConfig.from_pretrained(src,num_labels=len(lid),label2id=lid,id2label={i:l for l,i in lid.items()},ignore_mismatched_sizes=True)
+arg=TrainingArguments(num_train_epochs=3,per_device_train_batch_size=16,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=GPT2ForTokenClassification.from_pretrained(src,config=cfg,ignore_mismatched_sizes=True),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:7209e84b760fd1c174490caebdd8d4da3086c8d522c3efff4814dda70eba8873
+size 441907170

special_tokens_map.json

@@ -0,0 +1,32 @@
+{
+  "cls_token": "<s>",
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": "<s>",
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

spiece.model

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

tokenizer_config.json

@@ -0,0 +1,40 @@
+{
+  "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
+    }
+  },
+  "additional_special_tokens": [],
+  "auto_map": {"AutoTokenizer":[null,"juman.JumanReformerTokenizerFast"]},
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "mask_token": "<unk>",
+  "model_max_length": 1024,
+  "pad_token": "</s>",
+  "sep_token": "<s>",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "JumanReformerTokenizerFast",
+  "unk_token": "<unk>"
+}

upos.py

@@ -0,0 +1,41 @@
+from transformers import TokenClassificationPipeline
+
+class BellmanFordTokenClassificationPipeline(TokenClassificationPipeline):
+  def __init__(self,**kwargs):
+    import numpy
+    super().__init__(**kwargs)
+    x=self.model.config.label2id
+    y=[k for k in x if not k.startswith("I-")]
+    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):
+    import numpy
+    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
+