fancy nlp
1.0.0
NLP pour humain. Une boîte à outils rapide et facile à utiliser le traitement du langage naturel (NLP), satisfaisant votre imagination à propos de la PNL.
→ Version anglaise
Introduction de base • Installation • Guide de démarrage • Tutoriel détaillé • Honours • Comment contribuer le code • Citations • Remerciements
Fancy-NLP est un outil d'exploration de connaissances de texte pour construire des portraits de produits construits par l'équipe de stratégie de publicité des produits de Tencent. Il prend en charge une variété de tâches NLP communes telles que l'extraction des entités, la classification du texte et la correspondance de similitude de texte. Par rapport aux cadres couramment utilisés dans l'industrie, il peut aider les utilisateurs à mettre en œuvre une implémentation fonctionnelle rapide: il peut non seulement répondre à la personnalisation profonde des modèles par des utilisateurs avancés, mais également permettre aux utilisateurs ordinaires d'utiliser rapidement des modèles pré-formés pour pratiquer rapidement la pratique fonctionnelle. Dans le scénario de publicité actuel de la publicité, nous utilisons cet outil pour explorer rapidement les caractéristiques des données de produits massives, prenant ainsi en charge les modules tels que les recommandations de produits publicitaires.
L'intention initiale du projet est de fournir un ensemble d'outils NLP faciles à utiliser, qui visent directement les scénarios d'utilisation et répondent aux besoins des utilisateurs pour les tâches PNL, afin que les utilisateurs n'aient pas besoin de gérer le prétraitement complexe et d'autres processus intermédiaires, et de terminer directement les multiples tâches NLP pour le texte du langage naturel d'entrée, la réalisation de ce qu'ils obtiennent!
Qu'est-ce que Fancy? Pour de nombreuses tâches NLP actuelles, telles que la reconnaissance de l'entité nommée (NER), la classification du texte et la correspondance de similitude de texte (correspondance de la paire de phrases (SPM), la plupart des outils sont conçus pour favoriser la formation et l'évaluation du modèle. Chaque lien de la tâche NLP dans Fancy-NLP et appliquez efficacement le modèle aux scénarios de demande réels.
Fancy-NLP est actuellement pris en charge pour une utilisation dans les environnements Python 3 et a été entièrement testé dans Python 3.6. TensorFlow 2.x dépend entièrement de la version actuelle. Si vous avez des préoccupations concernant la compatibilité des modules, nous vous recommandons d'utiliser VirtualEnv pour créer un environnement virtuel pour utiliser cet outil.
Fancy-NLP prend en charge l'installation en un clic à l'aide pip :
pip install fancy-nlpDans le guide de démarrage, nous utiliserons des modèles pré-formés pour vous emmener pour comprendre et vivre rapidement les fonctions de base de la Fancy-NP.
Remarque: Nous continuerons d'optimiser le modèle de reconnaissance des entités de plusieurs scénarios (différentes données annotées) pour que les utilisateurs puissent utiliser directement. Si vous avez des ensembles de données pertinents, vous êtes également invités à nous donner des commentaires positifs dans le problème.
La version actuelle de Fancy-NP peut charger le modèle NER formé à l'aide de données de sous-ensemble MSRA NER par défaut. Il peut identifier les structures organisationnelles (ORG), les emplacements (LOCS) et les personnes (PER) entités en texte chinois. Le modèle de base chargé par défaut est que les utilisateurs puissent vivre directement. Si vous souhaitez utiliser directement votre propre modèle personnalisé, vous pouvez vous référer à l'introduction dans le tutoriel détaillé ultérieur pour créer votre système d'extraction d'entité.
> >> from fancy_nlp . applications import NER
> >> ner_app = NER ()Lorsque vous exécutez le code ci-dessus pour la première fois, le modèle NER pré-formé sera téléchargé à partir du cloud.
> >> 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 est chargé par défaut avec le modèle de classification de texte formé dans l'ensemble de données de classification des titres de nouvelles chinois actuellement publié, qui peut prédire la catégorie des nouvelles à laquelle il appartient pour le texte du titre de l'information.
> >> from fancy_nlp . applications import TextClassification
> >> text_classification_app = TextClassification ()Lorsque vous exécutez le programme ci-dessus pour la première fois, le modèle pré-formé sera téléchargé à partir du cloud.
> >> text_classification_app . predict ( '苹果iOS占移动互联网流量份额逾65% 位居第一' )
'科技' > >> text_classification_app . analyze ( '苹果iOS占移动互联网流量份额逾65% 位居第一' )
( '科技' , 0.9996544 )Fancy-NLP est chargé par défaut dans le modèle de correspondance de similitude de texte formé dans l'ensemble de données correspondant à la question du service client Webank actuellement publié, qui peut prédire s'il exprime la même intention pour les paires de texte fournies.
> >> from fancy_nlp . applications import SPM
> >> spm_app = SPM ()Lorsque vous exécutez le programme ci-dessus pour la première fois, le modèle de correspondance de similitude de texte pré-formé sera téléchargé à partir du cloud.
> >> spm_app . predict (( '未满足微众银行审批是什么意思' , '为什么我未满足微众银行审批' ))
'1' Dans le résultat de prédiction, 1 représente la même intention ou le même texte similaire, 0 représente l'intention différente ou le texte différent.
> >> spm_app . analyze (( '未满足微众银行审批是什么意思' , '为什么我未满足微众银行审批' ))
( '1' , array ([ 1.6599501e-09 , 1.0000000e+00 ], dtype = float32 ))Dans le didacticiel détaillé , vous pouvez apprendre à utiliser Fancy-NLP pour créer des modèles personnalisés qui répondent à des scénarios personnalisés à l'aide de vos propres ensembles de données et ont une compréhension plus complète de l'interface de Fancy-NP.
Pour expérimenter pleinement le tutoriel suivant, vous devez télécharger l'ensemble de données et le modèle Bert que nous utilisons:
86geqk7e6rb7 Vous pouvez déplacer les données téléchargées au même niveau que le répertoire examples , et la structure du répertoire final est la suivante:
.
├── 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
Vous pouvez donc exécuter directement l'exemple du programme. Par exemple, python examples/ner_example.py .
Nous utilisons toujours les données du sous-ensemble MSRA NER mentionnées ci-dessus comme exemple pour introduire comment utiliser les ensembles de données existants pour former notre propre modèle de reconnaissance d'entité. Pour une version complète de tous les extraits de code suivants, veuillez vous référer aux examples/ner_example.py .
Dans Fancy-NLP, les applications de reconnaissance d'entités prennent en charge l'utilisation de formats de jeu de données NER standard, chaque caractère à identifier et sa balise correspondante est séparée par t , et les phrases sont séparées par des lignes vides. Le format de la balise peut être un format standard commun tel que BIO et BIOES .
En utilisant l'interface fournie par Fancy-NP, nous pouvons charger directement l'ensemble de données et le traiter dans le format requis par le modèle.
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 implémente le chargement efficace des ensembles de données NER. Vous pouvez utiliser directement le chemin du fichier des données (ensemble de formation, jeu de validation ou jeu de test) pour être chargé en tant que paramètres. L'ensemble de tests est utilisé comme ensemble de validation. Dans les tâches réelles, vous devriez avoir leurs propres ensembles de validation indépendants et ensembles de tests pour obtenir des résultats d'évaluation de test précieux.
Après avoir obtenu des données valides, l'application NER peut commencer à former directement le modèle.
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 ) Pour l'interface fit de l'application NER, vous devez passer dans l'ensemble de formation et les échantillons d'ensemble de validation qui ont déjà été traités. Les significations des paramètres restants sont les suivants:
ner_model_type : indique le nom du modèle à utiliser. Dans cet exemple, le modèle bilstm_cnn est utilisé;char_embed_trainable : si la couche vectorielle de mot peut être un réglage fin. Dans cet exemple, il est défini sur True , indiquant que le réglage fin peut être effectué;callback_list : le nom de la fonction de rappel qui doit être utilisé. Les fonctions de rappel utilisées dans cet exemple sont:modelcheckpoint : utilisez la fonction de point de contrôle du modèle. Après chaque itération, sauvez le modèle formé;earlystopping : utilisez la fonction d'arrêt précoce. Si les performances du modèle ne s'améliorent pas après n itérations rondes (par défaut n = 5), la formation sera terminée;swa : SWA signifie la moyenne du poids stochastique, qui est une stratégie d'intégration de modèle courante qui peut efficacement améliorer les performances du modèle. Pour plus de détails, veuillez vous référer à l'introduction dans le document d'origine;checkpoint_dir : le chemin du répertoire pour enregistrer le fichier du modèle;model_name : le nom de fichier du fichier modèle;load_swa_model : s'il faut charger le poids du modèle SWA après la formation du modèle. Réglé sur True ici, indiquant l'utilisation du modèle SWA; test_data , test_labels = load_ner_data_and_labels ( 'datasets/ner/msra/test_data' )
ner_app . score ( test_data , test_labels ) Ici, load_ner_data_and_labels est toujours utilisé pour traiter les données des tests de test. Après avoir obtenu un format de données valide, utilisez l'interface score de l'application NER pour obtenir le score du modèle dans l'ensemble de tests.
Après avoir entraîné le modèle, tous les fichiers liés au modèle requis par la tâche doivent être enregistrés pour faciliter l'utilisation de modèles formés en NLP dans d'autres applications externes.
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' )) L'interface save de l'application NER peut être utilisée pour persister le fichier de structure du modèle (JSON), le fichier de poids (HDF5) et les résultats liés au prétraitement (cornichon):
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' )) À l'heure actuelle, ner_app a déjà la capacité de prédire des échantillons, et vous pouvez remplir les fonctions de prédiction pertinentes mentionnées dans le guide d'introduction . Par exemple, analyze , restrict_analyze .
Nous utilisons toujours l'ensemble de données de classification des titres de nouvelles chinois mentionné ci-dessus comme exemple pour présenter comment utiliser l'ensemble de données existant pour former notre propre modèle de classification de texte. Pour une version complète de tous les extraits de code suivants, veuillez vous référer aux examples/text_classification_example.py .
Dans Fancy-NLP, les applications de classification de texte prennent en charge les formats de jeu de données séparés par des délimiteurs fixes à l'aide du texte d'origine. Ils peuvent avoir des colonnes redondantes qui sont indépendantes des tâches de classification du texte. Ils ont seulement besoin de s'assurer que la colonne d'étiquette et la colonne de texte d'entrée sont en position fixe unifiée.
De plus, pour les balises de classification, un fichier de mappage de balises et d'ID de balise est également requis, qui se compose de deux colonnes: la première colonne est le nom d'origine de la balise dans l'ensemble de données, généralement quelques ID codés; La deuxième colonne est le nom lisible correspondant au nom d'origine de la balise. La correspondance de ce fichier sera utilisée pour sortir directement les noms d'étiquette lisibles lorsque le modèle est prévu.
En utilisant l'interface fournie par Fancy-NP, nous pouvons charger directement l'ensemble de données et le traiter dans le format requis par le modèle.
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 implémente le chargement efficace des ensembles de données de classification de texte. Vous pouvez utiliser directement le chemin du fichier des données (ensemble de formation, jeu de validation ou jeu de test) pour être chargé en tant que paramètres. Les données complètes sont utilisées ici pour diviser l'ensemble de formation, l'ensemble de validation et le jeu de test. En plus du fichier de données, la signification spécifique des paramètres restants ci-dessus est:
label_index : la position de la balise de classification dans le fichier de données (le numéro de position commence à partir de 0);text_index : l'emplacement du texte à classer dans le fichier de données;delimiter : le séparateur entre les colonnes du fichier de données;split_mode : indique comment diviser les données d'origine en modifiant les paramètres. dans:split_size : Ratio de division des données. Lorsque split_mode=1 , cela signifie que les données qui divisent split_size des données d'origine seront utilisées comme ensemble de vérification; Lorsque split_mode=2 , cela signifie que les données qui divisent split_size à partir des données d'origine seront utilisées comme somme de l'ensemble de vérification et de l'ensemble de tests, et les proportions de l'ensemble de vérification et du test de test chaque compte pour la moitié. Après avoir obtenu des données valides, l'application de classification de texte peut commencer à former directement le modèle.
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 ) Pour l'interface fit d'une application de classification de texte, vous devez passer dans l'ensemble de formation et les échantillons d'ensemble de validation qui ont déjà été traités. Les significations des paramètres restants sont les suivants:
text_classification_model_type : indique le nom du modèle à utiliser. Dans cet exemple, le modèle cnn est utilisé;char_embed_trainable : si la couche vectorielle de mot peut être un réglage fin. Dans cet exemple, il est défini sur True , indiquant que le réglage fin peut être effectué;callback_list : le nom de la fonction de rappel qui doit être utilisé. Les fonctions de rappel utilisées dans cet exemple sont:modelcheckpoint : utilisez la fonction de point de contrôle du modèle. Après chaque itération, sauvez le modèle formé;earlystopping : utilisez la fonction d'arrêt précoce. Si les performances du modèle ne s'améliorent pas après n itérations rondes (par défaut n = 5), la formation sera terminée;swa : SWA signifie la moyenne du poids stochastique, qui est une stratégie d'intégration de modèle courante qui peut efficacement améliorer les performances du modèle. Pour plus de détails, veuillez vous référer à l'introduction dans le document d'origine;checkpoint_dir : le chemin du répertoire pour enregistrer le fichier du modèle;model_name : le nom de fichier du fichier modèle;label_dict_file : un fichier de dictionnaire d'étiquette, qui se compose de deux colonnes: la première colonne est le nom d'origine de l'étiquette dans l'ensemble de données, généralement quelques ID codés; La deuxième colonne est le nom lisible correspondant au nom d'origine de l'étiquette;max_len : Pour la longueur maximale conservée par le texte d'entrée, le texte au-delà de cette longueur sera tronqué;load_swa_model : s'il faut charger le poids du modèle SWA après la formation du modèle. Réglé sur True ici, indiquant l'utilisation du modèle SWA; text_classification_app . score ( test_data , test_labels ) Ici, vous pouvez utiliser directement l'interface score de l'application de classification de texte pour obtenir le score du modèle dans l'ensemble de tests.
Après avoir entraîné le modèle, tous les fichiers liés au modèle requis par la tâche doivent être enregistrés pour faciliter l'utilisation de modèles formés en NLP dans d'autres applications externes.
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' )) L'interface save des applications de classification de texte peut être utilisée pour persister le fichier de structure du modèle (JSON), le fichier de poids (HDF5) et les résultats liés au prétraitement (cornichon):
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' )) À l'heure actuelle, text_classification_app a déjà la capacité de prédire des échantillons, et vous pouvez remplir les fonctions de prédiction pertinentes mentionnées dans le guide d'introduction . Par exemple, predict , analyze .
Nous utilisons toujours l'ensemble de données de correspondance du service client de Webank mentionné ci-dessus comme exemple pour introduire comment utiliser l'ensemble de données existant pour former notre propre modèle de correspondance de similitude de texte. Pour une version complète de tous les extraits de code suivants, veuillez vous référer aux examples/spm_example.py .
Dans Fancy-NLP, l'application de tâche de correspondance de similitudes de texte prend en charge l'utilisation du texte d'origine dans un format de jeu de données séparé par t , qui se compose de trois colonnes: la première colonne et la deuxième colonne sont respectivement un ensemble de paires de texte; La troisième colonne est un échantillon d'étiquette, 1 signifie que la sémantique texte est similaire et 0 signifie dissemblable.
En utilisant l'interface fournie par Fancy-NP, nous pouvons charger directement l'ensemble de données et le traiter dans le format requis par le modèle.
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 implémente le chargement efficace des ensembles de données de correspondance de similitude de texte. Vous pouvez utiliser directement le chemin du fichier des données (ensemble de formation, jeu de validation ou jeu de test) pour être chargé en tant que paramètres.
Après avoir obtenu des données valides, l'application de correspondance de similitude de texte peut commencer à former directement le modèle.
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 ) Pour l'interface fit de l'application correspondant à la similitude du texte, vous devez passer dans les échantillons d'ensemble de formation et de validation qui ont déjà été traités. La signification des paramètres restants est le suivant:
spm_model_type : indique le nom du modèle à utiliser. Dans cet exemple, le modèle siamese_cnn est utilisé;word_embed_trainable : si le calque de vecteur de mot peut être un réglage fin. Dans cet exemple, il est défini sur True , indiquant que le réglage fin peut être effectué;callback_list : le nom de la fonction de rappel qui doit être utilisé. Les fonctions de rappel utilisées dans cet exemple sont:modelcheckpoint : utilisez la fonction de point de contrôle du modèle. Après chaque itération, sauvez le modèle formé;earlystopping : utilisez la fonction d'arrêt précoce. Si les performances du modèle ne s'améliorent pas après n itérations rondes (par défaut n = 5), la formation sera terminée;swa : SWA signifie la moyenne du poids stochastique, qui est une stratégie d'intégration de modèle courante qui peut efficacement améliorer les performances du modèle. Pour plus de détails, veuillez vous référer à l'introduction dans le document d'origine;checkpoint_dir : le chemin du répertoire pour enregistrer le fichier du modèle;model_name : le nom de fichier du fichier modèle;max_len : Pour la longueur maximale conservée par le texte d'entrée, le texte au-delà de cette longueur sera tronqué;load_swa_model : s'il faut charger le poids du modèle SWA après la formation du modèle. Réglé sur True ici, indiquant l'utilisation du modèle 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 ) Ici, vous pouvez utiliser directement l'interface score d'application de correspondance de similitude de texte pour obtenir le score du modèle dans l'ensemble de tests.
Après avoir entraîné le modèle, tous les fichiers liés au modèle requis par la tâche doivent être enregistrés pour faciliter l'utilisation de modèles formés en NLP dans d'autres applications externes.
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' )) L'interface save de l'application de correspondance de similitude de texte peut être utilisée pour persister le fichier de structure du modèle (JSON), le fichier de poids (HDF5) et les résultats liés au prétraitement (cornichon):
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' )) Pour le moment, spm_app a déjà la capacité de prédire des échantillons, et vous pouvez continuer à remplir les fonctions de prédiction pertinentes mentionnées dans le guide d'introduction . Par exemple, predict , analyze .
FACNY-NLP fournit diverses méthodes d'utilisation du modèle Bert :
Pour utiliser Bert dans Fancy-NP, il vous suffit de télécharger le modèle Bert pré-formé (comme le modèle chinois Bert fourni par Google, le modèle Ernie fourni par Baidu (Code d'extraction: IQ74) et le modèle Bert-WWM fourni par Harbin Institute of Technology). Après cela, vous pouvez transmettre le chemin d'accès du fichier de vocabulaire du modèle Bert, du fichier de configuration et du fichier du modèle dans fit de l'application pertinente. Ce qui suit est un exemple de l'application de reconnaissance d'entité. Pour l'exemple complet du code, veuillez vous référer aux examples/bert_fine_tuning.py , examples/bert_single.py et examples/bert_combination.py .
Notez que le modèle Bert ne peut être utilisé qu'avec des vecteurs de caractères, pas avec des vecteurs de mots.
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 )Dans l'extrait de code ci-dessus, il est important de noter:
ner_model_type : Définissez le type de modèle sur bert ;use_char : set pour ne pas utiliser les vecteurs au niveau des caractères;use_word : défini pour ne pas utiliser les vecteurs de niveau mot comme entrée auxiliaire;use_bert : Lors du réglage fin du modèle Bert, défini sur l'entrée Bert uniquement,;bert_vocab_file , bert_config_file , bert_checkpoint_file : le chemin d'accès aux fichiers liés au modèle bertbert_trainable : définissez les paramètres du modèle Bert à l'état formable, c'est-à-dire le réglage fin;optimizer : définissez l'optimiseur pour le modèle Bert. Pour affiner le modèle Bert, le taux d'apprentissage de l'optimiseur doit être ajusté à un niveau plus petit. 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 )Dans l'extrait de code ci-dessus, il est important de noter:
ner_model_type : Définissez le type de modèle sur bilstm_cnn , et un modèle Nonbert doit être utilisé ici;use_char : set pour ne pas utiliser les vecteurs au niveau des caractères;use_word : défini pour ne pas utiliser les vecteurs de niveau mot comme entrée auxiliaire;use_bert : défini pour utiliser uniquement les vecteurs Bert comme entrée de fonctionnalité;bert_vocab_file , bert_config_file , bert_checkpoint_file : le chemin d'accès aux fichiers liés au modèle bertbert_trainable : définissez le paramètre du modèle Bert sur un état inexpsionnable, et il est également possible de le définir sur True ici;optimizer : définissez l'optimiseur. Si le modèle BET est formable, il est recommandé d'ajuster le taux d'apprentissage de l'optimiseur à un plus petit. 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 )Dans l'extrait de code ci-dessus, il est important de noter:
ner_model_type : Définissez le type de modèle sur bilstm_cnn , et un modèle Nonbert doit être utilisé ici;use_char : définissez le vecteur d'utilisation au niveau des caractères;use_word : défini pour ne pas utiliser les vecteurs de niveau mot comme entrée auxiliaire;use_bert : Définissez l'utilisation du vecteur Bert, qui combine des vecteurs de mots et des vecteurs Bert comme entrées de fonction;bert_vocab_file , bert_config_file , bert_checkpoint_file : le chemin d'accès aux fichiers liés au modèle bertbert_trainable : définissez les paramètres du modèle Bert à l'état formable, et il est également possible de le définir sur False ici;optimizer : définissez l'optimiseur. Si le modèle BET est formable, il est recommandé d'ajuster le taux d'apprentissage de l'optimiseur à un plus petit. Les développeurs qui souhaitent améliorer le code NLP fantaisie doivent suivre les spécifications suivantes pour soumettre des demandes de traction:
Si vous utilisez une PNL fantaisie pendant le processus de recherche connexe, vous pouvez ajouter ce qui suit à la liste de citations
@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}
}▴ Retour en haut
Ce projet est inspiré par de nombreux excellents projets open source, en particulier les keras. En tant que slogan de Keras: Deep Learning for Human l'a dit, nous espérons que la NLP fantaisie est une PNL pour l'homme , en particulier dans le domaine chinois.
