Geben Sie Azure LUIS-Lerntexte einfach mit Python-Skripten ein

LUIS (Language Understanding Intelligent Service) des Verarbeitungsdienstes für natürliche Sprache von Microsoft Azure ist sehr Praktisch.

Sie können gleichzeitig ** Absichten ** und ** Entitäten ** einer Konversation extrahieren und auf einfache Weise ein einfaches Konversationsantwortprogramm oder einen Chatbot erstellen. (Eine Entität ist ein Wort, das Sie extrahieren möchten.)

https://www.luis.ai/

Das Eingeben einer Entität kann jedoch eine entmutigende Aufgabe sein. Wenn beispielsweise "aktueller Wohnort" und "gewünschter Umzugsort" eingegeben werden, sollten Sie einen Chatbot (eine API zur Extraktion von Ortsnamen) erstellen, der Ihnen den optimalen Umzugsplan angibt.

Über den Browserbildschirm, wie im obigen Bild gezeigt, mussten die Beispielsätze und "die Entitäten, die Sie von hier nach hier extrahieren möchten" nacheinander eingegeben werden, was eine ziemlich ausdauernde Aufgabe war.

Strategie

LUIS verfügt über JSON-Export- und Importfunktionen.

Sie können mit `{}` jeder Anwendung auf der Application Top Page auf dem obigen Bildschirm oder mit `` `Import App``` exportieren. Sie können es erneut hochladen.

aus diesem Grund,

• Geben Sie Informationen in Excel wie unten gezeigt ein
• Export nach CSV
• Mit Python-Skript in JSON konvertieren

Python-Skript

Bereiten Sie das folgende Skript vor, um eine JSON-Datei zu generieren. Die Version von Python, die ich verwende, ist 3.5.

Detaillierte Einstellungen und Dateinamen werden mit festen Werten eingegeben, diesmal handelt es sich jedoch um einen verworfenen Code. Selbst wenn Sie ihn hinzufügen, müssen Sie den Code nur ein wenig ändern. Bitte verzeihen Sie mir.

Diesmal "Quelle verschieben ( Area :: FromArea)" und "Ziel verschieben (` `` Area :: ToArea) "mit der Entität Eltern-Kind-Beziehung ( Hierarchisch```) Ich habe es mir ausgedacht, um es auszudrücken. Natürlich werden auch Entitäten unterstützt, die keine Eltern-Kind-Beziehung haben.

Ich habe auch `` `OrderedDict``` verwendet, weil Python-Wörterbuchtypen die Reihenfolge nicht einhalten. Sie müssen die Reihenfolge wahrscheinlich nicht einhalten, aber es ist zu langweilig, die Ausgabe zu sehen ...

#!/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()

Wenn Sie jedoch zwei Zeichenfolgen extrahieren möchten, können Sie nur die erste angeben. Dies sollte beim Tippen beachtet werden.

Wenn Sie dieses Skript ausführen, es in eine entsprechende JSON-Datei ausgeben und es früher vom Browserbildschirm importieren, sollten Apps mit dem Text, den Sie lernen möchten, vorbereitet werden.

python3 export_schema.py > output.json

Zukunftsaussichten

Azure CLI ist ebenfalls verfügbar, sodass Sie möglicherweise die Import- / Exportarbeit automatisieren können.

Wenn ich es in Betrieb nehmen kann, werde ich es versuchen, um Arbeit zu sparen.