Clinical Natural Language Processing in Python _ Andrew Villazon

Prévia do material em texto

30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 1/36
Andrew Villazon Artigos Contato
Processamento de linguagem natural
clínica em Python
30 de abril de 2021
Pitão
Ao trabalhar com dados de saúde, algumas das informações mais valiosas estão na
Documentação Clínica. As observações feitas pelos médicos documentam muitos
detalhes, incluindo doenças presentes, tratamentos, medicamentos ou procedimentos,
fornecendo informações sobre a condição do paciente.
Neste guia, veremos como usar ferramentas modernas de PNL em Python para extrair
informações significativas de textos clínicos.
Pré-requisitos
https://www.andrewvillazon.com/
https://www.andrewvillazon.com/articles/
https://www.andrewvillazon.com/contact/
https://www.andrewvillazon.com/tags/python/
https://www.python.org/
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 2/36
Este guia fará algumas suposições, a saber:
Familiaridade com Python, incluindo importação de bibliotecas, loop e
acesso a atributos
Confortável usando o terminal ou prompt de comando para instalar pacotes
Uma compreensão básica dos objetivos e da terminologia do Processamento
de Linguagem Natural
Vamos combinar três bibliotecas para realizar PNL clínica:
spaCy : biblioteca NLP que fornece processamento de texto e orquestração.
scispaCy : uma biblioteca de componentes específicos clínicos e
biomédicos que se integram com spaCy.
negspaCy : para detectar negação de termos.
O objetivo deste guia não é um tutorial detalhado sobre cada uma dessas bibliotecas,
mas sim como utilizá-las para PNL clínica.
Visão geral
https://spacy.io/
https://allenai.github.io/scispacy/
https://github.com/jenojp/negspacy
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 3/36
Processando texto com spaCy
Processando Texto Clínico com ScispaCy
Negação com negspaCy
Conclusão
Leitura adicional
A primeira biblioteca que enfocaremos é spaCy , uma biblioteca de código aberto para
Processamento de Linguagem Natural em Python. spaCy atua como a base da PNL e
gerencia o processamento de texto ponta a ponta. Posteriormente, adicionaremos
componentes spaCy específicos para a clínica para lidar com Texto clínico.
Vamos ver como o spaCy funciona e explorar alguns de seus principais conceitos.
Conteúdo
Processando texto com spaCy
Pipelines
https://spacy.io/
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 4/36
Central para spaCy é a ideia de um pipeline de processamento , as etapas organizadas
para extrair informações de um texto. Essas etapas consistem em componentes
específicos encadeados que atuam em um texto para extrair dados estruturados.
O pipeline gera um documento ou Doc objeto contendo os dados estruturados extraídos
do texto.
Um pipeline executa tarefas como:
Tokenização: dividir um texto em unidades significativas conhecidas como
tokens.
Marcação de parte da fala �POS�� alocação de tipos de palavras (por
exemplo, substantivos, verbos) para tokens.
Análise de dependência: identificar como os tokens se relacionam entre si,
por exemplo, em "o gato preto", sabendo que o adjetivo "preto" está
relacionado ao gato.
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 5/36
Lematização: identificar a raiz, ou radical, de uma palavra, por exemplo,
corre, correu, correu, todos derivados da palavra "correr".
Named Entity Recognition �NER�� rotulando "entidades" ou coisas de
interesse. Em um contexto clínico, isso poderia ser a identificação da
presença de uma doença ou parte da anatomia.
Em geral, a primeira etapa no uso de spaCy é criar um objeto de pipeline.
No código a seguir, criamos um pipeline (simples) a partir da aula de inglês. O pipeline
do idioma inglês possui os componentes necessários para lidar com o texto do idioma
inglês.
A convenção em spaCy é atribuir um objeto pipeline a uma variável chamada nlp . Para
processar um texto com o pipeline, chamamos isso de passagem de texto. A convenção
também recomenda atribuir o resultado a uma variável chamada doc .
Criação de um pipeline
from spacy.lang.en import English
 
nlp = English()
 
