Lassen Sie die COTOHA-API die schwierigen Dinge tun.

Die COTOHA-API ist eine API, die auf der Grundlage der Forschungsergebnisse der NTT-Gruppe problemlos die Verarbeitung natürlicher Sprache verwenden kann [^ 1]. Die Implementierung schwieriger Algorithmen wird durch Drücken dieser API vereinfacht.

Wenn es um API geht, erhalten Sie möglicherweise ein schwieriges Bild. Diese API ist jedoch sehr einfach zu verwenden. Darüber hinaus wurde in diesem Artikel erläutert, wie Sie sie sorgfältiger und detaillierter verwenden können. Außerdem wurde der gesamte Beispielcode in diesem Artikel in Python implementiert, um Ihnen zu helfen, wenn Sie in Zukunft selbst einen schwierigen Algorithmus implementieren möchten. Vorkenntnisse der API sind nicht erforderlich! (Also bitte seien Sie versichert)

1.2 Arten der Verarbeitung natürlicher Sprache, die in diesem Artikel verfügbar sein werden

** Satzzusammenfassung, Syntaxanalyse, Extraktion eindeutiger Ausdrücke, Korrespondenzanalyse, Schlüsselwortextraktion, Ähnlichkeitsberechnung zwischen zwei Sätzen, Satztypschätzung, Schätzung menschlicher Attribute wie Alter und Beruf, Stagnationsentfernung (ah, uh usw.), Spracherkennungsfehlererkennung, Emotionsanalyse **

Dies sind alles Prozesse in natürlicher Sprache, die von kostenlosen Benutzern (für Entwickler) der COTOHA-API verwendet werden können. In diesem Artikel werde ich diese Aufgaben vorstellen und den Code erklären, der tatsächlich funktioniert. (Da es jedoch der Absicht dieses Artikels widerspricht, mit Kopieren und Einfügen zu enden, bieten wir keine Implementierung an, die die gesamte Verarbeitung natürlicher Sprache verwenden kann. Es gibt tatsächlich drei Arten von Kopieren und Einfügen, die ausgeführt werden können: Zusammenfassung, Syntaxanalyse und ordnungsgemäße Ausdrucksextraktion. Ist.)

1.3 Endergebnis

Schauen wir uns als Beispiel das Ergebnis der Satzzusammenfassung an. Ich habe den Qiita-Artikel zusammengefasst, den ich (@MonaCat) zuvor als Eingabetext geschrieben habe.

> python cotoha_test.py -f data/input.txt -s 3

<Zusammenfassung>

Satzzusammenfassungen werden in Extraktionstyp und Generierungstyp (abstrakter Typ) unterteilt, aber derzeit ist der Generierungstyp (Kombination aus Extraktionstyp) der Mainstream.
Einführung des Zusammenfassungsmodells für neuronale Sätze-Die auf M3 Tech Blog seq2seq basierende automatische Zusammenfassungsmethode wird zusammengefasst.
Papierkommentar Aufmerksamkeit ist alles was Sie brauchen(Transformer) -Deep Learning Blog Wenn Sie dies zuerst lesen, besteht kein Zweifel.

Lassen Sie mich kurz erklären.

Ich führe ein Programm mit python cotoha_test.py aus. Durch Übergeben verschiedener Optionen als Argumente kann auch angegeben werden, welche API aufgerufen werden soll. In der obigen Abbildung ist der Teil "-f data / input.txt -s 3" eine Option. Es bezieht sich auf eine Datei mit dem Namen "input.txt" und gibt an, dass die API für die automatische Zusammenfassung mit drei Zusammenfassungssätzen verwendet werden soll. Daher sollte das Ausgabeergebnis eine Zusammenfassung von 3 Sätzen sein.

