0 / 0
Retourner à la version anglaise de la documentation
Détection d'entités avec un dictionnaire personnalisé
Dernière mise à jour : 29 juil. 2024
Détection d'entités avec un dictionnaire personnalisé

Si vous avez un ensemble fixe de termes que vous souhaitez détecter, comme une liste de noms de produits ou d'organisations, vous pouvez créer un dictionnaire. L'appariement des dictionnaires est très rapide et efficace sur le plan des ressources.

Les dictionnaires de traitement de langage naturel Watson contiennent des fonctions de correspondance avancées qui vont au-delà d'une simple correspondance de chaîne, notamment :

  • Les termes du dictionnaire peuvent être constitués d'un jeton unique, par exemple Roue, ou de plusieurs jetons, par exemple, Volant, volant.
  • Le terme de dictionnaire correspondant peut être sensible à la casse ou insensible à la casse. Avec une correspondance sensible à la casse, vous pouvez vous assurer que les acronymes, comme ABS ne correspondent pas à des termes dans la langue standard, comme Abs qui ont une signification différente.
  • Vous pouvez spécifier comment consolider les correspondances lorsque plusieurs entrées de dictionnaire correspondent au même texte. Étant donné les deux entrées de dictionnaire, Watson et Watson Traitement des langues naturelles, vous pouvez configurer l'entrée qui doit correspondre dans " I like Watson Natural Language Processing" : soit uniquement Watson Traitement des langues naturelles, car elle contient Watson, ou les deux.
  • Vous pouvez spécifier de faire correspondre le lemme au lieu d'énumérer toutes les inflexions. De cette façon, l'entrée de dictionnaire unique Souris détecte à la fois Souris et Souris dans le texte.
  • Vous pouvez associer un libellé à chaque entrée de dictionnaire, par exemple Catégorie d'organisation pour inclure des métadonnées supplémentaires dans la correspondance.

Toutes ces fonctions peuvent être configurées, vous pouvez donc choisir l'option appropriée pour votre cas d'utilisation.

Types de fichiers de dictionnaire

Watson Natural Language Processing prend en charge deux types de fichiers de dictionnaire :

  • Liste de termes (se terminant par .dict)

    Exemple de liste de termes :

    Arthur
    Allen
    Albert
    Alexa
    
  • Table (se terminant par .csv)

    Exemple de tableau :

    "label", "entry"
    "ORGANIZATION", "NASA"
    "COUNTRY", "USA"
    "ACTOR", "Christian Bale"
    

Vous pouvez utiliser plusieurs dictionnaires au cours de la même extraction. Vous pouvez également utiliser les deux types en même temps, par exemple, exécuter une extraction unique avec trois dictionnaires, une liste de termes et deux tables.

Création de fichiers de dictionnaire

Commencez par créer un répertoire de module dans votre ordinateur portable. Il s'agit d'un répertoire dans le système de fichiers du bloc-notes qui sera utilisé temporairement pour stocker vos fichiers de dictionnaire.

Pour créer des fichiers de dictionnaire dans votre bloc-notes :

  1. Créez un répertoire de module. Notez que le nom du dossier de module ne peut pas contenir de tirets car cela provoque des erreurs.
    import os
    import watson_nlp
    module_folder = "NLP_Dict_Module_1"
    os.makedirs(module_folder, exist_ok=True)
    
  2. Créez des fichiers de dictionnaire et stockez-les dans le répertoire du module. Vous pouvez soit lire dans une liste externe ou un fichier CSV, soit créer des fichiers de dictionnaire comme suit :
    # Create a term list dictionary
    term_file = "names.dict"
    with open(os.path.join(module_folder, term_file), 'w') as dictionary:
        dictionary.write('Bruce')
        dictionary.write('\n')
        dictionary.write('Peter')
        dictionary.write('\n')
    
    # Create a table dictionary
    table_file = 'Places.csv'
    with open(os.path.join(module_folder, table_file), 'w') as places:
        places.write("\"label\", \"entry\"")
        places.write("\n")
        places.write("\"SIGHT\", \"Times Square\"")
        places.write("\n")
        places.write("\"PLACE\", \"5th Avenue\"")
        places.write("\n")
    

Chargement des dictionnaires et configuration des options de correspondance

Les dictionnaires peuvent être chargés à l'aide des méthodes d'aide suivantes.

  • Pour charger un dictionnaire unique, utilisez watson_nlp.toolkit.rule_utils.DictionaryConfig (<dictionary configuration>)
  • Pour charger plusieurs dictionnaires, utilisez watson_nlp.toolkit.rule_utils.DictionaryConfig.load_all([<dictionary configuration>)])