doc = nlp("Get to the chopper!")
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 6/36
Chamar o nlp pipeline no texto produz um Doc objeto.
O Doc objeto (abreviação de Documento) funciona como um contêiner para os dados
identificados pelo pipeline de processamento, como tokens, classes gramaticais,
sentenças, lemas, entidades, etc.
O Doc se comporta como uma sequência. Quando usado em um loop for, o Doc objeto
retorna cada token em sua matriz de tokens.
O Objeto Doc
from spacy.lang.en import English
 
nlp = English()
doc = nlp("Iced that guy, cone a phrase.")
 
for token in doc:
 print(token)
Iced
that
guy
,
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 7/36
Uma das principais tarefas do pipeline de processamento é produzir tokens .
Na PNL, um token é uma sequência de caracteres agrupados que têm algum
significado. Os tokens padrão são coisas como palavras, números, pontuação, etc.
spaCy nos fornece uma grande quantidade de informações sobre um token, incluindo:
O texto do token
Se o token for um caractere do alfabeto, um dígito, minúsculas ou
maiúsculas, moeda, etc.
Se o token for semelhante a um e-mail, número, URL, etc.
Abaixo, examina uma seleção de atributos para os tokens em um Doc objeto.
cone
a
phrase
.
Tokens
 from spacy.lang.en import English
 