Durch Ändern dieser Option können andere APIs verwendet und Einstellungen geändert werden (z. B. Zusammenfassen mit 5 Sätzen anstelle von 3 Sätzen). Um diesen Betrag wurde es ein wenig schwierig, aber ich fügte eine ergänzende Erklärung der Optionsimplementierung hinzu. Ich bin sehr froh, wenn nur diejenigen, die es sich leisten können, es lesen können, weil es in der Hauptzeile als nicht verwandt angesehen wird.

2 Lassen Sie uns die Verarbeitung natürlicher Sprache kennen

Bevor wir es implementieren, lernen wir etwas über die Verarbeitung natürlicher Sprache. Natürliche Sprache ist eine Sprache wie Japanisch oder Englisch, die wir in unserem täglichen Leben verwenden. Das heißt, die Verarbeitung natürlicher Sprache bezieht sich auf ein technisches Feld, das "natürliche Sprache" "verarbeitet".

In diesem Kapitel werden kurz die Technologien zur Verarbeitung natürlicher Sprache beschrieben, die mit der COTOHA-API verwendet werden können. (Teilweise weggelassen)

• Parsen

Die syntaktische Analyse besteht darin, einen Satz (Zeichenkette) in morphologische Elemente zu unterteilen und die strukturelle Beziehung zwischen ihnen zu analysieren. Zum Beispiel besteht der Satz "Ich sah" aus "Substantiv" + "Hilfs" + "Verb". Die strukturelle Beziehung von nicht markierten Zeichenketten kann durch syntaktische Analyse geklärt werden.

• Extraktion einzigartiger Ausdrücke

Die Extraktion eindeutiger Ausdrücke ist eine Technologie, die automatisch die richtige Nomenklatur (persönliche Namen, Ortsnamen usw.) extrahiert. Es gibt unzählige richtige Nomenklaturen auf der Welt, aber es ist nicht realistisch, alle im Wörterbuch zu registrieren. Durch die Automatisierung der Extraktion wird es daher möglich, eine große Textmenge zu verarbeiten.

• Korrespondenzanalyse

Direktiven und Synonyme wie "dies" und "er" werden wie Vorgänger verwendet, können jedoch gelesen werden, da wir ihre Beziehungen natürlich verstehen, wenn wir Sätze verstehen. Gibt es. Diese Beziehung wird als Korrespondenzbeziehung bezeichnet, und die Technik zur Analyse dieser Beziehung wird als Korrespondenzanalyse bezeichnet.

• Schlüsselwortextraktion

Schlüsselwörter haben verschiedene Bedeutungen, aber die COTOHA-API berechnet charakteristische Phrasen und Wörter und extrahiert sie als Schlüsselwörter. Mit anderen Worten, es kann als typische Phrase oder Wort in einem Satz angesehen werden.

• Attributschätzung

Es ist eine Technologie, die Attribute (Alter, Geschlecht, Hobbys, Beruf usw.) schätzt. Die COTOHA-API zielt darauf ab, die Attribute von Twitter-Benutzern zu schätzen.

• Beseitigung der Stagnation

Iyodomi ist ein Wort, das beim Sprechen zwischen Sätzen verwendet wird, z. B. "ah" und "uh". Beispielsweise kann ein durch Spracherkennung transkribierter Satz eine Stagnation enthalten, die für die Konvertierung in Text nicht erforderlich ist. Durch Entfernen der Stagnation in einem solchen Fall wird es möglich, den Text in Daten zu verarbeiten, die einfach zu verwenden sind.

--Emotion Analyse

Emotionsanalyse (negatives / positives Urteil) bezieht sich auf die Klassifizierung von Emotionen, die aus Sätzen geschrieben wurden, in zwei Werte, negativ und positiv. Die Analyse mit Deep Learning ist aktiver als die oben eingeführten Felder.

• Satzzusammenfassung

Es ist eine Technologie, die Sätze automatisch zu einem Satz oder mehreren Sätzen zusammenfasst. In letzter Zeit ist es üblich geworden, dass Nachrichtenseiten eine Zusammenfassung mit drei Sätzen enthalten. Man kann sagen, dass es sich um eine Aufgabe handelt, die der Keyword-Extraktion ähnelt, da wichtige Phrasen / Sätze aus langen Sätzen analysiert werden.