Pour chaque dictionnaire, vous devez spécifier une configuration de dictionnaire. La configuration du dictionnaire est un dictionnaire Python, avec les attributs suivants :

Attribut Valeur Descriptif Requis
name chaîne Le nom du dictionnaire Oui
source chaîne Chemin d'accès au dictionnaire, par rapport à module_folder Oui
dict_type Fichier ou table Indique si l'artefact de dictionnaire est une liste de termes (fichier) ou une table de mappages (table) Non. Le fichier par défaut est le fichier
consolidate ContainedWithin (Conserver la correspondance la plus longue et dedupliquer) / NotContainedWithin (Conserver la correspondance la plus courte et dédoubldupliquer) / ContainsButNotEqual (Conserver la correspondance la plus longue mais conserver les occurrences en double) / ExactMatch (Deduplicate) / LeftToRight (Conserver la plus longue durée sans chevauchement) Que faire des correspondances de dictionnaire qui se chevauchent. Non. La valeur par défaut est de ne pas consolider les correspondances.
case exact / insensible Indiquez une casse exacte ou une casse insensible. Non. La valeur par défaut est la correspondance exacte.
lemma Vrai / Faux Faites correspondre les termes du dictionnaire avec les lemmes du texte. Le dictionnaire ne doit contenir que des formes de lemme. Par exemple, ajoutez mouse dans le dictionnaire pour qu'il corresponde à la fois à mouse et à mice dans le texte. N'ajoutez pas mice dans le dictionnaire. Pour faire correspondre des termes qui se composent de plusieurs tokens dans le texte, séparez les lemmes de ces termes dans le dictionnaire par un caractère d'espace. Non. La valeur par défaut est false.
mappings.columns (colonnes as attribute of mappages : {}) list [ chaîne ] Liste des en-têtes de colonne dans le même ordre que celui présent dans la table csv Oui si dict_type: table
mappings.entry (mappages d'entrée as attribute of : {}) chaîne Nom de l'en-tête de colonne qui contient la chaîne à mettre en correspondance avec le document. Oui si dict_type: table
label chaîne Libellé à associer aux correspondances. Non

Exemple de code

# Load the dictionaries
dictionaries = watson_nlp.toolkit.rule_utils.DictionaryConfig.load_all([{
    'name': 'Names',
    'source': term_file,
    'case':'insensitive'
}, {
    'name': 'places_and_sights_mappings',
    'source': table_file,
    'dict_type': 'table',
    'mappings': {
        'columns': ['label', 'entry'],
        'entry': 'entry'
    }
}])

Formation d'un modèle contenant des dictionnaires

Après avoir chargé les dictionnaires, créez un modèle de dictionnaire et formez le modèle à l'aide de la méthode RBR.train(). Dans la méthode, spécifiez :

  • Répertoire du module
  • La langue des entrées du dictionnaire
  • Les dictionnaires à utiliser

Exemple de code

custom_dict_block = watson_nlp.resources.feature_extractor.RBR.train(module_folder,
language='en', dictionaries=dictionaries)

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_dict_block.run('Bruce is at Times Square')

Sortie de l'exemple de code :

{(0, 5): ['Names'], (12, 24): ['SIGHT']}

Pour afficher les libellés ou le nom du dictionnaire :

RBR_result = custom_dict_block.executor.get_raw_response('Bruce is at Times Square', language='en')
print(RBR_result)

Sortie montrant les libellés :

{'annotations': {'View_Names': [{'label': 'Names', 'match': {'location': {'begin': 0, 'end': 5}, 'text': 'Bruce'}}], 'View_places_and_sights_mappings': [{'label': 'SIGHT', 'match': {'location': {'begin': 12, 'end': 24}, 'text': 'Times Square'}}]}, 'instrumentationInfo': {'annotator': {'version': '1.0', 'key': 'Text match extractor for NLP_Dict_Module_1'}, 'runningTimeMS': 3, 'documentSizeChars': 32, 'numAnnotationsTotal': 2, 'numAnnotationsPerType': [{'annotationType': 'View_Names', 'numAnnotations': 1}, {'annotationType': 'View_places_and_sights_mappings', 'numAnnotations': 1}], 'interrupted': False, 'success': True}}

Rubrique parent : Création de vos propres modèles

Recherche et réponse à l'IA générative
Ces réponses sont générées par un modèle de langue de grande taille dans watsonx.ai en fonction du contenu de la documentation du produit. En savoir plus