En esta publicación, aprenderá a usar NerVisualizer de Spark NLP para visualizar entidades con nombre.
Comencemos con una breve introducción de Spark NLP y luego discutamos los detalles de las entidades nombradas de visualización con algunos resultados sólidos.
Spark NLP es una biblioteca de código abierto mantenida por John Snow Labs. Está construido sobre Apache Spark y Spark ML y proporciona anotaciones NLP simples, precisas y de alto rendimiento para canalizaciones de aprendizaje automático que pueden escalar fácilmente en un entorno distribuido.
Desde su primer lanzamiento en julio de 2017, Spark NLP se ha convertido en una herramienta completa de PNL, que proporciona:
- Una única solución unificada para todas sus necesidades de PNL
- Transferir el aprendizaje e implementar lo último y lo mejor SOTA algoritmos y modelos en la investigación de la PNL
- La biblioteca de PNL más utilizada en la industria (5 años seguidos)
- La biblioteca más escalable, precisa y rápida en la historia de la PNL
Spark NLP viene con más de 17 800 canalizaciones y modelos preentrenados en más de 250 idiomas. Admite la mayoría de las tareas de NLP y proporciona módulos que se pueden usar sin problemas en un clúster.
Spark NLP procesa los datos usando Pipelinesestructura que contiene todos los pasos a ejecutar sobre los datos de entrada:
Cada paso contiene un anotador que realiza una tarea específica, como tokenización, normalización y análisis de dependencias. Cada anotador tiene anotación(es) de entrada(s) y genera una nueva anotación.
Un anotador en Spark NLP es un componente que realiza una tarea específica de NLP en un documento de texto y le agrega anotaciones. Un anotador toma un documento de texto de entrada y produce un documento de salida con metadatos adicionales, que se pueden utilizar para su posterior procesamiento o análisis. Por ejemplo, un anotador de reconocimiento de entidades con nombre podría identificar y etiquetar entidades como personas, organizaciones y ubicaciones en un documento de texto, mientras que un anotador de análisis de opiniones podría clasificar la opinión del texto como positiva, negativa o neutral.
Para instalar Spark NLP en Python, simplemente use su administrador de paquetes favorito (conda, pip, etc.). Por ejemplo:
!pip install spark-nlp
!pip install pyspark
!pip install spark-nlp-display
Para otras opciones de instalación para diferentes entornos y máquinas, consulte la documentación oficial.
Luego, simplemente importe la biblioteca e inicie una sesión de Spark:
import sparknlp# Start Spark Session
spark = sparknlp.start()
El objetivo de NER es detectar y clasificar automáticamente las entidades nombradas en un documento de texto dado. Esto implica identificar las palabras o frases relevantes en una oración que se refieren a entidades nombradas y luego asignarlas a categorías predefinidas, como nombres de personas, nombres de organizaciones, nombres de ubicaciones, fechas y más.
Una técnica de visualización común para las anotaciones de texto es resaltar o Codigo de color los diferentes tipos de anotaciones en el texto. Por ejemplo, en el reconocimiento de entidades nombradas, se anotan nombres propios como nombres de personas, organizaciones y ubicaciones. Estos se pueden resaltar en un color específico para ayudar al usuario a identificarlos rápidamente en el texto.
NerVisualizer destaca la entidades nombradas que son identificados por Spark NLP y también muestra sus etiquetas como decoraciones sobre el texto analizado. Los colores asignados a las etiquetas previstas se pueden configurar para adaptarse a las necesidades particulares de la aplicación.
Trabajemos en el siguiente texto de muestra para observar las capacidades de Spark NLP NerVisualizer.
example = [
"""One of the most prominent centers of the Renaissance was Florence, Italy,
which produced many of the era's most influential painters.
Among these was Sandro Botticelli, whose masterpieces include
"The Birth of Venus" and "Primavera," both of which feature mythological
themes and strikingly beautiful figures. Another great Renaissance painter
from Florence was Michelangelo, known for his stunning frescoes
on the ceiling of the Sistine Chapel, as well as his sculptures such as
the "David" and "Pieta."""
]
Uso de una canalización previamente entrenada: reconocer entidades DL Pipeline
recognize_entities_dl es una canalización preentrenada que se puede usar para procesar texto con una canalización simple que realiza pasos básicos de procesamiento y reconoce entidades.
Una canalización previamente entrenada en Spark NLP es un conjunto preconstruido de modelos y herramientas de aprendizaje automático para realizar tareas de NLP. Está diseñado para proporcionar una forma rápida y fácil de comenzar con la PNL, sin necesidad de una gran experiencia en aprendizaje automático o PNL.
# Import the required modules and libraries
from sparknlp.pretrained import PretrainedPipeline# Define a pipeline
pipeline = PretrainedPipeline('recognize_entities_dl', lang='en')
Obtengamos predicciones de la canalización preentrenada.
ppres = pipeline.fullAnnotate(example)[0]
Ahora, podemos visualizar los resultados, además guardamos los resultados como un archivo html.
# First import NerVisualizer
from sparknlp_display import NerVisualizer# Display the results
visualiser = NerVisualizer()
visualiser.display(ppres, label_col='entities', document_col='document', save_path=f"display_recognize_entities.html")
También tenemos la opción de cambiar el color de una entidad, definiendo el código de color. Aquí nosotros definió los códigos de color para las entidades PER y LOC.
# Define the color codes for certain entities
visualiser.set_label_colors({'LOC':'#008080', 'PER':'#800080'})visualiser.display(ppres, label_col='entities')
Tenemos la opción de filtrar entidades; en el siguiente código, filtramos y optamos por mostrar solo las entidades etiquetadas como «PER».
# Filter the entitiesvisualiser.display(ppres, label_col='entities', document_col='document',
labels=['PER'])
print()
print ('color code for label "PER": ' + visualiser.get_label_color('PER'))
Uso de un modelo NER preentrenado: ner_dl
En este caso, en lugar de usar una canalización predefinida, usaremos un modelo previamente entrenado de John Snow Labs Models Hub. La biblioteca Spark NLP incluye varios modelos NER preentrenados, que están entrenados en grandes cantidades de datos de texto y están listos para usar de inmediato.
ner_dl es un modelo NER, lo que significa que anota texto para encontrar características como los nombres de personas, lugares y organizaciones.
ner_dl El modelo está entrenado con incrustaciones de palabras GloVe 100D, por lo que se deben usar las mismas incrustaciones en la canalización.
Usemos otro texto ahora:
example = [
"""Leonardo da Vinci was one of the most renowned polymaths in human history.
Born in Vinci, Italy in 1452, he is best known for his masterful works of art.
Throughout his life, Leonardo da Vinci lived and worked in various cities
in Italy, including Florence, Milan, and Rome. He began his artistic career
as an apprentice to Andrea del Verrocchio in Florence, where he honed
his skills in painting, sculpture, and metalworking. Leonardo da Vinci
died in Amboise, France in 1519, but his legacy has continued to
inspire artists, scientists, and inventors for centuries."""
]
Spark NLP tiene la enfoque de tubería y la tubería incluirá las etapas necesarias para extraer las entidades del texto.
# Import the required modules and classes
from sparknlp.base import DocumentAssembler, Pipeline, LightPipeline
from sparknlp.annotator import (
Tokenizer,
WordEmbeddingsModel,
NerDLModel,
NerConverter
)
import pyspark.sql.functions as F# Step 1: Transforms raw texts to `document` annotation
documentAssembler = DocumentAssembler()\
.setInputCol("text")\
.setOutputCol("document")
# Step 2: Tokenization
tokenizer = Tokenizer() \
.setInputCols(["document"]) \
.setOutputCol("token")
# Step 3: Get the embeddings using glove_100d
embeddings = WordEmbeddingsModel.pretrained('glove_100d').\
setInputCols(["document", 'token']).\
setOutputCol("embeddings")
# Step 4: Use the ner_dl model
public_ner = NerDLModel.pretrained('ner_dl', 'en') \
.setInputCols(["document", "token", "embeddings"]) \
.setOutputCol("ner")
# Step 5: Convert to user-friendly NER
ner_converter = NerConverter() \
.setInputCols(["document", "token", "ner"]) \
.setOutputCol("entities")
# Define the pipeline
nlpPipeline = Pipeline(stages=[ documentAssembler,
tokenizer,
embeddings,
public_ner,
ner_converter
])
# Create the dataframe
empty_df = spark.createDataFrame([['']]).toDF("text")
# Fit the dataframe to the pipeline to get the model
pipelineModel = nlpPipeline.fit(empty_df)
# Convert to LightPipeline Model
lmodel = LightPipeline(pipelineModel)
# Full annotate the light model to get predictions
cpres = lmodel.fullAnnotate(example)[0]
Mostremos los resultados. Recuerde, tenemos un texto nuevo y usamos un modelo preentrenado, en lugar de una tubería preentrenada:
visualiser = NerVisualizer()visualiser.display(cpres, label_col='entities', document_col='document', save_path=f"display_result_ner.html")
El documento se guarda nuevamente como un archivo html y, de manera similar al caso anterior, es posible cambiar los colores y filtrar los resultados.
Primero filtremos por la entidad «PER» y luego mostremos solo las entidades «LOC»:
visualiser.display(ppres, label_col='entities', document_col='document',
labels=['PER'])
visualiser.display(ppres, label_col='entities', document_col='document',
labels=['LOC'])
