Skip to content

ner

knowledge_graph.clinical.ner

Zero-shot clinical NER: one of five released models on all 100 notes under the six input conditions.

python -m knowledge_graph.clinical.ner --model gliner_relex # writes zero_shot_ner/gliner_relex.json

PhenoBERT

Source code in src/knowledge_graph/clinical/ner.py
18
19
20
21
22
23
24
25
26
27
28
class PhenoBERT:
    def __init__(self):
        from knowledge_graph.clinical.phenobert import PhenoBERTBackend

        self.api = PhenoBERTBackend()

    def predict(self, document, segments):
        from knowledge_graph.clinical.phenobert import parse_predictions

        return [row for segment in segments
                for row in parse_predictions(self.api.annotate_text(segment["text"]), segment, document["text"])]

api = PhenoBERTBackend() instance-attribute

predict(document, segments)

Source code in src/knowledge_graph/clinical/ner.py
24
25
26
27
28
def predict(self, document, segments):
    from knowledge_graph.clinical.phenobert import parse_predictions

    return [row for segment in segments
            for row in parse_predictions(self.api.annotate_text(segment["text"]), segment, document["text"])]

FastHPOCR

Source code in src/knowledge_graph/clinical/ner.py
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class FastHPOCR:
    def __init__(self):
        from FastHPOCR.HPOAnnotator import HPOAnnotator

        self.annotator = HPOAnnotator(str(HPO_OBO.with_name("hp.index")))

    def predict(self, document, segments):
        rows = []
        for segment in segments:
            for annotation in self.annotator.annotate(segment["text"], longestMatch=False):
                begin = segment["begin"] + int(annotation.getStartOffset())
                end = segment["begin"] + int(annotation.getEndOffset())
                rows.append({"begin": begin, "end": end, "text": document["text"][begin:end],
                             "hpo_label": str(annotation.getHPOLabel()), "concept_id": str(annotation.getHPOUri()),
                             "segment_id": segment["segment_id"]})
        return rows

annotator = HPOAnnotator(str(HPO_OBO.with_name('hp.index'))) instance-attribute

predict(document, segments)

Source code in src/knowledge_graph/clinical/ner.py
37
38
39
40
41
42
43
44
45
46
def predict(self, document, segments):
    rows = []
    for segment in segments:
        for annotation in self.annotator.annotate(segment["text"], longestMatch=False):
            begin = segment["begin"] + int(annotation.getStartOffset())
            end = segment["begin"] + int(annotation.getEndOffset())
            rows.append({"begin": begin, "end": end, "text": document["text"][begin:end],
                         "hpo_label": str(annotation.getHPOLabel()), "concept_id": str(annotation.getHPOUri()),
                         "segment_id": segment["segment_id"]})
    return rows

GLiNER

Source code in src/knowledge_graph/clinical/ner.py
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class GLiNER:
    def __init__(self):
        from gliner import GLiNER
        from knowledge_graph.clinical.gliner_relex import RELEX

        self.model = GLiNER.from_pretrained(RELEX).to("cuda")

    def predict(self, document, segments):
        from knowledge_graph.clinical.gliner_relex import THRESHOLD

        batches = self.model.batch_predict_entities([segment["text"] for segment in segments], list(ENTITY_PROMPTS),
                                                    flat_ner=False, threshold=THRESHOLD, batch_size=BATCH_SIZE,
                                                    return_relations=False)
        rows = []
        for segment, predictions in zip(segments, batches):
            for prediction in predictions:
                begin, end = segment["begin"] + int(prediction["start"]), segment["begin"] + int(prediction["end"])
                rows.append({"begin": begin, "end": end, "text": document["text"][begin:end],
                             "native_label": prediction["label"], "score": float(prediction["score"]),
                             "segment_id": segment["segment_id"]})
        return rows

model = GLiNER.from_pretrained(RELEX).to('cuda') instance-attribute

predict(document, segments)