Wenn Sie an einer Textzusammenfassung interessiert sind, wird dieser Artikel empfohlen. Obwohl es den Titel "Einführung in Papiere" trägt, sollte es hilfreich sein, da es Informationen von den Grundlagen bis zur neuesten Technologie zusammenfasst: Einführung in das Papier "BERTSUM", das automatisch mit BERT + α - Qiita zusammengefasst wird //qiita.com/MonaCat/items/5123d2f970cba1acd897)

3 Verwenden wir es tatsächlich

Tut mir leid, dass ich dich habe warten lassen. Lassen Sie uns die Verarbeitung natürlicher Sprache mit der COTOHA-API erleben.

3.1 Gemeinsame Teile

Zunächst aus den erforderlichen gemeinsamen Teilen, unabhängig von der API, die Sie verwenden möchten.

Die COTOHA-API kann kostenlos registriert und verwendet werden. Registrieren Sie sich daher über die COTOHA-API.

Für die Registrierungsinformationen sind Ihr Name und Ihre Zugehörigkeit erforderlich, Sie benötigen jedoch keine Informationen wie eine Kreditkarte. Wenn Sie sich registrieren, erhalten Sie die unten gezeigten Informationen.

Von diesen unterscheiden sich die "Kunden-ID" und das "Kundengeheimnis" von Person zu Person. Seien Sie also bereit, sie später zu kopieren.

3.1.1 Zugriffstoken erhalten

Von hier an in Python implementieren. Ich überlasse Ihnen die Python-Umgebung, aber bitte installieren Sie die erforderlichen Module entsprechend mit pip oder conda, damit Sie sie verwenden können.

Definieren Sie zunächst eine Funktion, um ein Zugriffstoken zu erhalten.

CLIENT_ID = 'Schreiben Sie entsprechend um'
CLIENT_SECRET = 'Schreiben Sie entsprechend um'


def auth(client_id, client_secret):
    token_url = 'https://api.ce-cotoha.com/v1/oauth/accesstokens'
    headers = {
        'Content-Type': 'application/json',
        'charset': 'UTF-8'
    }
    data = {
        'grantType': 'client_credentials',
        'clientId': client_id,
        'clientSecret': client_secret
    }
    r = requests.post(token_url,
                      headers=headers,
                      data=json.dumps(data))

    return r.json()['access_token']


if __name__ == "__main__":

    access_token = auth(CLIENT_ID, CLIENT_SECRET)  #Zugriffstoken erhalten

Sie haben es vielleicht plötzlich schwierig gefunden. Aber es ist sehr einfach. Schauen wir sie uns der Reihe nach an.

Zunächst wird auth () mit den obigen Authentifizierungsinformationen als Argument aufgerufen.

In auth () wird das Zugriffstoken mithilfe der Authentifizierungsinformationen erfasst. In der Startanleitung wird es von einem Befehl abgerufen, diesmal wird jedoch dasselbe in Python implementiert. Beachten Sie, dass Sie die JSON-Datei bei Erfolg abrufen können, hier jedoch nur das Zugriffstoken möchten. Daher wird "r.json [" access_token "]" zurückgegeben.

Mit diesem Zugriffstoken können Sie die API verwenden.

3.1.2 Argumente angeben (optional)

In diesem Beispielcode wird das Modul "argparse" verwendet, um Argumente anzugeben. Dies wurde in Abschnitt 1.3 erläutert. Der Grund, warum wir die Angabe von Argumenten ermöglicht haben, besteht darin, dass das Umschalten praktisch ist, da davon ausgegangen wird, dass mehrere APIs verwendet werden.

Dieser Abschnitt erklärt kurz "argparse", aber da es nichts mit der Hauptzeile zu tun hat, überspringen Sie es bitte, wenn Sie es sich nicht leisten können.

