Entrez facilement des textes d'apprentissage Azure LUIS avec des scripts Python

LUIS (Language Understanding Intelligent Service) du service de traitement du langage naturel de Microsoft Azure est très Pratique.

Vous pouvez extraire des ** intentions ** et des ** entités ** d'une conversation en même temps, et vous pouvez facilement créer un simple programme de réponse à une conversation ou un chatbot. (Une entité est un mot que vous souhaitez extraire)

https://www.luis.ai/

Cependant, entrer dans une entité peut être une tâche ardue. Par exemple, si «lieu de résidence actuel» et «lieu de déplacement souhaité» sont saisis, nous envisagerons de créer un chatbot (une API d'extraction de nom de lieu pour) qui vous indiquera le plan de déplacement optimal.

En utilisant l'écran du navigateur, comme le montre l'image ci-dessus, il était nécessaire de saisir les phrases d'exemple et «les entités que vous voulez extraire d'ici à ici» une par une, ce qui était une tâche assez persistante.

Stratégie

LUIS a des capacités d'exportation et d'importation JSON.

Vous pouvez exporter avec `{}` de chaque application sur la [Page d'accueil de l'application](https://www.luis.ai/applications) sur l'écran ci-dessus, ou avec `ʻImport App```. Vous pouvez le télécharger à nouveau.

pour cette raison,

• Entrez les informations sur Excel comme indiqué ci-dessous
• Exporter vers csv
• Convertir en JSON avec un script Python

Script Python

Préparez le script suivant pour générer un fichier JSON. La version de Python que j'utilise est 3.5.

Les paramètres détaillés et les noms de fichiers sont entrés avec des valeurs fixes, mais cette fois, il s'agit d'un code ignoré, et même si vous l'ajoutez, vous n'aurez qu'à changer un peu le code, alors pardonnez-moi.

Cette fois, "Déplacer la source (" ʻArea :: FromArea) "et" Déplacer la destination (Area :: ToArea) "avec l'entité de relation parent-enfant (` `Hierarchical) J'ai pensé à l'exprimer. Bien sûr, il prend également en charge les entités qui n'ont pas de relation parent-enfant.

J'ai également utilisé OrderedDict parce que les types de dictionnaire Python ne gardent pas l'ordre. Vous n'avez probablement pas à garder l'ordre, mais c'est trop ennuyeux de vérifier la sortie ...

#!/usr/bin/env python3

import json
import csv
from collections import defaultdict, OrderedDict


def main():
    df = _read_csv('./input.csv')
    output = _create_output(df)
    print(json.dumps(output))


class DataFrame(list):
    def __getitem__(self, key: str) -> list:
        return [x[key] for x in self]

    def keys(self) -> set:
        res = set()
        for x in self:
            for y in x.keys():
                res.add(y)
        return res


def _create_output(df: DataFrame) -> OrderedDict:
    entity_keys = df.keys() - {'text', 'Entities', 'intent'}
    entities = _create_entities(entity_keys)
    intents = _create_intents(df['intent'])
    utterrances = _create_utterances(df, entity_keys)
    return _create_luis_schema(intents, entities, utterrances)


def _read_csv(path: str) -> DataFrame:
    with open(path, 'r', encoding='utf8') as f:
        df = DataFrame(l for l in csv.DictReader(f) if l)
    return df


def _create_entities(entities: list) -> list:
    res = []
    for name, children in _parse_entities(entities).items():
        cs = [c for c in children if c is not None]
        res.append(_create_entity(name, cs))
    return res


def _create_intents(intents: list) -> list:
    res = set(intents)
    res.add('None')
    return [{'name': n} for n in res]


def _parse_entities(entities: list) -> defaultdict(set):
    res = defaultdict(set)
    for entity in entities:
        name, child = _parse_entity(entity)
        res[name].add(child)
    return res


def _parse_entity(entity: str) -> tuple:
    if '::' not in entity:
        return (entity, None)
    return tuple(entity.split('::'))


def _create_entity(name: str, children: set) -> OrderedDict:
    res = OrderedDict([('name', name)])
    if len(children) >= 1:
        res['children'] = list(children)
    return res


def _create_utterances(rows: DataFrame, entity_keys) -> list:
    return [_create_utterrance(x, entity_keys) for x in rows]


def _create_utterrance(row: dict, entity_keys: set) -> OrderedDict:
    return OrderedDict([
      ('text', row['text']),
      ('intent', row['intent']),
      ('entities', _create_utterrance_entities(
          row['text'], [(k, row[k]) for k in entity_keys]))
    ])


def _create_utterrance_entities(text: str, entitity_items: list) -> list:
    return [_create_utterrance_entity(text, k, v)
            for k, v in entitity_items if v]  # not ''


def _create_utterrance_entity(
        text: str, entity_key: str, entity_value: str) -> OrderedDict:
    start_pos = text.find(entity_value)
    return OrderedDict([
        ('entity', entity_key),
        ('startPos', start_pos),
        ('endPos', start_pos + len(entity_value) - 1)
    ])


def _create_luis_schema(
        intents: list, entities: list, utterrances: list) -> OrderedDict:
    return OrderedDict([
        ('luis_schema_version', '2.1.0'),
        ('versionId', '0.1'),
        ('name', 'TestOperator'),
        ('desc', 'forTestOperator'),
        ('culture', 'ja-jp'),
        ('intents', intents),
        ('entities', entities),
        ('composites', []),
        ('closedLists', []),
        ('bing_entities', []),
        ('actions', []),
        ('model_features', []),
        ('regex_features', []),
        ('utterances', utterrances)
    ])


if __name__ == '__main__':
    main()

Cependant, si vous souhaitez extraire deux chaînes de caractères, vous ne pouvez spécifier que la première. Cela doit être pris en compte lors de la saisie.

Si vous exécutez ce script, exportez-le dans un fichier json approprié et importez-le plus tôt à partir de l'écran du navigateur, les applications contenant le texte que vous souhaitez apprendre doivent être préparées.

python3 export_schema.py > output.json

Perspectives d'avenir

Azure CLI est également disponible, vous pouvez donc peut-être automatiser le travail d'importation / exportation.

Si je peux le mettre en service, je vais l'essayer pour économiser du travail.