Semblable à la détection d'entités avec des dictionnaires, vous pouvez utiliser des correspondances de modèle regex pour détecter des entités.
Les expressions régulières ne sont pas fournies dans des fichiers comme des dictionnaires, mais en mémoire dans une configuration regex. Vous pouvez utiliser plusieurs configurations regex au cours de la même extraction.
Les tables que vous définissez avec Watson Natural Language Processing peuvent utiliser des limites de jeton. Ainsi, vous pouvez vous assurer que vos expressions régulières correspondent à un ou plusieurs jetons. Il s'agit d'un avantage évident sur les moteurs d'expression régulière plus simples, en particulier lorsque vous travaillez avec une langue qui n'est pas séparée par un espace, tel que le chinois.
Les expressions régulières sont traitées par un composant dédié appelé Rule-Based Runtime ou RBR court.
Création de configurations d'expression régulière
Commencez par créer un répertoire de module dans votre ordinateur portable. Il s'agit d'un répertoire à l'intérieur du système de fichiers du bloc-notes utilisé temporairement pour stocker les fichiers créés par la formation RBR. Ce répertoire de module peut être le même que celui que vous avez créé et utilisé pour l'extraction d'entité basée sur un dictionnaire. Des dictionnaires et des expressions régulières peuvent être utilisés pour la même formation.
Pour créer le répertoire du module dans votre bloc-notes, entrez la commande suivante dans une cellule de code. Notez que le répertoire du module ne peut pas contenir de tiret (-).
import os
import watson_nlp
module_folder = "NLP_RBR_Module_2"
os.makedirs(module_folder, exist_ok=True)
Une configuration regex est un dictionnaire Python, avec les attributs suivants :
Attribut | Valeur | Descriptif | Requis |
---|---|---|---|
name |
chaîne | Nom de l'expression régulière. Les correspondances de l'expression régulière dans le texte d'entrée sont balisées avec ce nom dans la sortie. | Oui |
regexes |
Liste (chaîne de modèles de regex à base de perl) | Ne doit pas être vide. Plusieurs regexes peuvent être fournis. | Oui |
flags |
Chaîne délimité des indicateurs valides | Les indicateurs tels que UNICODE ou CASE_INSENSITIVE contrôlent la correspondance. Peut également être une combinaison de drapeaux. Pour les indicateurs pris en charge, voir Modèle (Java Platform SE 8). | Non (valeur par défaut pour DOTALL) |
token_boundary.min |
entier | token_boundary indique d'établir une correspondance d'expression régulière qu'aux limites d'unités lexicales. Spécifié en tant qu'objet dict avec les attributs min et max . |
Non (renvoie la correspondance sans chevauchement la plus longue à chaque position de caractère dans le texte d'entrée) |
token_boundary.max |
entier | max est un attribut facultatif pour token_boundary et requis lorsque la limite doit être étendue pour une plage (entre les jetons min et max ). token_boundary.max doit être >= token_boundary.min |
Non (si token_boundary est spécifié, l'attribut min peut être spécifié seul) |
groups |
liste (libellés de chaînes pour les groupes correspondants) | L'index de chaîne dans la liste correspond au groupe de correspondance dans le modèle commençant par 1 où 0 correspond à l'intégralité de la correspondance. Par exemple : regex: (a)(b) sur ab avec group: ['full', 'first', 'second'] donne full: ab, first: a, second: b |
Non (par défaut, le libellé correspond à la correspondance complète) |
Les configurations de regex peuvent être chargées à l'aide des méthodes d'aide suivantes :
- Pour charger une configuration regex unique, utilisez
watson_nlp.toolkit.RegexConfig.load(<regex configuration>)
- Pour charger plusieurs configurations regex, utilisez
watson_nlp.toolkit.RegexConfig.load_all([<regex configuration>)])
Exemple de code
Cet exemple montre comment charger deux configurations regex différentes. La première configuration détecte les noms de personne. Il utilise l'attribut groups pour permettre un accès facile au nom complet, premier et dernier nom à une étape ultérieure.
La seconde configuration détecte les acronymes en tant que séquence de caractères en majuscules. En utilisant l'attribut token_boundary, il empêche les correspondances dans les mots contenant à la fois des caractères en majuscules et en minuscules.
from watson_nlp.toolkit.rule_utils import RegexConfig
# Load some regex configs, for instance to match First names or acronyms
regexes = RegexConfig.load_all([
{
'name': 'full names',
'regexes': ['([A-Z][a-z]*) ([A-Z][a-z]*)'],
'groups': ['full name', 'first name', 'last name']
},
{
'name': 'acronyms',
'regexes': ['([A-Z]+)'],
'groups': ['acronym'],
'token_boundary': {
'min': 1,
'max': 1
}
}
])
Formation d'un modèle contenant des expressions régulières
Après avoir chargé les configurations d'expression régulière, créez un modèle RBR à l'aide de la méthode RBR.train()
. Dans la méthode, spécifiez :
- Répertoire du module
- La langue du texte
- Les configurations d'expression régulière à utiliser
Il s'agit de la même méthode que celle utilisée pour former RBR avec une extraction basée sur le dictionnaire. Vous pouvez transmettre la configuration du dictionnaire dans le même appel de méthode.
Exemple de code
# Train the RBR model
custom_regex_block = watson_nlp.resources.feature_extractor.RBR.train(module_path=module_folder, language='en', regexes=regexes)
Application du modèle sur de nouvelles données
Une fois que vous avez formé les dictionnaires, appliquez le modèle sur de nouvelles données à l'aide de la méthode run()
, comme vous l'utilisiez sur n'importe lequel des blocs préformés existants.
Exemple de code
custom_regex_block.run('Bruce Wayne works for NASA')
Sortie de l'exemple de code :
{(0, 11): ['regex::full names'], (0, 5): ['regex::full names'], (6, 11): ['regex::full names'], (22, 26): ['regex::acronyms']}
Pour afficher les sous-groupes correspondants ou le texte correspondant :
import json
# Get the raw response including matching groups
full_regex_result = custom_regex_block.executor.get_raw_response('Bruce Wayne works for NASA‘, language='en')
print(json.dumps(full_regex_result, indent=2))
Sortie de l'exemple de code :
{
"annotations": {
"View_full names": [
{
"label": "regex::full names",
"fullname": {
"location": {
"begin": 0,
"end": 11
},
"text": "Bruce Wayne"
},
"firstname": {
"location": {
"begin": 0,
"end": 5
},
"text": "Bruce"
},
"lastname": {
"location": {
"begin": 6,
"end": 11
},
"text": "Wayne"
}
}
],
"View_acronyms": [
{
"label": "regex::acronyms",
"acronym": {
"location": {
"begin": 22,
"end": 26
},
"text": "NASA"
}
}
]
},
...
}
Rubrique parent : Création de vos propres modèles