Also zuerst, bevor Sie das Zugriffstoken erhalten

if __name__ == "__main__":

    document = 'Der Text, der verwendet wird, wenn kein Eingabetext angegeben ist. In dieser Implementierung können Sie zwei Muster verwenden: "Text mit Argumenten angeben" und "Textdatei mit Argumenten angeben". Bitte probieren Sie es aus.'
    args = get_args(document)  #Argumente abrufen

    access_token = auth(CLIENT_ID, CLIENT_SECRET)  #Zugriffstoken erhalten

Rufen wir get_args () mit auf. Der Inhalt dieser Funktion ist wie folgt.

def get_args(document):
    argparser = argparse.ArgumentParser(description='Code zum Spielen der Verarbeitung natürlicher Sprache mithilfe der Cotoha-API')
    argparser.add_argument('-t', '--text', type=str, default=document, help='Der Satz, den Sie analysieren möchten')
    argparser.add_argument('-f', '--file_name', type=str, help='Ich möchte analysieren.txt Pfad')
    argparser.add_argument('-p', '--parse', action='store_true', help='Geben Sie an, ob Sie die Syntax analysieren möchten')
    argparser.add_argument('-s', '--summarize', type=int, help='Geben Sie die Anzahl der Zusammenfassungssätze für die automatische Zusammenfassung an')

    return argparser.parse_args()

Die erste Zeile beschreibt den Code in der Beschreibung. Dies wird angezeigt, wenn -h als Befehlszeilenargument verwendet wird.

Ein Beispiel, wenn -h angegeben ist.

> python cotoha_test.py -h      
usage: cotoha_test.py [-h] [-t TEXT] [-f FILE_NAME] [-p] [-s SUMMARIZE]

Code zum Spielen der Verarbeitung natürlicher Sprache mithilfe der Cotoha-API

optional arguments:
  -h, --help            show this help message and exit
  -t TEXT, --text TEXT Der Text, den Sie analysieren möchten
  -f FILE_NAME, --file_name FILE_NAME
Pfad der Textdatei, die Sie analysieren möchten
  -p, --Analysieren der Syntaxanalyse
  -n, --ne einzigartige Expressionsextraktion
  -s SUMMARIZE, --summarize SUMMARIZE
Anzahl der zusammenfassenden Sätze in der automatischen Zusammenfassung

Nachfolgende Zeilen definieren die Argumente in der Reihenfolge mit "add_argument".

Wenn Sie ein Argument festlegen, geschieht natürlich nichts, es sei denn, Sie implementieren, was passiert, wenn dieses Argument angegeben wird. Dieses Mal möchte ich eine Syntaxanalyse durchführen, wenn -p angegeben ist. Wenn dies alles ist, scheint es nur durch bedingte Verzweigung mit der if-Anweisung zu funktionieren. Lass es uns sofort tun.

if (args.parse):
    parse(doc, access_token)  #Funktionsaufruf

Wenn args.parse True ist, rufen Sie die Funktion parse auf. Die Funktionsanalyse wurde bisher noch nicht angezeigt, sodass Sie nicht wissen, um was es sich handelt. Stellen Sie sich das hier nur als eine Funktion vor, die eine Syntaxanalyse durchführt. Details werden in einem späteren Kapitel erläutert.

args.parse ist die Option, die ich zuvor in argparser.add_argument hinzugefügt habe. Beachten Sie, dass es "args.parse" anstelle von "args.p" sein muss. In ähnlicher Weise kann beispielsweise "args.summarize" zur Zusammenfassung verwendet werden.

Übrigens wird es in Zukunft ein wenig unattraktiv aussehen, wenn viele andere Aufgaben als die Syntaxanalyse und -zusammenfassung mit if-Anweisungen bedingt verzweigt werden. Deshalb werde ich es ein wenig vereinfachen.

#API-Aufruf
l = [doc, access_token]  #Gemeinsame Argumente
parse(*l) if (args.parse) else None  #Parsing