Source code in src/knowledge_graph/clinical/ner.py
56
57
58
59
60
61
62
63
64
65
66
67
68
69
def predict(self, document, segments):
    from knowledge_graph.clinical.gliner_relex import THRESHOLD

    batches = self.model.batch_predict_entities([segment["text"] for segment in segments], list(ENTITY_PROMPTS),
                                                flat_ner=False, threshold=THRESHOLD, batch_size=BATCH_SIZE,
                                                return_relations=False)
    rows = []
    for segment, predictions in zip(segments, batches):
        for prediction in predictions:
            begin, end = segment["begin"] + int(prediction["start"]), segment["begin"] + int(prediction["end"])
            rows.append({"begin": begin, "end": end, "text": document["text"][begin:end],
                         "native_label": prediction["label"], "score": float(prediction["score"]),
                         "segment_id": segment["segment_id"]})
    return rows

hunflair_entities(sentence, text, offset)

Disease and Chemical mentions with document offsets.

Source code in src/knowledge_graph/clinical/ner.py
72
73
74
75
76
77
78
79
80
81
def hunflair_entities(sentence, text, offset):
    """Disease and Chemical mentions with document offsets."""
    rows = []
    for label in sentence.get_labels():
        if label.value in {"Disease", "Chemical"}:
            begin = offset + int(label.data_point.start_position)
            end = offset + int(label.data_point.end_position)
            rows.append({"begin": begin, "end": end, "text": text[begin:end], "native_label": label.value,
                         "score": float(label.score)})
    return rows

HunFlair2

Source code in src/knowledge_graph/clinical/ner.py
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
class HunFlair2:
    def __init__(self):
        import flair
        import torch
        from flair.nn import Classifier

        flair.device = torch.device("cuda")
        self.model = Classifier.load("hunflair2")

    def predict(self, document, segments):
        from flair.data import Sentence

        sentences = [Sentence(segment["text"]) for segment in segments]
        self.model.predict(sentences, mini_batch_size=BATCH_SIZE, verbose=False)
        return [{**row, "segment_id": segment["segment_id"]}
                for segment, sentence in zip(segments, sentences)
                for row in hunflair_entities(sentence, document["text"], segment["begin"])]

model = Classifier.load('hunflair2') instance-attribute

predict(document, segments)

Source code in src/knowledge_graph/clinical/ner.py
 93
 94
 95
 96
 97
 98
 99
100
def predict(self, document, segments):
    from flair.data import Sentence

    sentences = [Sentence(segment["text"]) for segment in segments]
    self.model.predict(sentences, mini_batch_size=BATCH_SIZE, verbose=False)
    return [{**row, "segment_id": segment["segment_id"]}
            for segment, sentence in zip(segments, sentences)
            for row in hunflair_entities(sentence, document["text"], segment["begin"])]

MedCAT

Source code in src/knowledge_graph/clinical/ner.py
103
104
105
106
107
108
109
110
111
112
class MedCAT:
    def __init__(self):
        from knowledge_graph.clinical.medcat import PACK, load_pack

        self.cat = load_pack(PACK)

    def predict(self, document, segments):
        from knowledge_graph.clinical.medcat import clinical_entities

        return [row for segment in segments for row in clinical_entities(self.cat, segment)]

cat = load_pack(PACK) instance-attribute

predict(document, segments)

Source code in src/knowledge_graph/clinical/ner.py
109
110
111
112
def predict(self, document, segments):
    from knowledge_graph.clinical.medcat import clinical_entities

    return [row for segment in segments for row in clinical_entities(self.cat, segment)]

main()

Source code in src/knowledge_graph/clinical/ner.py
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
def main():
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--model", choices=PREDICTORS, required=True)
    parser.add_argument("--out-dir", type=Path, default=CLINICAL_RUNS / "zero_shot_ner")
    args = parser.parse_args()
    notes = documents()
    nlp = segmenter()
    model = PREDICTORS[args.model]()
    results = {}
    for condition in CONDITIONS:
        predictions = {}
        for document in notes:
            inputs = segments(nlp, document["text"], document["reference_segments"], condition)
            predictions[document["id"]] = deduplicate(model.predict(document, inputs))
            print(args.model, condition, document["id"], len(predictions[document["id"]]), flush=True)
        results[condition] = {"metrics": score_ner(notes, predictions),
                              "documents": [{"id": key, "predictions": rows} for key, rows in predictions.items()]}
    write_json(args.out_dir / f"{args.model}.json", {"model": args.model, "conditions": results})
    print(json.dumps({key: value["metrics"] for key, value in results.items()}))