Limpieza de texto: eliminar palabras vacías del texto con Spark NLP

En esta publicación, aprenderá cómo usar Spark NLP StopWordsCleaner anotador para realizar la limpieza de palabras vacías utilizando modelos previamente entrenados de manera eficiente.

Comencemos con una breve introducción de Spark NLP y luego discutamos los detalles de la limpieza de palabras vacías 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

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()

Las palabras vacías son una lista de palabras comunes que generalmente se eliminan del texto antes del análisis. Incluyen palabras como «el», «y», «un», etc. que no llevan mucha información significativa pero aparecen con frecuencia en el texto. La eliminación de palabras vacías es un paso crucial en el preprocesamiento de texto porque ayuda a reducir el tamaño de los datos de texto y facilita su análisis. También acelera el tiempo de procesamiento y mejora la eficiencia de los algoritmos basados ​​en texto.

Consulte el Centro de modelos de John Snow Labs para conocer los modelos disponibles. modelos preentrenados.

Echemos un vistazo a la tubería a continuación y luego ejecútela en el texto de muestra, para observar la eficiencia de StopWordsCleaner.

# Import the required modules and classes
from sparknlp.base import DocumentAssembler, Pipeline
from sparknlp.annotator import (
SentenceDetector,
Tokenizer,
StopWordsCleaner
)
import pyspark.sql.functions as F
# Step 1: Transforms raw texts to `document` annotation
document_assembler = (
DocumentAssembler()
.setInputCol("text")
.setOutputCol("document")
)
# Step 2: Splits the text into separate sentences
sentence = (
SentenceDetectorDLModel.pretrained("sentence_detector_dl", "en")
.setInputCols(["document"])
.setOutputCol("sentence")
)
# Step 2: Gets tokens from the sentences
tokenizer = (
Tokenizer()
.setInputCols(["sentence"])
.setOutputCol("token")
)
# Step 3: Performs stopwords cleaning
stop_words = (
StopWordsCleaner().pretrained("stopwords_iso","en")
.setInputCols(["token"])
.setOutputCol("cleanTokens")
)
pipeline = Pipeline(stages=[document_assembler, sentence, tokenizer, stop_words])

Después de eso, alimentamos el texto y usamos el modelo para ver los tokens limpios, sin palabras vacías.

sample_text = """
The quick brown fox jumped over the lazy dog. It was a beautiful day in 
the park, with birds chirping and the sun shining brightly. As the fox 
ran through the grass, it startled a group of rabbits who were munching on 
some carrots. They quickly scurried away, leaving the fox to continue 
its hunt. After a while, the fox grew tired and decided to take a nap under 
a nearby tree. The dog watched from a distance, wagging its tail lazily. 
Eventually, the sun began to set, and the sky turned a brilliant shade of 
orange and pink. It was a perfect end to a perfect day.
"""
# Create a dataframe from the sample_text
prediction_data = spark.createDataFrame([[sample_text]]).toDF("text")
# Fit and transform to get a prediction
model = pipeline.fit(prediction_data)
result = model.transform(prediction_data)
# Display the results
result.select("cleanTokens.result").show(truncate =  200)

Mostrar las palabras vacías limpiadas

Después de la limpieza, podemos ver todas las palabras vacías del modelo (571 en total):

stop_words.getStopWords()

Uso de LightPipeline

LightPipeline es una clase de Pipeline específica de Spark NLP equivalente a Spark ML Pipeline. La diferencia es que su ejecución no sigue los principios de Spark, sino que calcula todo localmente (pero en paralelo) para lograr resultados rápidos cuando se trata de pequeñas cantidades de datos. Esto significa que no ingresamos un Spark Dataframe, sino una cadena o una matriz de cadenas, para anotar.

Consulte esta publicación para obtener más información sobre esta clase.

Podemos obtener predicciones ejecutando el siguiente código:

from sparknlp.base import LightPipeline
light_model = LightPipeline(model)
light_result = light_model.fullAnnotate(sample_text)[0]

Podemos mostrar los resultados en un Pandas DataFrame ejecutando el siguiente código:

import pandas as pd
keys_df = pd.DataFrame([(k.result, k.begin, k.end, k.metadata['sentence']) for k in light_result['cleanTokens']],
columns = ['cleanTokens','begin','end','sentence'])
keys_df.sort_values(['sentence']).head(100)