Was ich mache, ist das gleiche wie zuvor, aber ich schreibe eine if-Anweisung in eine Zeile, füge sie in eine Liste ein, da es viele gemeinsame Argumente gibt, erweitere sie und übergebe sie an die Funktion, um sie aufzurufen.

Lassen Sie uns abschließend implementieren, wenn die Datei mit -f angegeben wird. Wenn eine Datei angegeben wird, wird diese priorisiert. Es kann jedoch ein Fehler auftreten, sofern die angegebene Datei nicht zuvor vorhanden ist.

#Wenn Sie eine Datei angeben, wird diese priorisiert
if (args.file_name != None and os.path.exists(args.file_name)):
    with open(args.file_name, 'r', encoding='utf-8') as f:
        doc = f.read()
else:
    doc = args.text

Wenn Sie so weit folgen, sollte die Implementierung wie folgt sein.

import argparse
import requests
import json
import os


BASE_URL = 'https://api.ce-cotoha.com/api/dev/'
CLIENT_ID = ''  #Schreiben Sie entsprechend um
CLIENT_SECRET = ''  #Schreiben Sie entsprechend um


def get_args(document):
    argparser = argparse.ArgumentParser(description='Code zum Spielen der Verarbeitung natürlicher Sprache mithilfe der Cotoha-API')
    argparser.add_argument('-t', '--text', type=str, default=document, help='Text, den Sie analysieren möchten')
    argparser.add_argument('-f', '--file_name', type=str, help='Pfad der Textdatei, die Sie analysieren möchten')
    argparser.add_argument('-p', '--parse', action='store_true', help='Parsing')
    argparser.add_argument('-n', '--ne', action='store_true', help='Einzigartige Ausdrucksextraktion')
    argparser.add_argument('-c', '--coreference', action='store_true', help='Korrespondenzanalyse')
    argparser.add_argument('-k', '--keyword', action='store_true', help='Schlüsselwortextraktion')
    argparser.add_argument('-s', '--summarize', type=int, help='Anzahl der zusammenfassenden Sätze in der automatischen Zusammenfassung')

    return argparser.parse_args()


def auth(client_id, client_secret):
    """
Funktion zum Abrufen des Zugriffstokens
    """
    token_url = 'https://api.ce-cotoha.com/v1/oauth/accesstokens'
    headers = {
        'Content-Type': 'application/json',
        'charset': 'UTF-8'
    }
    data = {
        'grantType': 'client_credentials',
        'clientId': client_id,
        'clientSecret': client_secret
    }
    r = requests.post(token_url,
                      headers=headers,
                      data=json.dumps(data))

    return r.json()['access_token']


def base_api(data, document, api_url, access_token):
    """
Header usw., der allen APIs gemeinsam ist
    """
    base_url = BASE_URL
    headers = {
        'Content-Type': 'application/json; charset=UTF-8',
        'Authorization': 'Bearer {}'.format(access_token)
    }
    r = requests.post(base_url + api_url,
                      headers=headers,
                      data=json.dumps(data))

    return r.json()


if __name__ == "__main__":

    doc = 'Ich habe Michael gestern am Bahnhof von Tokio getroffen. Ich habe vor einem Monat angefangen, ihn zu treffen.'
    args = get_args(doc)  #Argumente abrufen

    #Wenn Sie eine Datei angeben, wird diese priorisiert
    if (args.file_name != None and os.path.exists(args.file_name)):
        with open(args.file_name, 'r', encoding='utf-8') as f:
            doc = f.read()
    else:
        doc = args.text

    access_token = auth(CLIENT_ID, CLIENT_SECRET)  #Zugriffstoken erhalten
    
    #API-Aufruf
    l = [doc, access_token]  #Gemeinsame Argumente

    parse(*l) if (args.parse) else None  #Parsing
    ne(*l) if (args.ne) else None  #Einzigartige Ausdrucksextraktion
    coreference(*l) if (args.coreference) else None  #Korrespondenzanalyse
    keyword(*l) if (args.keyword) else None  #Schlüsselwortextraktion
    summarize(*l, args.summarize) if (args.summarize) else None  #einpacken

