fancy nlp
1.0.0
PNL para humanos. Un conjunto de herramientas de procesamiento del lenguaje natural (PNL) rápido y fácil de usar, que satisface su imaginación sobre PNL.
→ Versión en inglés
Introducción básica • Instalación • Guía de inicio • Tutorial detallado • Honores • Cómo contribuir con código • Cotizaciones • Agradecimientos
Fancy-NLP es una herramienta de minería de conocimiento de texto para construir retratos de productos construidos por el equipo de estrategia de publicidad de productos de Tencent. Admite una variedad de tareas comunes de PNL, como extracción de entidad, clasificación de texto y coincidencia de similitud de texto. En comparación con los marcos actuales de uso común en la industria, puede admitir a los usuarios a implementar una implementación funcional rápida: no solo puede cumplir con la personalización profunda de los modelos por parte de los usuarios avanzados, sino que también permite a los usuarios comunes usar rápidamente modelos previamente capacitados para practicar rápidamente la práctica funcional. En el escenario comercial actual de publicidad de productos, utilizamos esta herramienta para explorar rápidamente las características de los datos de productos masivos, lo que respalda módulos como las recomendaciones de los productos publicitarios.
La intención original del proyecto es proporcionar un conjunto de herramientas de PNL fáciles de usar, que están directamente dirigidas a los escenarios de uso y satisfacer las necesidades de los usuarios para las tareas de PNL, para que los usuarios no necesiten lidiar con el preprocesamiento complejo y otros procesos intermedios, y completar directamente múltiples tareas de PNL para el texto de lenguaje natural de entrada, que piensan lo que piensan!
¿Qué es Fancy? Para muchas tareas actuales de NLP, como el reconocimiento de entidad nombrado (NER), la clasificación de texto y la coincidencia de similitud de texto (coincidencia de pares de oraciones (SPM), la mayoría de las herramientas están diseñadas para favorecer la capacitación y la evaluación del modelo. Cuando los usuarios comunes desean aplicar estos modelos a los escenarios comerciales reales, a menudo deben realizar una configuración de preprocesos complejos y las configuraciones de implementaciones, que a menudo no pueden cumplir con sus usuarios de los usuarios. Enlace de la tarea NLP en Fancy-NLP, y aplique eficientemente el modelo a los escenarios de demanda reales.
Fancy-NLP es actualmente compatible para su uso en entornos Python 3 y se ha probado completamente en Python 3.6. Tensorflow 2.x depende completamente de la versión actual. Si tiene alguna inquietud sobre la compatibilidad del módulo, le recomendamos que use VirtualEnv para crear un entorno virtual para usar esta herramienta.
Fancy-NLP admite una instalación de un clic utilizando pip :
pip install fancy-nlpEn la guía de inicio, utilizaremos modelos previamente capacitados para llevarlo a comprender y experimentar rápidamente las funciones básicas de Fancy-NP.
Nota: Continuaremos optimizando el modelo de reconocimiento de entidad de múltiples escenarios (datos anotados diferentes) para que los usuarios los usen directamente. Si tiene conjuntos de datos relevantes, también puede darnos comentarios positivos en el tema.
La versión actual de Fancy-NLP puede cargar el modelo NER capacitado utilizando los datos de subconjunto MSRA NER de forma predeterminada. Puede identificar estructuras organizacionales (ORG), ubicaciones (LOC) y personas (por) entidades en texto chino. El modelo básico cargado de forma predeterminada es que los usuarios experimenten directamente. Si desea utilizar su propio modelo personalizado directamente, puede consultar la introducción en el tutorial detallado posterior para construir su sistema de extracción de entidad.
> >> from fancy_nlp . applications import NER
> >> ner_app = NER ()Cuando ejecuta el código anterior por primera vez, el modelo NER previamente entrenado se descargará desde la nube.
> >> ner_app . analyze ( '同济大学位于上海市杨浦区，校长为陈杰' )
{ 'text' : '同济大学位于上海市杨浦区，校长为陈杰' ,
'entities' : [
{ 'name' : '同济大学' ,
'type' : 'ORG' ,
'score' : 1.0 ,
'beginOffset' : 0 ,
'endOffset' : 4 },
{ 'name' : '上海市' ,
'type' : 'LOC' ,
'score' : 1.0 ,
'beginOffset' : 6 ,
'endOffset' : 9 },
{ 'name' : '杨浦区' ,
'type' : 'LOC' ,
'score' : 1.0 ,
'beginOffset' : 9 ,
'endOffset' : 12 },
{ 'name' : '陈杰' ,
'type' : 'PER' ,
'score' : 1.0 ,
'beginOffset' : 16 ,
'endOffset' : 18 }]} > >> ner_app . restrict_analyze ( '同济大学位于上海市杨浦区，校长为陈杰' )
{ 'text' : '同济大学位于上海市杨浦区，校长为陈杰' ,
'entities' : [
{ 'name' : '同济大学' ,
'type' : 'ORG' ,
'score' : 1.0 ,
'beginOffset' : 0 ,
'endOffset' : 4 },
{ 'name' : '杨浦区' ,
'type' : 'LOC' ,
'score' : 1.0 ,
'beginOffset' : 9 ,
'endOffset' : 12 },
{ 'name' : '陈杰' ,
'type' : 'PER' ,
'score' : 1.0 ,
'beginOffset' : 16 ,
'endOffset' : 18 }]} >>> ner_app.predict('同济大学位于上海市杨浦区，校长为陈杰')
['B-ORG',
'I-ORG',
'I-ORG',
'I-ORG',
'O',
'O',
'B-LOC',
'I-LOC',
'I-LOC',
'B-LOC',
'I-LOC',
'I-LOC',
'O',
'O',
'O',
'O',
'B-PER',
'I-PER']
Fancy-NLP se carga de forma predeterminada con el modelo de clasificación de texto capacitado en el conjunto de datos de clasificación de título de noticias chino actualmente publicado, que puede predecir la categoría de noticias a la que pertenece para el texto del título de noticias.
> >> from fancy_nlp . applications import TextClassification
> >> text_classification_app = TextClassification ()Cuando ejecuta el programa anterior por primera vez, el modelo previamente entrenado se descargará de la nube.
> >> text_classification_app . predict ( '苹果iOS占移动互联网流量份额逾65% 位居第一' )
'科技' > >> text_classification_app . analyze ( '苹果iOS占移动互联网流量份额逾65% 位居第一' )
( '科技' , 0.9996544 )Fancy-NLP se carga de forma predeterminada en el modelo de coincidencia de similitud de texto capacitado en el conjunto de datos de coincidencia de preguntas de servicio al cliente de Webank publicado actualmente, que puede predecir si expresa la misma intención para los pares de texto proporcionados.
> >> from fancy_nlp . applications import SPM
> >> spm_app = SPM ()Cuando ejecuta el programa anterior por primera vez, el modelo de coincidencia de similitud de texto previamente entrenado se descargará desde la nube.
> >> spm_app . predict (( '未满足微众银行审批是什么意思' , '为什么我未满足微众银行审批' ))
'1' En el resultado de la predicción, 1 representa la misma intención o texto similar, 0 representa la intención diferente o el texto diferente.
> >> spm_app . analyze (( '未满足微众银行审批是什么意思' , '为什么我未满足微众银行审批' ))
( '1' , array ([ 1.6599501e-09 , 1.0000000e+00 ], dtype = float32 ))En el tutorial detallado , puede aprender a usar Fancy-NLP para crear modelos personalizados que cumplan con escenarios personalizados utilizando sus propios conjuntos de datos y tener una comprensión más completa de la interfaz Fancy-NLP.
Para experimentar completamente el siguiente tutorial, debe descargar el modelo de conjunto de datos y el modelo Bert que utilizamos:
86geqk7e6rb7 Puede mover los datos descargados al mismo nivel que el directorio examples , y la estructura final del directorio es la siguiente:
.
├── datasets
│ ├── ner
│ │ └── msra
│ │ ├── test_data
│ │ └── train_data
│ ├── spm
│ │ └── webank
│ │ ├── BQ_dev.txt
│ │ ├── BQ_test.txt
│ │ └── BQ_train.txt
│ └── text_classification
│ └── toutiao
│ ├── toutiao_cat_data.txt
│ └── toutiao_label_dict.txt
├── examples
│ ├── bert_combination.py
│ ├── bert_fine_tuning.py
│ ├── bert_single.py
│ ├── ner_example.py
│ ├── spm_example.py
│ └── text_classification_example.py
└── pretrained_embeddings
└── chinese_L-12_H-768_A-12
├── bert_config.json
├── bert_model.ckpt.data-00000-of-00001
├── bert_model.ckpt.index
├── bert_model.ckpt.meta
└── vocab.txt
Para que pueda ejecutar el programa de muestra directamente. Por ejemplo, python examples/ner_example.py .
Todavía usamos los datos del subconjunto MSRA mencionados anteriormente como un ejemplo para introducir cómo usar conjuntos de datos existentes para capacitar a nuestro propio modelo de reconocimiento de entidad. Para obtener una versión completa de todos los siguientes fragmentos de código, consulte examples/ner_example.py .
En Fancy-NP-NP, las aplicaciones de reconocimiento de entidades admiten el uso de formatos de conjunto de datos NER estándar, cada carácter a identificar y su etiqueta correspondiente está separada por t , y las oraciones están separadas por líneas en blanco. El formato de la etiqueta puede ser un formato estándar común, como BIO y BIOES .
Usando la interfaz proporcionada por Fancy-NLP, podemos cargar directamente el conjunto de datos y procesarlo en el formato requerido por el modelo.
from fancy_nlp . applications import NER
ner_app = NER ( use_pretrained = False )
from fancy_nlp . utils import load_ner_data_and_labels
train_data , train_labels = load_ner_data_and_labels ( 'datasets/ner/msra/train_data' )
valid_data , valid_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' ) load_ner_data_and_labels implementa una carga efectiva de conjuntos de datos NER. Puede usar directamente la ruta de archivo de los datos (conjunto de capacitación, conjunto de validación o conjunto de pruebas) para cargar como parámetros. El conjunto de pruebas se usa como conjunto de validación. En las tareas reales, debe tener sus propios conjuntos de validación independiente y conjuntos de pruebas para obtener valiosos resultados de evaluación de pruebas.
Después de obtener datos válidos, la aplicación NER puede comenzar a capacitar el modelo directamente.
checkpoint_dir = 'pretrained_models'
model_name = 'msra_ner_bilstm_cnn_crf'
ner_app . fit ( train_data , train_labels , valid_data , valid_labels ,
ner_model_type = 'bilstm_cnn' ,
char_embed_trainable = True ,
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = checkpoint_dir ,
model_name = model_name ,
load_swa_model = True ) Para la interfaz fit de la aplicación NER, debe aprobar el conjunto de capacitación y las muestras del conjunto de validación que se han procesado antes. Los significados de los parámetros restantes son los siguientes:
ner_model_type : indica el nombre del modelo que se utilizará. En este ejemplo, se usa el modelo bilstm_cnn ;char_embed_trainable : si la capa de vector de palabras puede ser un ajuste fino. En este ejemplo, se establece en True , lo que indica que se puede realizar un ajuste fino;callback_list : el nombre de la función de devolución de llamada que debe usarse. Las funciones de devolución de llamada utilizadas en este ejemplo son:modelcheckpoint : use la función de punto de control modelo. Después de cada iteración, guarde el modelo entrenado;earlystopping : Use la función de parada temprana. Si el rendimiento del modelo no mejora después de N iteraciones redondas (predeterminado n = 5), la capacitación se finalizará;swa : SWA significa promedio de peso estocástico, que es una estrategia de integración del modelo común que puede mejorar efectivamente el rendimiento del modelo. Para obtener más detalles, consulte la introducción en el documento original;checkpoint_dir : la ruta del directorio para guardar el archivo del modelo;model_name : el nombre del archivo del archivo modelo;load_swa_model : si cargar el peso del modelo SWA después de que el modelo esté entrenado. Establecer en True aquí, indicando el uso del modelo SWA; test_data , test_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' )
ner_app . score ( test_data , test_labels ) Aquí, load_ner_data_and_labels todavía se usa para procesar los datos del conjunto de pruebas. Después de obtener un formato de datos válido, use la interfaz score de la aplicación NER para obtener la puntuación del modelo en el conjunto de pruebas.
Después de capacitar al modelo, todos los archivos relacionados con el modelo requeridos por la tarea deben guardarse para facilitar el uso de modelos fantasmas-capacitados en NLP en otras aplicaciones externas.
import os
ner_app . save (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' )) La interfaz save de la aplicación NER se puede utilizar para persistir el archivo de estructura del modelo (JSON), el archivo de peso (HDF5) y los resultados relacionados con el preprocesamiento (Pickle):
modelcheckpoint ; ner_app . load (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' ),
weights_file = os . path . join ( checkpoint_dir , f' { model_name } _swa.hdf5' )) En este momento, ner_app ya tiene la capacidad de predecir muestras, y puede completar las funciones de predicción relevantes mencionadas en la Guía introductoria . Por ejemplo, analyze , restrict_analyze .
Todavía usamos el conjunto de datos de clasificación de títulos de noticias chino mencionado anteriormente como un ejemplo para introducir cómo usar el conjunto de datos existente para capacitar a nuestro propio modelo de clasificación de texto. Para obtener una versión completa de todos los siguientes fragmentos de código, consulte examples/text_classification_example.py .
En Fancy-NLP, las aplicaciones de clasificación de texto admiten formatos de conjunto de datos separados por delimitadores fijos que usan texto original. Pueden tener columnas redundantes que son independientes de las tareas de clasificación de texto. Solo necesitan asegurarse de que tanto la columna de etiqueta como la columna de texto de entrada estén en una posición fija unificada.
Además, para las etiquetas de clasificación, también se requiere un archivo de asignación de etiquetas e ID de etiquetas, que consta de dos columnas: la primera columna es el nombre original de la etiqueta en el conjunto de datos, generalmente algunas ID codificadas; La segunda columna es el nombre legible correspondiente al nombre original de la etiqueta. La correspondencia de este archivo se utilizará para emitir directamente los nombres de etiquetas legibles cuando se predice el modelo.
Usando la interfaz proporcionada por Fancy-NLP, podemos cargar directamente el conjunto de datos y procesarlo en el formato requerido por el modelo.
from fancy_nlp . applications import TextClassification
text_classification_app = TextClassification ( use_pretrained = False )
data_file = 'datasets/text_classification/toutiao/toutiao_cat_data.txt'
from fancy_nlp . utils import load_text_classification_data_and_labels
train_data , train_labels , valid_data , valid_labels , test_data , test_labels =
load_text_classification_data_and_labels ( data_file ,
label_index = 1 ,
text_index = 3 ,
delimiter = '_!_' ,
split_mode = 2 ,
split_size = 0.3 ) load_ner_data_and_labels implementa una carga efectiva de conjuntos de datos de clasificación de texto. Puede usar directamente la ruta de archivo de los datos (conjunto de capacitación, conjunto de validación o conjunto de pruebas) para cargar como parámetros. Los datos completos se usan aquí para dividir el conjunto de capacitación, el conjunto de validación y el conjunto de pruebas. Además del archivo de datos, el significado específico de los parámetros restantes anteriores es:
label_index : la posición de la etiqueta de clasificación en el archivo de datos (el número de posición comienza desde 0);text_index : la ubicación del texto que se clasificará en el archivo de datos;delimiter : el separador entre columnas del archivo de datos;split_mode : indica cómo dividir los datos originales cambiando los parámetros. en:split_size : relación de división de datos. Cuando split_mode=1 , significa que los datos que dividen split_size de los datos originales se utilizarán como el conjunto de verificación; Cuando split_mode=2 , significa que los datos que dividen split_size de los datos originales se utilizarán como la suma del conjunto de verificación y el conjunto de pruebas, y las proporciones del conjunto de verificación y el conjunto de pruebas cada cuenta para la mitad. Después de obtener datos válidos, la aplicación de clasificación de texto puede comenzar a capacitar el modelo directamente.
dict_file = 'datasets/text_classification/toutiao/toutiao_label_dict.txt'
model_name = 'toutiao_text_classification_cnn'
checkpoint_dir = 'pretrained_models'
text_classification_app . fit (
train_data , train_labels , valid_data , valid_labels ,
text_classification_model_type = 'cnn' ,
char_embed_trainable = True ,
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = checkpoint_dir ,
model_name = model_name ,
label_dict_file = dict_file ,
max_len = 60 ,
load_swa_model = True ) Para la interfaz fit de una aplicación de clasificación de texto, debe aprobar el conjunto de capacitación y las muestras del conjunto de validación que se han procesado antes. Los significados de los parámetros restantes son los siguientes:
text_classification_model_type : indica el nombre del modelo que se utilizará. En este ejemplo, se usa el modelo cnn ;char_embed_trainable : si la capa de vector de palabras puede ser un ajuste fino. En este ejemplo, se establece en True , lo que indica que se puede realizar un ajuste fino;callback_list : el nombre de la función de devolución de llamada que debe usarse. Las funciones de devolución de llamada utilizadas en este ejemplo son:modelcheckpoint : use la función de punto de control modelo. Después de cada iteración, guarde el modelo entrenado;earlystopping : Use la función de parada temprana. Si el rendimiento del modelo no mejora después de N iteraciones redondas (predeterminado n = 5), la capacitación se finalizará;swa : SWA significa promedio de peso estocástico, que es una estrategia de integración del modelo común que puede mejorar efectivamente el rendimiento del modelo. Para obtener más detalles, consulte la introducción en el documento original;checkpoint_dir : la ruta del directorio para guardar el archivo del modelo;model_name : el nombre del archivo del archivo modelo;label_dict_file : un archivo de diccionario de etiqueta, que consta de dos columnas: la primera columna es el nombre original de la etiqueta en el conjunto de datos, generalmente algunas ID codificadas; La segunda columna es el nombre legible correspondiente al nombre original de la etiqueta;max_len : para la longitud máxima retenida por el texto de entrada, el texto más allá de esa longitud se truncará;load_swa_model : si cargar el peso del modelo SWA después de que el modelo esté entrenado. Establecer en True aquí, indicando el uso del modelo SWA; text_classification_app . score ( test_data , test_labels ) Aquí puede usar directamente la interfaz score de la aplicación de clasificación de texto para obtener la puntuación del modelo en el conjunto de pruebas.
Después de capacitar al modelo, todos los archivos relacionados con el modelo requeridos por la tarea deben guardarse para facilitar el uso de modelos fantasmas-capacitados en NLP en otras aplicaciones externas.
import os
text_classification_app . save (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' )) La interfaz save de las aplicaciones de clasificación de texto se puede utilizar para persistir el archivo de estructura del modelo (JSON), el archivo de peso (HDF5) y los resultados relacionados con el preprocesamiento (Pickle):
modelcheckpoint . text_classification_app . load (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' ),
weights_file = os . path . join ( checkpoint_dir , f' { model_name } _swa.hdf5' )) En este momento, text_classification_app ya tiene la capacidad de predecir muestras, y puede completar las funciones de predicción relevantes mencionadas en la Guía introductoria . Por ejemplo, predict , analyze .
Todavía usamos el conjunto de datos de coincidencia de la pregunta de servicio al cliente de Webank mencionado anteriormente como un ejemplo para introducir cómo usar el conjunto de datos existente para capacitar nuestro propio modelo de coincidencia de similitud de texto. Para obtener una versión completa de todos los siguientes fragmentos de código, consulte examples/spm_example.py .
En Fancy-NP-NP, la aplicación de tareas de coincidencia de similitud de texto admite el uso de texto original en un formato de conjunto de datos separado por t , que consta de tres columnas: la primera columna y la segunda columna son un conjunto de pares de texto respectivamente; La tercera columna es una etiqueta de muestra, 1 significa que la semántica de texto es similar y 0 significa diferente.
Usando la interfaz proporcionada por Fancy-NLP, podemos cargar directamente el conjunto de datos y procesarlo en el formato requerido por el modelo.
from fancy_nlp . applications import SPM
spm_app = applications . SPM ( use_pretrained = False )
train_file = 'datasets/spm/webank/BQ_train.txt'
valid_file = 'datasets/spm/webank/BQ_dev.txt'
from fancy_nlp . utils import load_spm_data_and_labels
train_data , train_labels = load_spm_data_and_labels ( train_file )
valid_data , valid_labels = load_spm_data_and_labels ( valid_file ) load_spm_data_and_labels implementa una carga efectiva de conjuntos de datos de coincidencia de similitud de texto. Puede usar directamente la ruta de archivo de los datos (conjunto de capacitación, conjunto de validación o conjunto de pruebas) para cargar como parámetros.
Después de obtener datos válidos, la aplicación de coincidencia de similitud de texto puede comenzar a capacitar el modelo directamente.
model_name = 'spm_siamese_cnn'
checkpoint_dir = 'pretrained_models'
spm_app . fit ( train_data , train_labels , valid_data , valid_labels ,
spm_model_type = 'siamese_cnn' ,
word_embed_trainable = True ,
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = checkpoint_dir ,
model_name = model_name ,
max_len = 60 ,
load_swa_model = True ) Para la interfaz fit de la aplicación de similitud de texto, debe aprobar las muestras del conjunto de entrenamiento y validación que se han procesado antes. El significado de los parámetros restantes es el siguiente:
spm_model_type : indica el nombre del modelo que se utilizará. En este ejemplo, se usa el modelo siamese_cnn ;word_embed_trainable : si la capa de vector de palabras puede ser un ajuste fino. En este ejemplo, se establece en True , lo que indica que se puede realizar un ajuste fino;callback_list : el nombre de la función de devolución de llamada que debe usarse. Las funciones de devolución de llamada utilizadas en este ejemplo son:modelcheckpoint : use la función de punto de control modelo. Después de cada iteración, guarde el modelo entrenado;earlystopping : Use la función de parada temprana. Si el rendimiento del modelo no mejora después de N iteraciones redondas (predeterminado n = 5), la capacitación se finalizará;swa : SWA significa promedio de peso estocástico, que es una estrategia de integración del modelo común que puede mejorar efectivamente el rendimiento del modelo. Para obtener más detalles, consulte la introducción en el documento original;checkpoint_dir : la ruta del directorio para guardar el archivo del modelo;model_name : el nombre del archivo del archivo modelo;max_len : para la longitud máxima retenida por el texto de entrada, el texto más allá de esa longitud se truncará;load_swa_model : si cargar el peso del modelo SWA después de que el modelo esté entrenado. Establecer en True aquí, indicando el uso del modelo SWA; test_file = 'datasets/spm/webank/BQ_test.txt'
test_data , test_labels = load_spm_data_and_labels ( test_file )
spm_app . score ( test_data , test_labels ) Aquí puede usar directamente la interfaz score de aplicación de coincidencia de similitud de texto para obtener la puntuación del modelo en el conjunto de pruebas.
Después de capacitar al modelo, todos los archivos relacionados con el modelo requeridos por la tarea deben guardarse para facilitar el uso de modelos fantasmas-capacitados en NLP en otras aplicaciones externas.
import os
spm_app . save (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' )) La interfaz save de la aplicación de coincidencia de similitud de texto se puede utilizar para persistir el archivo de estructura del modelo (JSON), el archivo de peso (HDF5) y los resultados relacionados con el preprocesamiento (Pickle):
modelcheckpoint . spm_app . load (
preprocessor_file = os . path . join ( checkpoint_dir , f' { model_name } _preprocessor.pkl' ),
json_file = os . path . join ( checkpoint_dir , f' { model_name } .json' ),
weights_file = os . path . join ( checkpoint_dir , f' { model_name } _swa.hdf5' )) En este momento, spm_app ya tiene la capacidad de predecir muestras, y puede continuar completando las funciones de predicción relevantes mencionadas en la Guía introductoria . Por ejemplo, predict , analyze .
FACNY-NLP proporciona varios métodos para usar el modelo BERT :
Para usar Bert en Fancy-NLP, solo necesita descargar el modelo Bert pre-entrenado (como el modelo Bert chino proporcionado por Google, el modelo Ernie proporcionado por Baidu (código de extracción: IQ74) y el modelo Bert-WWM proporcionado por el Harbin Institute of Technology). Después de eso, puede pasar la ruta del archivo de vocabulario, el archivo de configuración y el archivo de modelado del modelo Bert en fit de la aplicación relevante. El siguiente es un ejemplo de la aplicación de reconocimiento de entidad. Para ver el código de ejemplo completo, consulte examples/bert_fine_tuning.py , examples/bert_single.py , y examples/bert_combination.py .
Tenga en cuenta que el modelo Bert solo se puede usar con vectores de caracteres, no con vectores de palabras.
import tensorflow as tf
from fancy_nlp . applications import NER
ner_app = NER ( use_pretrained = False )
from fancy_nlp . utils import load_ner_data_and_labels
train_data , train_labels = load_ner_data_and_labels ( 'datasets/ner/msra/train_data' )
valid_data , valid_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' )
ner_app . fit ( train_data , train_labels , valid_data , valid_labels ,
ner_model_type = 'bert' ,
use_char = False ,
use_word = False ,
use_bert = True ,
bert_vocab_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/vocab.txt' ,
bert_config_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_config.json' ,
bert_checkpoint_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_model.ckpt' ,
bert_trainable = True ,
optimizer = tf . keras . optimizers . Adam ( 1e-5 ),
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = 'pretrained_models' ,
model_name = 'msra_ner_bert_crf' ,
load_swa_model = True )En el fragmento de código anterior, es importante tener en cuenta:
ner_model_type : configure el tipo de modelo en bert ;use_char : establezca no para usar vectores a nivel de personaje;use_word : establezca no para usar vectores de nivel de palabra como entrada auxiliar;use_bert : al ajustar el modelo Bert, configurado para usar solo la entrada Bert;bert_vocab_file , bert_config_file , bert_checkpoint_file : la ruta a los archivos relacionados con el modelo Bertbert_trainable : establezca los parámetros del modelo Bert en estado capacitable, es decir, ajuste;optimizer : configure el optimizador para el modelo Bert. Al ajustar el modelo Bert, la tasa de aprendizaje del optimizador debe ajustarse a un nivel más pequeño. from fancy_nlp . applications import NER
ner_app = NER ( use_pretrained = False )
from fancy_nlp . utils import load_ner_data_and_labels
train_data , train_labels = load_ner_data_and_labels ( 'datasets/ner/msra/train_data' )
valid_data , valid_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' )
ner_app . fit ( train_data , train_labels , valid_data , valid_labels ,
ner_model_type = 'bilstm_cnn' ,
use_char = False ,
use_word = False ,
use_bert = True ,
bert_vocab_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/vocab.txt' ,
bert_config_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_config.json' ,
bert_checkpoint_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_model.ckpt' ,
bert_trainable = False ,
optimizer = 'adam' ,
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = 'pretrained_models' ,
model_name = 'msra_ner_bilstm_cnn_bert_crf' ,
load_swa_model = True )En el fragmento de código anterior, es importante tener en cuenta:
ner_model_type : configure el tipo de modelo en bilstm_cnn , y se debe usar un modelo que no sea Berten;use_char : establezca no para usar vectores a nivel de personaje;use_word : establezca no para usar vectores de nivel de palabra como entrada auxiliar;use_bert : establecer para usar solo los vectores Bert como entrada de características;bert_vocab_file , bert_config_file , bert_checkpoint_file : la ruta a los archivos relacionados con el modelo Bertbert_trainable : establezca el parámetro del modelo Bert en un estado no comercializable, y también es posible establecerlo en True aquí;optimizer : configure el optimizador. Si el modelo BET es capacitable, se recomienda ajustar la tasa de aprendizaje del optimizador a uno más pequeño. import tensorflow as tf
from fancy_nlp . applications import NER
ner_app = NER ( use_pretrained = False )
from fancy_nlp . utils import load_ner_data_and_labels
train_data , train_labels = load_ner_data_and_labels ( 'datasets/ner/msra/train_data' )
valid_data , valid_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' )
ner_app . fit ( train_data , train_labels , valid_data , valid_labels ,
ner_model_type = 'bilstm_cnn' ,
use_char = True ,
use_word = False ,
use_bert = True ,
bert_vocab_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/vocab.txt' ,
bert_config_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_config.json' ,
bert_checkpoint_file = 'pretrained_embeddings/chinese_L-12_H-768_A-12/bert_model.ckpt' ,
bert_trainable = True ,
optimizer = tf . keras . optimizers . Adam ( 1e-5 ),
callback_list = [ 'modelcheckpoint' , 'earlystopping' , 'swa' ],
checkpoint_dir = 'pretrained_models' ,
model_name = 'msra_ner_bilstm_cnn_char_bert_crf' ,
load_swa_model = True )En el fragmento de código anterior, es importante tener en cuenta:
ner_model_type : configure el tipo de modelo en bilstm_cnn , y se debe usar un modelo que no sea Berten;use_char : establezca el vector de nivel de caracteres use;use_word : establezca no para usar vectores de nivel de palabra como entrada auxiliar;use_bert : establezca el uso de Bert Vector, que combina vectores de palabras y vectores Bert como entradas de características;bert_vocab_file , bert_config_file , bert_checkpoint_file : la ruta a los archivos relacionados con el modelo Bertbert_trainable : establezca los parámetros del modelo Bert en estado capacitable, y también es posible establecerlo en False aquí;optimizer : configure el optimizador. Si el modelo BET es capacitable, se recomienda ajustar la tasa de aprendizaje del optimizador a uno más pequeño. Los desarrolladores interesados en mejorar el código NLP elegante deben seguir las siguientes especificaciones para enviar solicitudes de extracción:
Si usa NLP elegante durante el proceso de investigación relacionado, puede agregar lo siguiente a la lista de citas
@misc{tencent2019fancynlp,
title={Fancy-NLP},
author={Li Yang and Shiyao Xu and Shijia E},
howpublished={ url {https://github.com/boat-group/fancy-nlp}},
year={2019}
}▴ De vuelta a la cima
Este proyecto está inspirado en muchos excelentes proyectos de código abierto, especialmente Keras. Como dijo el eslogan de Keras: el aprendizaje profundo para humanos , esperamos que la PNL elegante sea la PNL para los humanos , especialmente en el campo chino.