Limpieza de palabras vacías para otros idiomas

Hay más de 100 modelos en John Snow Labs Models Hub para idiomas distintos del inglés.

Probemos un modelo para francés:

stop_words = StopWordsCleaner.pretrained("stopwords_fr","fr") \
.setInputCols(["token"]) \
.setOutputCol("cleanTokens")
pipeline = Pipeline(stages=[documentAssembler, tokenizer, stop_words]) 
sample_text_fr = """
Le rapide renard brun sauta par dessus le chien paresseux. C'était une belle journée à
le parc, avec le chant des oiseaux et le soleil qui brille de mille feux. Comme le renard
couru dans l'herbe, il a fait sursauter un groupe de lapins qui grignotaient
quelques carottes. Ils se sont rapidement éloignés, laissant le renard continuer
sa chasse. Au bout d'un moment, le renard se fatigua et décida de faire une sieste sous
un arbre voisin. Le chien regardait de loin, remuant paresseusement la queue.
Finalement, le soleil a commencé à se coucher et le ciel a pris une teinte brillante de
orange et rose. C'était une fin parfaite pour une journée parfaite.
"""
example = spark.createDataFrame([[sample_text_fr]], ["text"]) 
results = pipeline.fit(example).transform(example)
results.select("cleanTokens.result").show(1, truncate = 200)

Personaliza tus propias palabras vacías

En lugar de usar palabras vacías en el modelo, es posible define tu lista de palabras vacías usando el setStopWords parámetro. Usar un archivo también es una opción.

Como se muestra en el siguiente código, esta vez definimos solo dos palabras vacías: ‘Tom’ y ‘Kashmir’, aunque no son palabras vacías.

stop_words = StopWordsCleaner()\
.setInputCols(["token"]) \
.setOutputCol("cleanTokens") \
.setCaseSensitive(False)\
.setStopWords(["Tom", "Kashmir"]) 
#(We manually specified only 'is' and 'a' as stopwords. 
prediction_pipeline = Pipeline(
stages = [
documentAssembler,
sentence,
tokenizer,
stop_words
]
)
prediction_data = spark.createDataFrame([[
"Tom is a nice man and he lives in Kashmir."]]).toDF("text")
result = prediction_pipeline.fit(prediction_data).transform(prediction_data)
result.select("cleanTokens.result").show(1, False)

Como puede ver en el resultado, sólo las palabras definidas por el setStopWords El parámetro se limpió y muchas palabras vacías todavía están en el texto.

Alternativa de una sola línea

En octubre de 2022, John Snow Labs lanzó el código abierto johnsnowlabs biblioteca que contiene todos los productos de la empresa, de código abierto y con licencia, en una biblioteca común. Esto simplificó el flujo de trabajo, especialmente para los usuarios que trabajan con más de una de las bibliotecas (p. ej., Spark NLP + Healthcare NLP). Esta nueva biblioteca es un contenedor de todas las bibliotecas de John Snow Lab y se puede instalar con pip:

pip install johnsnowlabs

Consulte la documentación oficial para obtener más ejemplos y el uso de esta biblioteca. Para ejecutar el limpiador de palabras vacías con una línea de código, simplemente podemos usar el siguiente código:

from johnsnowlabs import nlp
nlp.load('en.stopwords').predict("The dog watched from a distance, wagging its tail.", output_level='sentence')

El resumen se basa en modelos predeterminados para cada tarea de PNL. Dependiendo de sus requisitos, es posible que desee utilizar el resumen de una sola línea para simplificar o personalizar la canalización para elegir modelos específicos que se ajusten a sus necesidades.

NOTA: cuando se utiliza sólo el johnsnowlabs biblioteca, asegúrese de inicializar la sesión de chispa con la configuración que tiene disponible. Dado que algunas de las bibliotecas tienen licencia, es posible que deba establecer la ruta a su archivo de licencia. Si solo está utilizando la biblioteca de código abierto, puede iniciar la sesión con spark = nlp.start(nlp=False). Los parámetros predeterminados para la función de inicio incluyen el uso de la biblioteca Healthcare NLP con licencia con nlp=Truepero podemos configurarlo para False y use todos los recursos de las bibliotecas de código abierto como Spark NLP, Spark NLP Display y NLU.