Natürlich funktioniert dieses Programm immer noch nicht. Dies liegt daran, dass keine Funktionen wie parse () und ne () definiert werden. Es wird in den folgenden Abschnitten implementiert.

3.2 Verschiedene Teile für jede Aufgabe

Für diejenigen, die 3.1.2 übersprungen haben, verwenden wir hier ein Programm, das nur Syntaxanalysen durchführt, wie das folgende Programm.

import argparse
import requests
import json
import os


BASE_URL = 'https://api.ce-cotoha.com/api/dev/'
CLIENT_ID = 'Schreiben Sie entsprechend um'
CLIENT_SECRET = 'Schreiben Sie entsprechend um'

def auth(client_id, client_secret):
    """
Funktion zum Abrufen des Zugriffstokens
    """
    token_url = 'https://api.ce-cotoha.com/v1/oauth/accesstokens'
    headers = {
        'Content-Type': 'application/json; charset: UTF-8',
    }
    data = {
        'grantType': 'client_credentials',
        'clientId': client_id,
        'clientSecret': client_secret
    }
    r = requests.post(token_url,
                      headers=headers,
                      data=json.dumps(data))

    return r.json()['access_token']


if __name__ == "__main__":

    doc = 'Ich habe Michael gestern am Bahnhof von Tokio getroffen. Ich habe vor einem Monat angefangen, ihn zu treffen.'

    access_token = auth(CLIENT_ID, CLIENT_SECRET)  #Zugriffstoken erhalten
    parse(doc, access_token)  #Parsing

Diejenigen, die 3.1.2 befolgt haben, sollten diese Implementierung einfach so verwenden, wie sie ist. In jedem Fall implementieren wir hier eine Funktion, die APIs wie parse () und ne () aufruft, um die Verarbeitung natürlicher Sprache durchzuführen.

3.2.1 Syntaxanalyse

Wenn Sie Syntaxanalyse-Referenz lesen, finden Sie den Anforderungsheader, den Anforderungshauptteil usw. und müssen den Schlüssel angeben. Du wirst sehen. Der Anforderungsheader ist jedoch tatsächlich allen COTOHA-APIs gemeinsam. Daher werden allgemeine Teile wie Anforderungsheader von einer Funktion namens base_api () implementiert, und Teile, die für die Syntaxanalyse eindeutig sind, werden von einer Funktion namens parse () implementiert.

def base_api(data, document, api_url, access_token):
    """
Header usw., der allen APIs gemeinsam ist
    """
    base_url = BASE_URL
    headers = {
        'Content-Type': 'application/json; charset=UTF-8',
        'Authorization': 'Bearer {}'.format(access_token)
    }
    r = requests.post(base_url + api_url,
                      headers=headers,
                      data=json.dumps(data))

    return r.json()


def parse(sentence, access_token):
    """
Parsing
    """
    data = {'sentence': sentence}
    result = base_api(data, sentence, 'nlp/v1/parse', access_token)

    print('\n<Parsing>\n')
    result_list = list()
    
    for chunks in result['result']:
        for token in chunks['tokens']:
            result_list.append(token['form'])

    print(' '.join(result_list))

Beginnen wir mit base_api (). Die soeben angezeigten Anforderungsheader werden in den Headern angegeben. Sie können sehen, dass die Anforderung mit diesem Wert, dem Anforderungshauptteil, dem zu analysierenden Text und der URL der API als Argumente gesendet wird. Gibt die zuletzt erhaltene JSON-Datei zurück.

In parse () wird der Anforderungshauptteil zuerst durch die Variablendaten angegeben. Dieses Mal wird der Schlüsselsatz durch den variablen Satz angegeben (Sie denken vielleicht, was Sie sagen, aber es bedeutet dasselbe).