l E li h()
https://nlp.stanford.edu/IR-book/html/htmledition/tokenization-1.html
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 8/36
Para obter uma lista completa dos atributos disponíveis, consulte a documentação da
API spacy .
 nlp = English()
 doc = nlp("Two years from now, spam will be solved.")
 
 fmt_str = "{:<8}| {:<10}| {:<10}| {:<10}"
 print(fmt_str.format("token", "is_alpha","is_punct", "like_num"))
 
 for token in doc:
 print(fmt_str.format(token.text, token.is_alpha, token.is_punct, token.like_n
token | is_alpha | is_punct | like_num 
Two | 1 | 0 | 1 
years | 1 | 0 | 0 
from | 1 | 0 | 0 
now | 1 | 0 | 0 
, | 0 | 1 | 0 
spam | 1 | 0 | 0 
will | 1 | 0 | 0 
be | 1 | 0 | 0 
solved | 1 | 0 | 0 
. | 0 | 1 | 0 
Extração de informações com pipelines treinados
https://spacy.io/api/doc#attributes
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 9/36
O pipeline do idioma inglês que vimos anteriormente era bastante simples. O que
precisamos é extrair informações do texto. É aqui que entram os pipelines ou modelos
treinados.
Pipelines treinados são um tipo de pipeline que usa modelos estatísticos para fazerprevisões sobre tokens com base em seu contexto. Treinados em textos de exemplo
rotulados, esses modelos podem detectar classes gramaticais, relações de
dependência entre tokens e entidades nomeadas.
Os modelos não vêm com spaCy e são instalados separadamente. Os documentos
spaCy recomendam usar o download comando spaCy do terminal.
Uma vez instalado, um modelo aparecerá como um pacote instalado visível usando o
pip list comando do terminal.
Para obter a lista completa de modelos ingleses da equipe spaCy, consulte os
documentos .
Instalando modelos
python -m spacy download en_core_web_sm
https://spacy.io/models/en
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 10/36
Para usar um pipeline treinado, primeiro o criamos chamando a load() função spaCy ,
passando o nome de um modelo instalado. Neste código, estamos usando
en_core_web_sm um pequeno modelo baseado na web.
Como vimos anteriormente, chamamos nlp() o texto para processá-lo e criar um
Doc objeto.
Usando pipelines treinados
import spacy
 
nlp = spacy.load("en_core_web_sm")
 import spacy
 
 nlp = spacy.load("en_core_web_sm")
 doc = nlp("Early one morning, Peter opened the gate and walked out into the big g
 
 fmt_str = "{:<8}| {:<6}| {:<8}| {:<8}"
 print(fmt_str.format("token","pos", "label","parent"))
 
 for token in doc:
 print(fmt_str.format(token.text, token.pos_, token.ent_type_, token.head.text
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 11/36
Desta vez, o pipeline treinado adicionou algumas informações interessantes:
O lematizador determinou que "abriu" e "caminhou" a haste de abrir e andar.
O etiquetador da parte do discurso etiquetou os tokens ordenadamente.
O Named Entity Recognizer �NER� rotulou corretamente "Early", "one" e
"morning" como TIME entidades.
O NER também rotulou "Peter" como um PERSON .
token | pos | label | parent 
Early | ADV | TIME | morning 
one | NUM | TIME | morning 
morning | NOUN | TIME | opened 
, | PUNCT | | opened 
Peter | PROPN | PERSON | opened 
opened | VERB | | opened 
the | DET | | gate 
gate | NOUN | | opened 
and | CCONJ | | opened 
walked | VERB | | opened 
out | ADP | | walked 
into | ADP | | walked 
the | DET | | meadow 
big | ADJ | | meadow 
green | ADJ | | meadow 
meadow | NOUN | | into 
. | PUNCT | | opened 
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 12/36
Os pipelines e modelos treinados da spaCy são poderosos e fáceis de usar. Coletamos
informações estruturadas criando um objeto pipeline e chamando-o em um texto.
Agora que aprendemos sobre o uso do spaCy, vamos ver como combiná-lo com o
scispaCy para textos clínicos específicos.
Pipelines treinados funcionam bem; no entanto, há um problema. Sua eficácia depende
dos dados de treinamento e do domínio do modelo subjacente.
Por exemplo, pipelines treinados para conversas de chat provavelmente não serão
eficazes em Textos Clínicos. O que precisamos são modelos básicos especificamente
treinados para dados biomédicos.
scispaCy é uma biblioteca python que contém pipelines, modelos e componentes
spaCy para processamento de texto biomédico, científico ou clínico.
Ele possui alguns recursos adicionais que o tornam excelente para texto clínico: Um
detector de abreviações e um linker de entidade que vincula tokens a uma ontologia.
Processando Texto Clínico com ScispaCy
O que é scispaCy?
https://allenai.github.io/scispacy/
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 13/36
Semelhante aos modelos spaCy, os modelos scispaCy são instalados separadamente .
Os modelos scispaCy usam pip para instalar e uma URL de modelo.
A lista completa de modelos e URLs está disponível na página do scispaCy GitHub .
Uma nota sobre os modelos ScispaCy
No momento da escrita, scispaCy tem dois tipos de modelos, Detectores de Entidades e
Reconhecedores de Entidades Nomeadas �NER� .
Modelos de detecção entidade, en_core_sci_sm , en_core_sci_md , en_core_sci_lg , e
en_core_sci_scibert , detectar entidades, mas aplica-se um general ENTITY rótulo. Essas
entidades são usadas com componentes de pipeline adicionais, como o Detector de
abreviações, ou vinculadas a uma base de conhecimento.
Os modelos NER são mais específicos e treinados em um corpus anotado. Esses modelos
identificam uma entidade e dão a ela um rótulo distinto que é predefinido.
Instalação de modelos scispaCy
pip install <model_url>
https://github.com/allenai/scispacy#available-models
https://github.com/allenai/scispacy#available-models
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 14/36
Os pipelines scispaCy são criados e usados como outros pipelines treinados em spaCy,
ou seja, chamando o load() método spaCy e passando um nome de modelo. Depois de
feito, chamamos nlp() um texto para processá-lo.
Abaixo, criamos um pipeline scispaCy usando um modelo de detecção de entidade .
Em seguida, o chamamos em um texto clínico e inspecionamos os atributos do token.
Usando pipelines treinados com scispaCy
 import scispacy
 import spacy
 
 nlp = spacy.load("en_core_sci_sm")
 
 doc = nlp("An allograft was used to recreate the coracoacromial ligaments and the
 
 fmt_str = "{:<15}| {:<6}| {:<7}| {:<8}"
 print(fmt_str.format("token", "pos", "label", "parent"))
 
 for token in doc:
 print(fmt_str.format(token.text, token.pos_, token.ent_type_, token.head.text
token | pos | label | parent 
An | DET | | allograft
allograft | NOUN | ENTITY | used 
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 15/36
Observe como o pipeline fez a marcação de parte da fala, identificou dependências
sintáticas, mas também aplicou um ENTITY rótulo a alguns tokens.
Aqui fazemos o mesmo, mas substituímos o Detector de Entidade por um modelo NER .
was | VERB | | used 
used | VERB | | used 
to | PART | | recreate
recreate | VERB | ENTITY | used 
the | DET | | ligaments
coracoacromial | ADJ | ENTITY | ligaments
ligaments | NOUN | ENTITY | recreate
... etc
 import scispacy
 import spacy
 
 nlp = spacy.load("en_ner_bionlp13cg_md")
 
 doc = nlp("An allograft was used to recreate the coracoacromial ligaments and the
 
 fmt_str = "{:<15}| {:<6}| {:<7}| {:<8}"
 print(fmt_str.format("token", "pos", "label", "parent"))
 
 for token in doc:
 print(fmt_str.format(token.text, token.pos_, token.ent_type_, token.head.text
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 16/36
Os resultados são semelhantes, mas o Named Entity Recognizer aplicou um ORGAN rótulo
a alguns dos tokens.
O scispaCy vem com um AbbreviationDetector componente para ajudar na
decodificação de abreviações. As AbbreviationDetector funções como um componente
de pipeline regular de spacy e são adicionadas depois que um pipeline é carregado.
No spaCy 3.0, os componentesde pipeline personalizados devem ser registrados com
o pipeline. Para adicionar um componente de pipeline:
 token | pos | label | parent 
 An | DET | | allograft
 allograft | NOUN | ORGAN | used 
 was | VERB | | used 
 used | VERB | | used 
 to | PART | | recreate
 recreate | VERB | | used 
 the | DET | | ligaments
 coracoacromial | ADJ | ORGAN | ligaments
 ligaments | NOUN | ORGAN | recreate
 ... etc
Detecção de abreviatura
https://spacy.io/usage/v3#features-components
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 17/36
Importe o componente usando a import instrução
Carregue o pipeline treinado
Registre o componente no pipeline treinado com o add_pipe() método.
Em spaCy, as personalizações para Doc ou Token objetos, como aquelas feitas pelo
AbbreviationDetector , tornam-se disponíveis por meio de um _ atributo (sublinhado).
import spacy
from scispacy.abbreviation import AbbreviationDetector
 
nlp = spacy.load("en_core_sci_sm")
# Add the abbreviation pipe to the spacy pipeline.
nlp.add_pipe("abbreviation_detector")
 
doc = nlp(
 "Chronic lymphocytic leukemia (CLL), autoimmune hemolytic anemia, and oral ul
)
 
fmt_str = "{:<6}| {:<30}| {:<6}| {:<6}"
print(fmt_str.format("Short", "Long", "Starts", "Ends"))
 
for abrv in doc._.abbreviations:
 print(fmt_str.format(abrv.text, str(abrv._.long_form), abrv.start, abrv.end))
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 18/36
Para acessar o loop de abreviações na doc._.abbreviations coleção. Cada token nesta
coleção possui um long_form atributo que expande a abreviação.
Nenhuma abreviatura detectada
Você pode notar a AbbreviationDetector falha em identificar a abreviatura quando a forma
longa está ausente do texto. O algoritmo de Schwartz & Hearst implementado pelo
AbbreviationDetector requer pelo menos um par de formato longo e curto no texto antes de
identificar outras ocorrências de formato curto.
Para obter mais detalhes sobre como o algoritmo funciona, consulte o artigo original .
A EntityLinker classe do scispaCy é um componente de pipeline spaCy que vincula
entidades identificadas pelo pipeline treinado com várias ontologias clínicas. Em spaCy,
essas ontologias são chamadas de bases de conhecimento.
Short | Long | Starts| Ends 
CLL | Chronic lymphocytic leukemia | 4 | 5 
CLL | Chronic lymphocytic leukemia | 36 | 37 
Vinculando-se a UMLS e outros com o EntityLinker
https://pubmed.ncbi.nlm.nih.gov/12603049/
https://spacy.io/usage/processing-pipelines#pipelines
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 19/36
No momento da redação, o scispaCy oferece suporte ao seguinte: Sistema de
linguagem médica unificado , cabeçalhos de assuntos médicos , a ontologia RxNorm ,
a ontologia genética e a ontologia fenótipo humano .
O EntityLinker usa uma pesquisa aproximada de vizinhos mais próximos para
comparar cada entidade identificada com entradas na base de conhecimento.
As EntityLinker funções como um componente spaCy regular e são adicionadas a um
pipeline existente.
Para adicionar ao pipeline:
Importe o componente usando a import instrução
Carregue o pipeline treinado
Registre o componente no pipeline treinado com o add_pipe() método,
incluindo um dicionário de configuração opcional.
Configurando o EntityLinker
 import spacy
 import scispacy
 from scispacy.linking import EntityLinker
 
nlp = spacy load("en core sci sm")
https://www.nlm.nih.gov/research/umls/index.html
https://www.nlm.nih.gov/mesh/meshhome.html
https://www.nlm.nih.gov/research/umls/rxnorm/index.html
https://www.nlm.nih.gov/mesh/meshhome.html
https://www.nlm.nih.gov/research/umls/rxnorm/index.html
http://geneontology.org/
https://hpo.jax.org/app/
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 20/36
EntityLinker leva muito tempo para ser executado
A primeira vez que executar o EntityLinker levará muito tempo. Isso ocorre porque é
EntityLinker necessário fazer o download da Base de Conhecimento. Para o UMLS, este é
um arquivo json de 1 GB !. Depois de baixado, ele será armazenado em cache e usado no
futuro com muito mais rapidez.
Para configurar o EntityLinker , incluímos um dicionário opcional de pares de valores-
chave de configuração com a chamada para add_pipe()
O EntityLinker tem as seguintes opções de configuração:
opção modelo padrão Descrição
linker_name p Ontologia para vincular. Opções: umls ,
mesh , rxnorm , go , hpo
 nlp = spacy.load( en_core_sci_sm )
 nlp.add_pipe("scispacy_linker", config={"linker_name": "umls"})
Configurando o EntityLinker
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 21/36
opção modelo padrão Descrição
resolve_abbreviations bool False Resolva as abreviações antes de vincular. O
AbbreviationDetector (veja acima) deve
estar em andamento para que isso tenha
efeito.
max_entities_per_mention int 5 O número de entradas correspondentes a
serem retornadas da base de conhecimento.
threshold flutuador 0.7 O limite que um candidato a menção deve
atingir para ser adicionado à menção no
Doc como um candidato a menção.
k int 30 O número de vizinhos mais próximos a serem
consultados no gerador de candidato por
menção.
no_definition_threshold flutuador 0.95 O limite que um candidato a entidade deve
atingir para ser adicionado à menção no Doc
como um candidato a menção se o
candidato a entidade não tiver uma
definição.
filter_for_definitions bool True Inclua apenas entidades com definições na
base de conhecimento.
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 22/36
* reproduzido da página scispaCy GitHub
Em spaCy, as personalizações para Doc , Token ou Span objetos, como aquelas feitas
por EntityLinker , tornam-se disponíveis por meio de um _ atributo (sublinhado).
O EntityLinker adiciona um kb_ents atributo a cada entidade correspondida com êxito
a uma entrada da base de conhecimento. kb_ents é uma lista de tuplas de
correspondência contendo o identificador de conceito da base de conhecimento ( CUI )
e a pontuação de correspondência associada. O max_entities_per_mention define o
tamanho desta lista.
Usando resultados de EntityLinker
import spacy
import scispacy
from scispacy.linking import EntityLinker
 
nlp = spacy.load("en_core_sci_sm")
nlp.add_pipe("scispacy_linker", config={"linker_name": "umls", "max_entities_per_
 
doc = nlp("Patient has prostate cancer with metastatic disease to his bladder.")
 
fmt_str = "{:<20}| {:<11}| {:<6}"
print(fmt_str.format("Entity", "Concept ID", "Score"))
 
entity = doc.ents[2]
https://github.com/allenai/scispacy#entitylinker
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 23/36
Por último, podemos consultar a base de conhecimento para obter mais detalhes
usando o EntityLinker componente e o CUI.
Para consultar, primeiro recuperamos o EntityLinker do pipeline usando o
get_pipe() método. Em seguida, procuramos o CUI no
linker.kb.cui_to_entity dicionário usando o CUI como chave.for kb_entry in entity._.kb_ents:
 cui = kb_entry[0]
 match_score = kb_entry[1]
 
 print(fmt_str.format(entity.text, cui, match_score))
Entity | Concept ID | Score 
metastatic disease | C0027627 | 1.0 
metastatic disease | C2939419 | 1.0 
metastatic disease | C2939420 | 1.0 
metastatic disease | C4330673 | 0.8193445801734924
metastatic disease | C5205724 | 0.7593715190887451
metastatic disease | C0238258 | 0.7438488602638245
Consulta de entradas da base de conhecimento
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 24/36
 import spacy
 import scispacy
 from scispacy.linking import EntityLinker
 
 nlp = spacy.load("en_core_sci_sm")
 nlp.add_pipe("scispacy_linker", config={"linker_name": "umls", "max_entities_per_
 
 doc = nlp("Patient has prostate cancer with metastatic disease to his bladder.")
 
 linker = nlp.get_pipe("scispacy_linker")
 
 fmt_str = "{:<20}| {:<10}| {:<32}| {:<20}"
 print(fmt_str.format("Entity", "1st CUI", "Canonical Name", "Definition"))
 
 for entity in doc.ents:
 first_cuid = entity._.kb_ents[0][0]
 kb_entry = linker.kb.cui_to_entity[first_cuid]
 
 print(fmt_str.format(entity.text, first_cuid, kb_entry.canonical_name, kb_ent
Entity | 1st CUI | Canonical Name | Definition 
Patient | C0030705 | Patients | Individuals p
prostate cancer | C0376358 | Malignant neoplasm of prostate | A primary or 
metastatic disease | C0027627 | Neoplasm Metastasis | The transfer 
bladder | C0005682 | Urinary Bladder | A musculomemb
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 25/36
O aspecto final a considerar na PNL clínica é a negação - a contradição ou negação de
algo. Em um contexto clínico, a ausência documentada de algo, por exemplo, uma
doença, pode ser uma informação valiosa.
Para negação, podemos usar negspaCy , um componente de pipeline spaCy para negar
conceitos em um texto. negspaCy implementa o algoritmo Negex .
negspaCy implementa quatro padrões de negação:
pseudo negações: frases que parecem indicar negação, mas identificam
negativas duplas, por exemplo, "não descartado".
negações precedentes: frases de negação antes de uma entidade
seguintes negações: frases de negação após uma entidade
terminação: frases que cortam uma frase em partes, por exemplo,
"entretanto".
Como um componente spaCy, usamos negspaCy adicionando-o a um pipeline existente.
Negação com negspaCy
Usando negspaCy
https://github.com/jenojp/negspacy
https://doi.org/10.1006/jbin.2001.1029
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 26/36
Para adicionar ao pipeline:
Importe o componente usando a import instrução
Carregue o pipeline treinado
Registre o componente no pipeline treinado com o add_pipe() método,
incluindo um dicionário de configuração opcional.
Em spaCy, as personalizações para Doc , Token ou Span objetos, como aquelas feitas
por negspaCy, tornam-se disponíveis por meio de um _ atributo (sublinhado).
negspaCy adicionará um negex atributo a cada entidade no Doc objeto. Em entidades
negadas, este atributo é definido como True .
 import scispacy
 import spacy
 from negspacy.negation import Negex
 
 nlp = spacy.load("en_core_sci_sm")
 nlp.add_pipe("negex")
 import scispacy
 import spacy
 from negspacy.negation import Negex
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 27/36
Para configurar negspaCy, fornecemos um config dicionário opcional ao adicionar o
componente a um pipeline treinado.
 
 nlp = spacy.load("en_core_sci_sm")
 nlp.add_pipe("negex")
 
 doc = nlp("Patient has history of elevated cholesterol, but does not have ASHD, h
 
 fmt_str = "{:<22}| {:<10}"
 print(fmt_str.format("Entity", "Is negated"))
 
 for entity in doc.ents:
 print(fmt_str.format(entity.text, entity._.negex))
Entity | Is negated
Patient | 0 
history | 0 
elevated cholesterol | 0 
ASHD | 1 
hypertension | 1 
PVD | 1 
Configurando negspaCy
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 28/36
negspaCy tem as seguintes opções de configuração:
opção modelo padrão Descrição
"neg_termset" dict "en_clinical" O conjunto de termos de negação a ser usado
(veja abaixo como configurar). Inclui "en" :,
frases gerais de negação em inglês;
"en_clinical" , inglês geral e frases de
negação específicas da clínica;
"en_clinical_sensitive" , frases de negação
para entidades históricas.
"ent_types" Lista Uma lista de entidades nomeadas para excluir
da negação, por exemplo "PERSON" , "ORG"
"chunk_prefix" Lista Uma lista de negações anteriores quando as
negações são "agrupadas" como uma única
entidade (veja abaixo para mais detalhes)
 import scispacy
 import spacy
 from negspacy.negation import Negex
 
 nlp = spacy.load("en_core_sci_sm")
 nlp.add_pipe("negex", config={"chunk_prefix": ["no"]})
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 29/36
negspaCy define os padrões de negação e suas frases associadas como um conjunto
de termos . Um conjunto de termos pode ser visualizado importando a termset função,
criando um novo conjunto de termos e chamando termset.get_patterns() .
Para configurar o conjunto de termos que negspaCy usará, criamos um novo conjunto
de termos com a termset() função passando o nome do conjunto de termos escolhido.
Em seguida, incluímos o conjunto de termos no config dicionário ao adicionar negex ao
pipeline.
Escolhendo diferentes padrões de negação
 from negspacy.termsets import termset
 
 ts = termset("en_clinical")
 
 print(ts.get_patterns())
 import scispacy
 import spacy
 from negspacy.negation import Negex
 from negspacy.termsets import termset
 
 ts = termset("en_clinical_sensitive")
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 30/36
Para modificar o conjunto de termos, negspaCy fornece as funções add_patterns() e
remove_patterns() . Essas funções aceitam um dicionário com chaves correspondentes
a cada padrão de negação e uma lista de frases para adicionar ou remover.
Essas modificações devem ocorrer antes de adicionar negspaCy ao pipeline treinado.
Depois de modificado, inclua o novo conjunto de termos ao adicionar o negspaCy ao
pipeline.
 
 nlp = spacy.load("en_core_sci_sm")
 nlp.add_pipe("negex", config={"neg_termset": ts.get_patterns()})
Modificando padrões de negação
 import scispacy
 import spacy
 from negspacy.negation import Negex
 from negspacy.termsets import termset
 
 ts = termset("en_clinical")
 ts.add_patterns(
 {
 "preceding_negations":["unable"],
 "following_negations": ["was negative"]
 }
)
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 31/36
Se você estiver usando scispaCy, poderá descobrir que ele combina negações e
entidades em uma única entidade,por exemplo, "sem sangramento". Essa fragmentação
 )
 
 
 nlp = spacy.load("en_core_sci_sm")
 nlp.add_pipe("negex", config={"neg_termset": ts.get_patterns()})
 
 doc = nlp("Patient unable to walk or stand upright. The most recent bone scan was
 
 fmt_str = "{:<10}| {:<10}"
 print(fmt_str.format("Entity", "Is negated"))
 
 for entity in doc.ents:
 print(fmt_str.format(entity.text, entity._.negex))
Entity | Is negated
Patient | 0 
walk | 1 
stand | 1 
bone scan | 1 
negative | 0 
Tratamento quando negações e entidades são combinadas
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 32/36
faz com que a negspaCy perca a negação anterior.
Para resolver isso, podemos incluir uma "chunk_prefix" chave no config dicionário com
uma lista de negações que podem aparecer com uma entidade.
 import scispacy
 import spacy
 from negspacy.negation import Negex
 
 nlp = spacy.load("en_core_sci_sm")
 nlp.add_pipe("negex", config={"chunk_prefix":["no"]})
 
 doc = nlp("No bleeding.")
 
 fmt_str = "{:<12}| {:<10}"
 print(fmt_str.format("Entity", "Is negated"))
 
 for entity in doc.ents:
 print(fmt_str.format(entity.text, entity._.negex))
Entity | Is negated
No bleeding | 1 
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 33/36
Devido à sua natureza especializada, repleta de jargões e siglas, o Texto Clínico tem
sido difícil de utilizar de forma eficaz. No entanto, avanços recentes em algoritmos e
ferramentas melhores significam que isso está mudando.
Esperançosamente, este guia deu a você uma compreensão de como você pode usar
Python para extrair informações significativas de textos clínicos.
Por último, cobrimos muito, mas há muito mais por aí. Aqui está uma lista de recursos
adicionais para Processamento Clínico de Linguagem Natural.
spaCy101 é o curso online gratuito oferecido pela equipe spaCy. Ele cobre noções
básicas sobre spaCy até tópicos mais avançados, como otimização de pipelines para
velocidade e treinamento de modelos personalizados.
Conclusão
Para onde vamos a partir daqui
spaCy101
https://course.spacy.io/en/
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 34/36
Se você deseja começar com PNL clínica, recomendo fortemente começar com
spaCy101 .
O universo spaCy é uma lista com curadoria de projetos desenvolvidos com ou para
spaCy. As categorias Científica e Pesquisa apresentam projetos adicionais para PNL
clínica.
med7 é um modelo de spaCy de reconhecimento de entidade nomeada para rotulagem
de informações de medicamentos. As etiquetas incluem DOSAGEM, MEDICAMENTO,
DURAÇÃO, ROTA e muito mais. No momento em que foi escrito, não é compatível com
spaCy 3.0
mtsamples.com é um repositório de quase 5.000 relatórios e exemplos de amostras
médicas transcritas. Se você não conseguir trabalhar com o texto clínico real,
MTSAMPLES é uma boa alternativa.
universo spaCy
med7
MTSAMPLES
https://spacy.io/universe
https://github.com/kormilitzin/med7
https://mtsamples.com/
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 35/36
ClarityNLP é um aplicativo baseado em python para PNL clínica do Georgia Tech
Research Institute. De interesse é o size_measurement_finder módulo do Clarity , que
visa identificar medidas em textos clínicos.
Embora não seja um componente de pipeline spaCy, é possível importar o módulo para
o código existente e usá-lo a partir dele.
sqlalchemy é o Object-Relational-Mapper �ORM� mais popular do Python. ORMs
permitem definir objetos Python e mapear seus dados para um banco de dados.
sqlalchemy é útil para o armazenamento downstream de informações estruturadas
extraídas do Texto Clínico.
Processamento de texto clínico com Python
ClarityNLP e medição de tamanho
sqlalchemy e armazenamento de resultados
Leitura adicional
https://claritynlp.readthedocs.io/en/latest/
https://claritynlp.readthedocs.io/en/latest/developer_guide/algorithms/size_measurement_finder.html
https://docs.sqlalchemy.org/en/14/orm/tutorial.html
https://www.trivedigaurav.com/blog/clinical-text-processing-with-python/
30/06/2021 Clinical Natural Language Processing in Python | Andrew Villazon
https://www.andrewvillazon.com/clinical-natural-language-processing-python/#processing-clinical-text-with-scispacy 36/36
Casa Artigos Cerca de Contato
© Andrew Villazon 2020
https://www.andrewvillazon.com/
https://www.andrewvillazon.com/articles/
https://www.andrewvillazon.com/about/
https://www.andrewvillazon.com/contact/
https://github.com/andrewvillazon
https://www.gatsbyjs.com/