Fork of MedNER-CR-JA

.gitattributes

@@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+model.safetensors filter=lfs diff=lfs merge=lfs -text

NER_medNLP.py

@@ -0,0 +1,238 @@
+# %%
+
+import itertools
+from tqdm import tqdm
+import numpy as np
+import torch
+from transformers import BertJapaneseTokenizer, BertForTokenClassification
+import pytorch_lightning as pl
+
+# from torch.utils.data import DataLoader
+# import from_XML_to_json as XtC
+# import random
+# import json
+# import unicodedata
+# import pandas as pd
+
+# %%
+# 8-16 
+# PyTorch Lightningのモデル
+class BertForTokenClassification_pl(pl.LightningModule):
+        
+    def __init__(self, model_name, num_labels, lr):
+        super().__init__()
+        self.save_hyperparameters()
+        self.bert_tc = BertForTokenClassification.from_pretrained(
+            model_name,
+            num_labels=num_labels
+        )
+        
+    def training_step(self, batch, batch_idx):
+        output = self.bert_tc(**batch)
+        loss = output.loss
+        self.log('train_loss', loss)
+        return loss
+        
+    def validation_step(self, batch, batch_idx):
+        output = self.bert_tc(**batch)
+        val_loss = output.loss
+        self.log('val_loss', val_loss)
+        
+    def configure_optimizers(self):
+        return torch.optim.Adam(self.parameters(), lr=self.hparams.lr)
+
+
+
+# %%
+class NER_tokenizer_BIO(BertJapaneseTokenizer):
+
+    # 初期化時に固有表現のカテゴリーの数`num_entity_type`を
+    # 受け入れるようにする。
+    def __init__(self, *args, **kwargs):
+        self.num_entity_type = kwargs.pop('num_entity_type')
+        super().__init__(*args, **kwargs)
+
+    def encode_plus_tagged(self, text, entities, max_length):
+        """
+        文章とそれに含まれる固有表現が与えられた時に、
+        符号化とラベル列の作成を行う。
+        """
+        # 固有表現の前後でtextを分割し、それぞれのラベルをつけておく。
+        splitted = [] # 分割後の文字列を追加していく
+        position = 0
+        
+        for entity in entities:
+            start = entity['span'][0]
+            end = entity['span'][1]
+            label = entity['type_id']
+            splitted.append({'text':text[position:start], 'label':0})
+            splitted.append({'text':text[start:end], 'label':label})
+            position = end
+        splitted.append({'text': text[position:], 'label':0})
+        splitted = [ s for s in splitted if s['text'] ]
+
+        # 分割されたそれぞれの文章をトークン化し、ラベルをつける。
+        tokens = [] # トークンを追加していく
+        labels = [] # ラベルを追加していく
+        for s in splitted:
+            tokens_splitted = self.tokenize(s['text'])
+            label = s['label']
+            if label > 0: # 固有表現
+                # まずトークン全てにI-タグを付与
+                # 番号順O-tag:0, B-tag:1~タグの数，I-tag:タグの数〜
+                labels_splitted =  \
+                    [ label + self.num_entity_type ] * len(tokens_splitted)
+                # 先頭のトークンをB-タグにする
+                labels_splitted[0] = label
+            else: # それ以外
+                labels_splitted =  [0] * len(tokens_splitted)
+            
+            tokens.extend(tokens_splitted)
+            labels.extend(labels_splitted)
+
+        # 符号化を行いBERTに入力できる形式にする。
+        input_ids = self.convert_tokens_to_ids(tokens)
+        encoding = self.prepare_for_model(
+            input_ids, 
+            max_length=max_length, 
+            padding='max_length',
+            truncation=True
+        ) 
+
+        # ラベルに特殊トークンを追加
+        # max_lengthで切り取って，その前後に[CLS]と[SEP]を追加するためのラベルを入れる
+        labels = [0] + labels[:max_length-2] + [0]
+        # max_lengthに満たない場合は，満たない分を後ろ側に追加する
+        labels = labels + [0]*( max_length - len(labels) )
+        encoding['labels'] = labels
+
+        return encoding
+
+    def encode_plus_untagged(
+        self, text, max_length=None, return_tensors=None
+    ):
+        """
+        文章をトークン化し、それぞれのトークンの文章中の位置も特定しておく。
+        IO法のトークナイザのencode_plus_untaggedと同じ
+        """
+        # 文章のトークン化を行い、
+        # それぞれのトークンと文章中の文字列を対応づける。
+        tokens = [] # トークンを追加していく。
+        tokens_original = [] # トークンに対応する文章中の文字列を追加していく。
+        words = self.word_tokenizer.tokenize(text) # MeCabで単語に分割
+        for word in words:
+            # 単語をサブワードに分割
+            tokens_word = self.subword_tokenizer.tokenize(word) 
+            tokens.extend(tokens_word)
+            if tokens_word[0] == '[UNK]': # 未知語への対応
+                tokens_original.append(word)
+            else:
+                tokens_original.extend([
+                    token.replace('##','') for token in tokens_word
+                ])
+
+        # 各トークンの文章中での位置を調べる。（空白の位置を考慮する）
+        position = 0
+        spans = [] # トークンの位置を追加していく。
+        for token in tokens_original:
+            l = len(token)
+            while 1:
+                if token != text[position:position+l]:
+                    position += 1
+                else:
+                    spans.append([position, position+l])
+                    position += l
+                    break
+
+        # 符号化を行いBERTに入力できる形式にする。
+        input_ids = self.convert_tokens_to_ids(tokens) 
+        encoding = self.prepare_for_model(
+            input_ids, 
+            max_length=max_length, 
+            padding='max_length' if max_length else False, 
+            truncation=True if max_length else False
+        )
+        sequence_length = len(encoding['input_ids'])
+        # 特殊トークン[CLS]に対するダミーのspanを追加。
+        spans = [[-1, -1]] + spans[:sequence_length-2] 
+        # 特殊トークン[SEP]、[PAD]に対するダミーのspanを追加。
+        spans = spans + [[-1, -1]] * ( sequence_length - len(spans) ) 
+
+        # 必要に応じてtorch.Tensorにする。
+        if return_tensors == 'pt':
+            encoding = { k: torch.tensor([v]) for k, v in encoding.items() }
+
+        return encoding, spans
+
+    @staticmethod
+    def Viterbi(scores_bert, num_entity_type, penalty=10000):
+        """
+        Viterbiアルゴリズムで最適解を求める。
+        """
+        m = 2*num_entity_type + 1
+        penalty_matrix = np.zeros([m, m])
+        for i in range(m):
+            for j in range(1+num_entity_type, m):
+                if not ( (i == j) or (i+num_entity_type == j) ): 
+                    penalty_matrix[i,j] = penalty
+        path = [ [i] for i in range(m) ]
+        scores_path = scores_bert[0] - penalty_matrix[0,:]
+        scores_bert = scores_bert[1:]
+
+        
+
+        for scores in scores_bert:
+            assert len(scores) == 2*num_entity_type + 1
+            score_matrix = np.array(scores_path).reshape(-1,1) \
+                + np.array(scores).reshape(1,-1) \
+                - penalty_matrix
+            scores_path = score_matrix.max(axis=0)
+            argmax = score_matrix.argmax(axis=0)
+            path_new = []
+            for i, idx in enumerate(argmax):
+                path_new.append( path[idx] + [i] )
+            path = path_new
+
+        labels_optimal = path[np.argmax(scores_path)]
+        return labels_optimal
+
+    def convert_bert_output_to_entities(self, text, scores, spans):
+        """
+        文章、分類スコア、各トークンの位置から固有表現を得る。
+        分類スコアはサイズが（系列長、ラベル数）の2次元配列
+        """
+        assert len(spans) == len(scores)
+        num_entity_type = self.num_entity_type
+        
+        # 特殊トークンに対応する部分を取り除く
+        scores = [score for score, span in zip(scores, spans) if span[0]!=-1]
+        spans = [span for span in spans if span[0]!=-1]
+        
+        # Viterbiアルゴリズムでラベルの予測値を決める。
+        labels = self.Viterbi(scores, num_entity_type)
+
+        # 同じラベルが連続するトークンをまとめて、固有表現を抽出する。
+        entities = []
+        for label, group \
+            in itertools.groupby(enumerate(labels), key=lambda x: x[1]):
+            
+            group = list(group)
+            start = spans[group[0][0]][0]
+            end = spans[group[-1][0]][1]
+
+            if label != 0: # 固有表現であれば
+                if 1 <= label <= num_entity_type:
+                     # ラベルが`B-`ならば、新しいentityを追加
+                    entity = {
+                        "name": text[start:end],
+                        "span": [start, end],
+                        "type_id": label
+                    }
+                    entities.append(entity)
+                else:
+                    # ラベルが`I-`ならば、直近のentityを更新
+                    entity['span'][1] = end 
+                    entity['name'] = text[entity['span'][0]:entity['span'][1]]
+                
+        return entities
+