Als nächstes ist der Wert von base_api (), dh die json-Datei, in der Ergebnisvariablen enthalten.

Diese JSON-Datei enthält das Ergebnis der Syntaxanalyse. Lesen Sie sie daher. Das Format ist im Antwortbeispiel derselben Referenz beschrieben. Wenn ich das Antwortbeispiel der Syntaxanalyse lese, scheint es, dass die Schlüsselform des morphologischen Informationsobjekts das ist, wonach ich gesucht habe, also werde ich dies der Liste hinzufügen.

Auf diese Weise erhalten Sie die folgenden Ergebnisse:

> python cotoha_test.py

<Parsing>

Ich habe Michael gestern am Bahnhof von Tokio getroffen. Ich habe vor einem Monat angefangen, ihn zu treffen.

3.2.2 Extraktion eindeutiger Ausdrücke

Als nächstes werden eindeutige Ausdrücke extrahiert, aber ich werde sie weglassen, da ich nur die gleiche Erklärung wie zuvor wiederholen werde. Tatsächlich können Sie die meisten anderen APIs wie zuvor verwenden.

def ne(sentence, access_token):
    """
Einzigartige Ausdrucksextraktion
    """
    data = {'sentence': sentence}
    result = base_api(data, sentence, 'nlp/v1/ne', access_token)
    
    print('\n<Einzigartige Ausdrucksextraktion>\n')
    result_list = list()

    for chunks in result['result']:
        result_list.append(chunks['form'])

    print(', '.join(result_list))

> python cotoha_test.py

<Einzigartige Ausdrucksextraktion>

gestern,Michael,Tokyo Station,Ein Monat

3.2.3 Zusammenfassung

Es ist eine große Sache, also lasst uns etwas anderes machen. Wenn Sie die Abstract-Referenz lesen, finden Sie "sent_len" im Anforderungshauptteil, in dem Sie die Anzahl der Abstracts angeben können. Das ist auch eine große Sache, also möchte ich es nutzen.

def summarize(document, access_token, sent_len):
    """
einpacken
    """
    data = {
        'document': document,
        'sent_len': sent_len
    }
    result = base_api(data, document, 'nlp/beta/summary', access_token)

    print('\n <Zusammenfassung>\n')
    result_list = list()

    for result in result['result']:
        result_list.append(result)
    
    print(''.join(result_list))

Jetzt können Sie mit einer beliebigen Anzahl von Zusammenfassungssätzen zusammenfassen, indem Sie einen bestimmten Wert in "sent_len" eingeben. Wenn Sie die Option 3.1.2 implementieren können, ist dies praktisch, da Sie als Argument "sent_len" angeben können.

> python cotoha_test.py -s 1

<Zusammenfassung>

Ich habe Michael gestern am Bahnhof von Tokio getroffen.

3.3.3 Andere Verarbeitung natürlicher Sprache

Andere APIs können auf die gleiche Weise implementiert werden, daher werde ich sie weglassen.

4 Zusammenfassung

Schließlich wird ein Programm vorgestellt und zusammengefasst, das Syntaxanalyse, Extraktion eindeutiger Ausdrücke und Zusammenfassung durchführen kann. Auch hier können andere APIs auf die gleiche Weise implementiert werden. Wenn Sie also an der Verarbeitung natürlicher Sprache interessiert sind, versuchen Sie bitte, diese selbst zu implementieren.

import argparse
import requests
import json
import os


BASE_URL = 'https://api.ce-cotoha.com/api/dev/'
CLIENT_ID = ''  #Schreiben Sie entsprechend um
CLIENT_SECRET = ''  #Schreiben Sie entsprechend um


def get_args(document):
    argparser = argparse.ArgumentParser(description='Code zum Spielen der Verarbeitung natürlicher Sprache mithilfe der Cotoha-API')
    argparser.add_argument('-t', '--text', type=str, default=document, help='Text, den Sie analysieren möchten')
    argparser.add_argument('-f', '--file_name', type=str, help='Pfad der Textdatei, die Sie analysieren möchten')
    argparser.add_argument('-p', '--parse', action='store_true', help='Parsing')
    argparser.add_argument('-n', '--ne', action='store_true', help='Einzigartige Ausdrucksextraktion')
    argparser.add_argument('-s', '--summarize', type=int, help='Anzahl der zusammenfassenden Sätze in der automatischen Zusammenfassung')

    return argparser.parse_args()


def auth(client_id, client_secret):
    """
Funktion zum Abrufen des Zugriffstokens
    """
    token_url = 'https://api.ce-cotoha.com/v1/oauth/accesstokens'
    headers = {
        'Content-Type': 'application/json',
        'charset': 'UTF-8'
    }
    data = {
        'grantType': 'client_credentials',
        'clientId': client_id,
        'clientSecret': client_secret
    }
    r = requests.post(token_url,
                      headers=headers,
                      data=json.dumps(data))

    return r.json()['access_token']


def base_api(data, document, api_url, access_token):
    """
Header usw., der allen APIs gemeinsam ist
    """
    base_url = BASE_URL
    headers = {
        'Content-Type': 'application/json; charset=UTF-8',
        'Authorization': 'Bearer {}'.format(access_token)
    }
    r = requests.post(base_url + api_url,
                      headers=headers,
                      data=json.dumps(data))

    return r.json()


def parse(sentence, access_token):
    """
Parsing
    """
    data = {'sentence': sentence}
    result = base_api(data, sentence, 'nlp/v1/parse', access_token)

    print('\n<Parsing>\n')
    result_list = list()
    
    for chunks in result['result']:
        for token in chunks['tokens']:
            result_list.append(token['form'])

    print(' '.join(result_list))


def ne(sentence, access_token):
    """
Einzigartige Ausdrucksextraktion
    """
    data = {'sentence': sentence}
    result = base_api(data, sentence, 'nlp/v1/ne', access_token)
    
    print('\n<Einzigartige Ausdrucksextraktion>\n')
    result_list = list()

    for chunks in result['result']:
        result_list.append(chunks['form'])

    print(', '.join(result_list))


def summarize(document, access_token, sent_len):
    """
einpacken
    """
    data = {
        'document': document,
        'sent_len': sent_len
    }
    result = base_api(data, document, 'nlp/beta/summary', access_token)

    print('\n <Zusammenfassung>\n')
    result_list = list()

    for result in result['result']:
        result_list.append(result)
    
    print(''.join(result_list))


if __name__ == "__main__":

    doc = 'Ich habe Michael gestern am Bahnhof von Tokio getroffen. Ich habe vor einem Monat angefangen, ihn zu treffen.'
    args = get_args(doc)  #Argumente abrufen

    #Wenn Sie eine Datei angeben, wird diese priorisiert
    if (args.file_name != None and os.path.exists(args.file_name)):
        with open(args.file_name, 'r', encoding='utf-8') as f:
            doc = f.read()
    else:
        doc = args.text

    access_token = auth(CLIENT_ID, CLIENT_SECRET)  #Zugriffstoken erhalten
    
    #API-Aufruf
    l = [doc, access_token]  #Gemeinsame Argumente

    parse(*l) if (args.parse) else None  #Parsing
    ne(*l) if (args.ne) else None  #Einzigartige Ausdrucksextraktion
    summarize(*l, args.summarize) if (args.summarize) else None  #einpacken

[^ 1]: Im kommerziellen Plan (für Enterprise-Plan) werden nicht nur die Einschränkungen für den Wörterbuchtyp und die Anzahl der Anrufe gelockert, sondern auch die API für Spracherkennung und Sprachsynthese. Es wird jedoch in diesem Artikel nicht behandelt, da es für den persönlichen Gebrauch nicht realistisch ist.