README.md

@@ -1,3 +1,49 @@
 ---
-license: cc-by-4.0
+language: 
+- ja
+license:
+- cc-by-4.0
+tags:
+- NER
+- medical documents
+datasets:
+- MedTxt-CR-JA-training-v2.xml
+metrics:
+- NTCIR-16 Real-MedNLP subtask 1
 ---
+
+
+This is a model for named entity recognition of Japanese medical documents.
+
+### How to use
+
+Download the following five files and put into the same folder.
+- id_to_tags.pkl
+- key_attr.pkl
+- NER_medNLP.py
+- predict.py
+- text.txt (This is an input file which should be predicted, which could be changed.)
+
+You can use this model by running predict.py.
+
+```
+python3 predict.py
+```
+
+### Input Example
+
+```
+肥大型心筋症、心房細動に対してＷＦ投与が開始となった。
+治療経過中に非持続性心室頻拍が認められたためアミオダロンが併用となった。
+```
+
+### Output Example
+
+```
+ <d certainty="positive">肥大型心筋症、心房細動</d>に対して<m-key state="executed">ＷＦ</m-key>投与が開始となった。
+<timex3 type="med">治療経過中</timex3>に<d certainty="positive">非持続性心室頻拍</d>が認められたため<m-key state="executed">アミオダロン</m-key>が併用となった。
+```
+
+### Publication
+
+Tomohiro Nishiyama, Aki Ando, Mihiro Nishidani, Shuntaro Yada, Shoko Wakamiya, Eiji Aramaki: NAISTSOC at the NTCIR-16 Real-MedNLP Task, In Proceedings of the 16th NTCIR Conference on Evaluation of Information Access Technologies (NTCIR-16), pp. 330-333, 2022

config.json

@@ -0,0 +1,189 @@
+{
+  "_name_or_path": "cl-tohoku/bert-base-japanese-whole-word-masking",
+  "architectures": [
+    "BertForTokenClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2",
+    "3": "LABEL_3",
+    "4": "LABEL_4",
+    "5": "LABEL_5",
+    "6": "LABEL_6",
+    "7": "LABEL_7",
+    "8": "LABEL_8",
+    "9": "LABEL_9",
+    "10": "LABEL_10",
+    "11": "LABEL_11",
+    "12": "LABEL_12",
+    "13": "LABEL_13",
+    "14": "LABEL_14",
+    "15": "LABEL_15",
+    "16": "LABEL_16",
+    "17": "LABEL_17",
+    "18": "LABEL_18",
+    "19": "LABEL_19",
+    "20": "LABEL_20",
+    "21": "LABEL_21",
+    "22": "LABEL_22",
+    "23": "LABEL_23",
+    "24": "LABEL_24",
+    "25": "LABEL_25",
+    "26": "LABEL_26",
+    "27": "LABEL_27",
+    "28": "LABEL_28",
+    "29": "LABEL_29",
+    "30": "LABEL_30",
+    "31": "LABEL_31",
+    "32": "LABEL_32",
+    "33": "LABEL_33",
+    "34": "LABEL_34",
+    "35": "LABEL_35",
+    "36": "LABEL_36",
+    "37": "LABEL_37",
+    "38": "LABEL_38",
+    "39": "LABEL_39",
+    "40": "LABEL_40",
+    "41": "LABEL_41",
+    "42": "LABEL_42",
+    "43": "LABEL_43",
+    "44": "LABEL_44",
+    "45": "LABEL_45",
+    "46": "LABEL_46",
+    "47": "LABEL_47",
+    "48": "LABEL_48",
+    "49": "LABEL_49",
+    "50": "LABEL_50",
+    "51": "LABEL_51",
+    "52": "LABEL_52",
+    "53": "LABEL_53",
+    "54": "LABEL_54",
+    "55": "LABEL_55",
+    "56": "LABEL_56",
+    "57": "LABEL_57",
+    "58": "LABEL_58",
+    "59": "LABEL_59",
+    "60": "LABEL_60",
+    "61": "LABEL_61",
+    "62": "LABEL_62",
+    "63": "LABEL_63",
+    "64": "LABEL_64",
+    "65": "LABEL_65",
+    "66": "LABEL_66",
+    "67": "LABEL_67",
+    "68": "LABEL_68",
+    "69": "LABEL_69",
+    "70": "LABEL_70",
+    "71": "LABEL_71",
+    "72": "LABEL_72",
+    "73": "LABEL_73",
+    "74": "LABEL_74",
+    "75": "LABEL_75",
+    "76": "LABEL_76",
+    "77": "LABEL_77",
+    "78": "LABEL_78",
+    "79": "LABEL_79",
+    "80": "LABEL_80"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_10": 10,
+    "LABEL_11": 11,
+    "LABEL_12": 12,
+    "LABEL_13": 13,
+    "LABEL_14": 14,
+    "LABEL_15": 15,
+    "LABEL_16": 16,
+    "LABEL_17": 17,
+    "LABEL_18": 18,
+    "LABEL_19": 19,
+    "LABEL_2": 2,
+    "LABEL_20": 20,
+    "LABEL_21": 21,
+    "LABEL_22": 22,
+    "LABEL_23": 23,
+    "LABEL_24": 24,
+    "LABEL_25": 25,
+    "LABEL_26": 26,
+    "LABEL_27": 27,
+    "LABEL_28": 28,
+    "LABEL_29": 29,
+    "LABEL_3": 3,
+    "LABEL_30": 30,
+    "LABEL_31": 31,
+    "LABEL_32": 32,
+    "LABEL_33": 33,
+    "LABEL_34": 34,
+    "LABEL_35": 35,
+    "LABEL_36": 36,
+    "LABEL_37": 37,
+    "LABEL_38": 38,
+    "LABEL_39": 39,
+    "LABEL_4": 4,
+    "LABEL_40": 40,
+    "LABEL_41": 41,
+    "LABEL_42": 42,
+    "LABEL_43": 43,
+    "LABEL_44": 44,
+    "LABEL_45": 45,
+    "LABEL_46": 46,
+    "LABEL_47": 47,
+    "LABEL_48": 48,
+    "LABEL_49": 49,
+    "LABEL_5": 5,
+    "LABEL_50": 50,
+    "LABEL_51": 51,
+    "LABEL_52": 52,
+    "LABEL_53": 53,
+    "LABEL_54": 54,
+    "LABEL_55": 55,
+    "LABEL_56": 56,
+    "LABEL_57": 57,
+    "LABEL_58": 58,
+    "LABEL_59": 59,
+    "LABEL_6": 6,
+    "LABEL_60": 60,
+    "LABEL_61": 61,
+    "LABEL_62": 62,
+    "LABEL_63": 63,
+    "LABEL_64": 64,
+    "LABEL_65": 65,
+    "LABEL_66": 66,
+    "LABEL_67": 67,
+    "LABEL_68": 68,
+    "LABEL_69": 69,
+    "LABEL_7": 7,
+    "LABEL_70": 70,
+    "LABEL_71": 71,
+    "LABEL_72": 72,
+    "LABEL_73": 73,
+    "LABEL_74": 74,
+    "LABEL_75": 75,
+    "LABEL_76": 76,
+    "LABEL_77": 77,
+    "LABEL_78": 78,
+    "LABEL_79": 79,
+    "LABEL_8": 8,
+    "LABEL_80": 80,
+    "LABEL_9": 9
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "tokenizer_class": "BertJapaneseTokenizer",
+  "type_vocab_size": 2,
+  "vocab_size": 32000
+}

id_to_tags.pkl

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

key_attr.pkl

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

model.safetensors

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

predict.py

@@ -0,0 +1,143 @@
+
+# %%
+from tqdm import tqdm
+import unicodedata
+import re
+import pickle
+import torch
+import NER_medNLP as ner
+from bs4 import BeautifulSoup
+
+
+# import from_XML_to_json as XtC
+# import itertools
+# import random
+# import json
+# from torch.utils.data import DataLoader
+# from transformers import BertJapaneseTokenizer, BertForTokenClassification
+# import pytorch_lightning as pl
+# import pandas as pd
+# import numpy as np
+# import codecs
+device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+
+#%% global変数として使う
+dict_key = {}
+
+#%%
+def to_xml(data):
+    with open("key_attr.pkl", "rb") as tf:
+        key_attr = pickle.load(tf)
+    
+    text = data['text']
+    count = 0
+    for i, entities in enumerate(data['entities_predicted']):
+        if entities == "":
+            return   
+        span = entities['span']
+        type_id = id_to_tags[entities['type_id']].split('_')
+        tag = type_id[0]
+        
+        if not type_id[1] == "":
+            attr = ' ' + value_to_key(type_id[1], key_attr) +  '=' + '"' + type_id[1] + '"'
+        else:
+            attr = ""
+        
+        add_tag = "<" + str(tag) + str(attr) + ">"
+        text = text[:span[0]+count] + add_tag + text[span[0]+count:]
+        count += len(add_tag)
+
+        add_tag = "</" + str(tag) + ">"
+        text = text[:span[1]+count] + add_tag + text[span[1]+count:]
+        count += len(add_tag)
+    return text
+
+
+def predict_entities(modelpath, sentences_list, len_num_entity_type):
+    # model = ner.BertForTokenClassification_pl.load_from_checkpoint(
+    #     checkpoint_path = modelpath + ".ckpt"
+    # ) 
+    # bert_tc = model.bert_tc.cuda()
+    
+    model = ner.BertForTokenClassification_pl(modelpath, num_labels=81, lr=1e-5) 
+    bert_tc = model.bert_tc.to(device)
+
+    MODEL_NAME = 'cl-tohoku/bert-base-japanese-whole-word-masking'
+    tokenizer = ner.NER_tokenizer_BIO.from_pretrained(
+        MODEL_NAME,
+        num_entity_type =  len_num_entity_type#Entityの数を変え忘れないように！
+    )
+
+    #entities_list = [] # 正解の固有表現を追加していく
+    entities_predicted_list = [] # 抽出された固有表現を追加していく
+
+    text_entities_set = []
+    for dataset in sentences_list:
+        text_entities = []
+        for sample in tqdm(dataset):
+            text = sample
+            encoding, spans = tokenizer.encode_plus_untagged(
+                text, return_tensors='pt'
+            )
+            encoding = { k: v.to(device) for k, v in encoding.items() } 
+            
+            with torch.no_grad():
+                output = bert_tc(**encoding)
+                scores = output.logits
+                scores = scores[0].cpu().numpy().tolist()
+                
+            # 分類スコアを固有表現に変換する
+            entities_predicted = tokenizer.convert_bert_output_to_entities(
+                text, scores, spans
+            )
+
+            #entities_list.append(sample['entities'])
+            entities_predicted_list.append(entities_predicted)
+            text_entities.append({'text': text, 'entities_predicted': entities_predicted})
+        text_entities_set.append(text_entities)
+    return text_entities_set
+
+def combine_sentences(text_entities_set, insert: str):
+    documents = []
+    for text_entities in tqdm(text_entities_set):
+        document = []
+        for t in text_entities:
+            document.append(to_xml(t))
+        documents.append('\n'.join(document))
+    return documents
+
+def value_to_key(value, key_attr):#attributeから属性名を取得
+    global dict_key
+    if dict_key.get(value) != None:
+        return dict_key[value]
+    for k in key_attr.keys():
+        for v in key_attr[k]:
+            if value == v:
+                dict_key[v]=k
+                return k
+
+# %%
+if __name__ == '__main__':
+    with open("id_to_tags.pkl", "rb") as tf:
+        id_to_tags = pickle.load(tf)
+    with open("key_attr.pkl", "rb") as tf:
+        key_attr = pickle.load(tf)
+    with open('text.txt') as f:
+        articles_raw = f.read()
+        
+
+    article_norm = unicodedata.normalize('NFKC', articles_raw)
+
+    sentences_raw = [s for s in re.split(r'\n', articles_raw) if s != '']
+    sentences_norm = [s for s in re.split(r'\n', article_norm) if s != '']
+
+    text_entities_set = predict_entities("sociocom/RealMedNLP_CR_JA", [sentences_norm], len(id_to_tags))
+
+
+    for i, texts_ent in enumerate(text_entities_set[0]):
+        texts_ent['text'] = sentences_raw[i]
+
+
+    documents = combine_sentences(text_entities_set, '\n')
+
+    print(documents[0])

pytorch_model.bin

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

text.txt

@@ -0,0 +1,15 @@
+
+【目的】ワルファリン（ＷＦ）は血栓予防を目的に汎用されるが、その効果は個人差が大きく、また併用薬との相互作用により投与量設定に苦慮する場合が多い。
+ 我々はＷＦの適正使用を目的に血中濃度測定を行い、相互作用に関する情報の収集を行っている。
+ 本発表ではＷＦとベンズブロマロン、アミオダロンの併用例について抗凝固能をモニターし、同時にＷＦ血中濃度測定を行い、それに基づいた相互作用の発現機序について考察した。
+ 【方法】ＷＦ血中濃度は高速液体クロマトグラフィーにて測定を行い、採血時間は朝服用前とした。
+ 【症例】《症例１》７０歳女性。
+ 脳梗塞、左房内血栓に対してＷＦ投与開始となった。
+ 後遺症としての痙攣発作に対してカルバマゼピン、またＷＦ増量調節中に尿酸値が高めであったことからベンズブロマロンも併用となった。
+ 《症例２》６３歳男性。
+ 肥大型心筋症、心房細動に対してＷＦ投与が開始となった。
+治療経過中に非持続性心室頻拍が認められたためアミオダロンが併用となった。
+ 【結果・考察】いずれの症例においても、併用により血中濃度および抗凝固能に著明な変動が認められた。
+ 症例１では特にＳ体ＷＦの血中濃度変動が著明であるのに対し、症例２では立体選択的な挙動は認められず、相互作用の発現機序がなると考えられた。
+ 前者の相互作用はチトクロムＰ４５０（ＣＹＰ）２Ｃ９を介した相互作用であり、多型との関連が注目される。
+ 日常臨床ではＷＦを介した相互作用の頻度は高いと予想され、血中濃度測定と抗凝固能の変動に留意する必要がある。