Laissez l 'API COTOHA faire les choses difficiles.

L'API COTOHA est une API qui peut facilement utiliser le traitement du langage naturel basé sur les résultats de recherche du groupe NTT [^ 1]. La mise en œuvre d'algorithmes difficiles est simplifiée en appuyant sur cette API.

Quand il s'agit d'API, vous pouvez obtenir une image difficile. Cependant, cette API est très facile à utiliser et, en outre, cet article explique comment l'utiliser plus soigneusement et en détail. De plus, tout l'exemple de code de cet article a été implémenté en Python pour vous aider si vous souhaitez implémenter vous-même un algorithme difficile à l'avenir. Aucune connaissance préalable de l'API n'est requise! (Alors soyez assuré)

1.2 Types de traitement du langage naturel qui seront disponibles dans cet article

** Synthèse de phrases, analyse syntaxique, extraction d'expressions propres, analyse de correspondance, extraction de mots clés, calcul de similarité entre deux phrases, estimation du type de phrase, estimation d'attributs humains tels que l'âge et la profession, suppression de la stagnation (ah, euh, etc.), Détection des erreurs de reconnaissance vocale, analyse des émotions **

Ce sont tous des processus de langage naturel qui peuvent être utilisés par des utilisateurs gratuits (pour les développeurs) de l'API COTOHA. Dans cet article, je présenterai ces tâches et expliquerai le code qui fonctionne réellement. (Cependant, comme il est contraire à l'intention de cet article de se terminer par le copier-coller, nous ne fournissons pas d'implémentation qui puisse utiliser tout le traitement du langage naturel. Il existe en fait trois types de copier-coller qui peuvent être utilisés: le résumé, l'analyse syntaxique et l'extraction d'expression appropriée. Est.)

1.3 Résultat final

Regardons le résultat du résumé de la phrase à titre d'exemple. J'ai résumé l'article de Qiita que j'ai (@MonaCat) écrit plus tôt comme texte d'entrée.

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

<Résumé>

Les résumés de phrases sont divisés en type d'extraction et type de génération (type abstrait), mais actuellement le type de génération (combinaison de type d'extraction) est le plus courant.
Introduction du modèle de résumé des phrases neuronales-La méthode de résumé automatique basée sur seq2seq de M3 Tech Blog est résumée.
Commentaire sur papier L'attention est tout ce dont vous avez besoin(Transformer) -Blog de Deep Learning Si vous lisez ceci en premier, cela ne fait aucun doute.

Laissez-moi vous expliquer brièvement.

J'exécute un programme avec python cotoha_test.py. De plus, en passant diverses options comme arguments, il est possible de spécifier l'API à appeler. Dans la figure ci-dessus, la partie -f data / input.txt -s 3 est une option. Il fait référence à un fichier appelé ʻinput.txt` et spécifie que l'API de résumé automatique doit être utilisée avec 3 phrases de résumé. Par conséquent, le résultat de sortie doit être un résumé de 3 phrases.

En modifiant cette option, il est possible d'utiliser d'autres API et de modifier les paramètres (par exemple, résumer avec 5 phrases au lieu de 3 phrases). C'est devenu un peu difficile de ce montant, mais j'ai ajouté une explication supplémentaire de la mise en œuvre de l'option. Je suis très heureux si seulement ceux qui en ont les moyens peuvent le lire car il est considéré comme n'étant pas lié à la ligne principale.

2 Connaissons le traitement du langage naturel

Avant de l'implémenter, apprenons un peu plus sur le traitement du langage naturel. La langue naturelle est une langue comme le japonais ou l'anglais que nous utilisons dans notre vie quotidienne. Autrement dit, le traitement du langage naturel fait référence à un domaine technique qui «traite» le «langage naturel».

Ce chapitre décrit brièvement les technologies de traitement du langage naturel qui peuvent être utilisées avec l'API COTOHA. (Partiellement omis)

• Analyse

L'analyse syntaxique consiste à diviser une phrase (chaîne de caractères) en éléments morphologiques et à analyser la relation structurelle entre eux. Par exemple, la phrase "j'ai vu" est composée de "nom" + "auxiliaire" + "verbe". La relation structurelle des chaînes de caractères non marquées peut être clarifiée par une analyse syntaxique.

--Extraction d'expression unique

L'extraction d'expressions uniques est une technologie qui extrait automatiquement la nomenclature appropriée (noms personnels, noms de lieux, etc.). Il existe d'innombrables nomenclatures appropriées dans le monde, mais il n'est pas réaliste de les enregistrer toutes dans le dictionnaire. Par conséquent, en automatisant l'extraction, il devient possible de traiter une grande quantité de texte.

--Analyse de correspondance

Les directives et les synonymes tels que «ceci» et «il» sont utilisés comme les prédécesseurs, mais ils peuvent être lus parce que nous comprenons naturellement leurs relations lors de la compréhension des phrases. y a-t-il. Cette relation s'appelle la relation de correspondance, et la technique pour l'analyser s'appelle l'analyse de correspondance.

• Extraction de mots clés

Les mots-clés ont différentes significations, mais l'API COTOHA calcule les phrases et les mots caractéristiques et les extrait en tant que mots-clés. En d'autres termes, il peut être considéré comme une phrase ou un mot typique dans une phrase.

--Estimation d'attributs

C'est une technique d'estimation des attributs (âge, sexe, loisirs, profession, etc.). L'API COTOHA vise à estimer les attributs des utilisateurs de Twitter.

• Suppression de la stagnation

Iyodomi est un mot qui est utilisé entre les phrases quand on parle, comme "ah" et "uh". Par exemple, une phrase transcrite par reconnaissance vocale peut contenir une stagnation qui n'est pas nécessaire pour la conversion en texte. En supprimant la stagnation dans un tel cas, il devient possible de traiter le texte en données faciles à utiliser.

--Analyse des mouvements

L'analyse des émotions (jugement négatif / positif) consiste à classer les émotions écrites à partir de phrases en deux valeurs, négatives et positives. L'analyse utilisant le deep learning sera plus active que les domaines présentés ci-dessus.

• Résumé de la phrase

C'est une technologie qui résume automatiquement les phrases en une ou plusieurs phrases. Récemment, il est devenu courant pour les sites d'information de proposer un résumé en trois phrases. On peut dire que c'est une tâche similaire à l'extraction de mots-clés en ce qu'elle analyse des phrases / phrases importantes à partir de phrases longues.

Si vous êtes intéressé par la synthèse de texte, cet article est recommandé. Bien qu'il s'intitule «Introduction of Papers», il devrait être utile car il résume les informations des bases aux dernières technologies: Présentation du papier «BERTSUM» qui résume automatiquement avec BERT + α --Qiita //qiita.com/MonaCat/items/5123d2f970cba1acd897)

3 Utilisons-le réellement

Je suis désolé de vous avoir fait attendre. Expérimentons le traitement du langage naturel à l'aide de l'API COTOHA.

3.1 Parties communes

Tout d'abord, à partir des parties communes nécessaires quelle que soit l'API que vous souhaitez utiliser.

L'API COTOHA peut être enregistrée et utilisée gratuitement, alors enregistrez-vous depuis API COTOHA.

Les informations d'enregistrement nécessitent votre nom et votre affiliation, mais vous n'avez pas besoin d'informations telles qu'une carte de crédit. Si vous vous inscrivez, vous obtiendrez les informations ci-dessous.

Parmi ceux-ci, l '«ID client» et le «secret client» diffèrent d'une personne à l'autre, soyez donc prêt à les copier plus tard.

3.1.1 Obtention d'un jeton d'accès

À partir de là, implémentez en Python. Je vous laisse l'environnement Python, mais veuillez installer les modules nécessaires selon les besoins avec pip ou conda afin que vous puissiez les utiliser.

Tout d'abord, définissez une fonction pour obtenir un jeton d'accès.

CLIENT_ID = 'Réécrire selon le cas'
CLIENT_SECRET = 'Réécrire selon le cas'


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)  #Obtenez un jeton d'accès

Vous avez peut-être soudainement trouvé cela difficile. Mais c'est très simple. Regardons-les dans l'ordre.

Tout d'abord, auth () est appelée avec les informations d'authentification ci-dessus comme argument.

Dans auth (), le jeton d'accès est acquis à l'aide des informations d'authentification. Dans le Guide de démarrage, il est obtenu par une commande, mais cette fois, la même chose est implémentée en Python. Notez que vous pouvez obtenir le fichier json en cas de succès, mais ici, vous ne voulez que le jeton d'accès. Par conséquent, il renvoie r.json ['access_token'].

Vous pourrez utiliser l'API à l'aide de ce jeton d'accès.

3.1.2 Spécification des arguments (facultatif)

Dans cet exemple de code, l'argument peut être spécifié à l'aide du module ʻargparse`. Cela a été expliqué dans la section 1.3, mais la raison pour laquelle nous avons rendu possible la spécification d'arguments est que la commutation est pratique car on suppose que plusieurs API seront utilisées.

Dans cette section, je vais expliquer brièvement «argumentaire», mais comme cela n'a rien à voir avec la ligne principale, veuillez l'ignorer si vous ne pouvez pas vous le permettre.

Donc d'abord, avant d'obtenir le jeton d'accès

if __name__ == "__main__":

    document = 'Le texte utilisé lorsqu'aucun texte d'entrée n'est spécifié. Dans cette implémentation, vous pouvez utiliser deux modèles, «spécifier du texte avec des arguments» et «spécifier un fichier texte avec des arguments». Veuillez essayer.'
    args = get_args(document)  #Obtenir des arguments

    access_token = auth(CLIENT_ID, CLIENT_SECRET)  #Obtenez un jeton d'accès

Appelons get_args () avec. Le contenu de cette fonction est le suivant.

def get_args(document):
    argparser = argparse.ArgumentParser(description='Code pour lire le traitement du langage naturel à l'aide de l'API Cotoha')
    argparser.add_argument('-t', '--text', type=str, default=document, help='La phrase que vous souhaitez analyser')
    argparser.add_argument('-f', '--file_name', type=str, help='Je veux analyser.chemin txt')
    argparser.add_argument('-p', '--parse', action='store_true', help='Précisez si vous souhaitez analyser la syntaxe')
    argparser.add_argument('-s', '--summarize', type=int, help='Spécifiez le nombre de phrases récapitulatives pour la récapitulation automatique')

    return argparser.parse_args()

La première ligne décrit le code dans la description. Ceci est affiché lorsque -h est utilisé comme argument de ligne de commande.

Un exemple lorsque -h est spécifié.

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

Code pour lire le traitement du langage naturel à l'aide de l'API Cotoha

optional arguments:
  -h, --help            show this help message and exit
  -t TEXT, --text TEXT Le texte que vous souhaitez analyser
  -f FILE_NAME, --file_name FILE_NAME
Chemin du fichier texte que vous souhaitez analyser
  -p, --analyser l'analyse syntaxique
  -n, --ne extraction d'expressions uniques
  -s SUMMARIZE, --summarize SUMMARIZE
Nombre de phrases récapitulatives dans la synthèse automatique

Les lignes suivantes définissent les arguments dans l'ordre avec ʻadd_argument`.

Bien sûr, si vous définissez un argument, rien ne se passe à moins que vous n'implémentiez ce qui se passe lorsque cet argument est spécifié. Cette fois, je veux effectuer une analyse de syntaxe lorsque -p est spécifié. Si c'est tout, cela semble fonctionner uniquement par branchement conditionnel avec l'instruction if. Faisons-le tout de suite.

if (args.parse):
    parse(doc, access_token)  #Appel de fonction

Si ʻargs.parse` vaut True, appelez la fonction parse. L'analyse des fonctions n'est pas apparue jusqu'à présent, vous ne saurez donc pas de quoi il s'agit. Considérez-le ici simplement comme une fonction qui effectue une analyse syntaxique. Les détails seront expliqués dans un chapitre ultérieur.

ʻArgs.parse est l'option que j'ai ajoutée plus tôt dans ʻargparser.add_argument. Notez que ce doit être ʻargs.parse, pas ʻargs.p. De même, par exemple, ʻargs.summarize` peut être utilisé pour la synthèse.

En passant, à l'avenir, si de nombreuses tâches autres que l'analyse syntaxique et la synthèse sont liées à des branchements conditionnels avec des instructions if, cela semblera un peu inesthétique. Par conséquent, je vais simplifier un peu.

#Appel API
l = [doc, access_token]  #Arguments communs
parse(*l) if (args.parse) else None  #Analyse

Ce que je fais est le même qu'avant, mais j'écris une instruction if sur une ligne, je la mets dans une liste en considérant qu'il existe de nombreux arguments communs, je la développe et je la passe à la fonction pour l'appeler.

Enfin, implémentons quand le fichier est spécifié avec -f. Lorsqu'un fichier est spécifié, il est priorisé, mais si le fichier spécifié n'existe pas avant cela, une erreur peut se produire.

#Si vous spécifiez un fichier, celui-ci est priorisé
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

Si vous suivez ceci jusqu'à ce point, l'implémentation doit être la suivante.

import argparse
import requests
import json
import os


BASE_URL = 'https://api.ce-cotoha.com/api/dev/'
CLIENT_ID = ''  #Réécrire selon le cas
CLIENT_SECRET = ''  #Réécrire selon le cas


def get_args(document):
    argparser = argparse.ArgumentParser(description='Code pour lire le traitement du langage naturel à l'aide de l'API Cotoha')
    argparser.add_argument('-t', '--text', type=str, default=document, help='Texte que vous souhaitez analyser')
    argparser.add_argument('-f', '--file_name', type=str, help='Chemin du fichier texte que vous souhaitez analyser')
    argparser.add_argument('-p', '--parse', action='store_true', help='Analyse')
    argparser.add_argument('-n', '--ne', action='store_true', help='Extraction d'expression unique')
    argparser.add_argument('-c', '--coreference', action='store_true', help='Analyse de correspondance')
    argparser.add_argument('-k', '--keyword', action='store_true', help='Extraction de mots-clés')
    argparser.add_argument('-s', '--summarize', type=int, help='Nombre de phrases récapitulatives dans la synthèse automatique')

    return argparser.parse_args()


def auth(client_id, client_secret):
    """
Fonction pour obtenir un jeton d'accès
    """
    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):
    """
En-tête, etc. commun à toutes les API
    """
    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 = 'J'ai rencontré Michael à la gare de Tokyo hier. J'ai commencé à sortir avec lui il y a un mois.'
    args = get_args(doc)  #Obtenir des arguments

    #Si vous spécifiez un fichier, celui-ci est priorisé
    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)  #Obtenez un jeton d'accès
    
    #Appel API
    l = [doc, access_token]  #Arguments communs

    parse(*l) if (args.parse) else None  #Analyse
    ne(*l) if (args.ne) else None  #Extraction d'expression unique
    coreference(*l) if (args.coreference) else None  #Analyse de correspondance
    keyword(*l) if (args.keyword) else None  #Extraction de mots-clés
    summarize(*l, args.summarize) if (args.summarize) else None  #emballer

Bien sûr, ce programme ne fonctionne toujours pas. C'est parce qu'il ne définit pas des fonctions telles que parse () et ne (). Il sera mis en œuvre dans les sections suivantes.

3.2 Différentes parties pour chaque tâche

Pour ceux qui ont ignoré 3.1.2, nous utilisons ici un programme qui effectue uniquement une analyse de syntaxe, comme le programme suivant.

import argparse
import requests
import json
import os


BASE_URL = 'https://api.ce-cotoha.com/api/dev/'
CLIENT_ID = 'Réécrire selon le cas'
CLIENT_SECRET = 'Réécrire selon le cas'

def auth(client_id, client_secret):
    """
Fonction pour obtenir un jeton d'accès
    """
    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 = 'J'ai rencontré Michael à la gare de Tokyo hier. J'ai commencé à sortir avec lui il y a un mois.'

    access_token = auth(CLIENT_ID, CLIENT_SECRET)  #Obtenez un jeton d'accès
    parse(doc, access_token)  #Analyse

Ceux qui ont suivi 3.1.2 devraient simplement utiliser cette implémentation telle quelle. Dans tous les cas, ce que nous implémentons ici est une fonction qui appelle des API telles que parse () et ne () pour effectuer le traitement du langage naturel.

3.2.1 Analyse syntaxique

Si vous lisez Syntax Analysis Reference, vous trouverez l'en-tête de la requête, le corps de la requête, etc., et vous devez spécifier la clé. Tu verras. Cependant, l'en-tête de requête est en fait commun à toutes les API COTOHA. Par conséquent, les parties communes telles que les en-têtes de requête sont implémentées par une fonction appelée base_api (), et les parties uniques à l'analyse syntaxique sont implémentées par une fonction appelée parse ().

def base_api(data, document, api_url, access_token):
    """
En-tête, etc. commun à toutes les API
    """
    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):
    """
Analyse
    """
    data = {'sentence': sentence}
    result = base_api(data, sentence, 'nlp/v1/parse', access_token)

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

    print(' '.join(result_list))

Commençons par base_api (). Les en-têtes de demande que vous venez de voir sont spécifiés dans les en-têtes. Vous pouvez voir que la requête est envoyée avec cette valeur, le corps de la requête, le texte à analyser et l'URL de l'API comme arguments. Renvoie le dernier fichier json obtenu.

Dans parse (), le corps de la requête est d'abord spécifié par la variable data. Cette fois, la phrase clé est spécifiée par la phrase variable (vous pouvez penser à ce que vous dites, mais cela signifie la même chose).

Ensuite, la valeur de base_api (), c'est-à-dire le fichier json, est contenue dans la variable de résultat.

Ce fichier json contient le résultat de l'exécution de l'analyse syntaxique, alors lisez-le. Le format est décrit dans l'exemple de réponse de la même référence. Quand je lis l'exemple de réponse de l'analyse syntaxique, il semble que la forme clé de l'objet d'information morphologique soit ce que je recherchais, je vais donc l'ajouter à la liste.

Cela vous donnera les résultats suivants:

> python cotoha_test.py

<Analyse>

J'ai rencontré Michael à la gare de Tokyo hier. J'ai commencé à sortir avec lui il y a un mois.

3.2.2 Extraction d'expression unique

Vient ensuite l'extraction d'expressions uniques, mais je vais l'omettre car je ne répéterai que la même explication que précédemment. En fait, vous pouvez utiliser la plupart des autres API comme auparavant.

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

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

    print(', '.join(result_list))

> python cotoha_test.py

<Extraction d'expression unique>

hier,Michael,Gare de Tokyo,Un mois

3.2.3 Résumé

C'est un gros problème, alors faisons quelque chose d'un peu différent. Si vous lisez la référence abstraite, vous trouverez «sent_len» dans le corps de la requête où vous pouvez spécifier le nombre d'abstracts. C'est aussi un gros problème, donc je veux l'utiliser.

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

    print('\n <Résumé>\n')
    result_list = list()

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

Vous pouvez maintenant résumer avec n'importe quel nombre de phrases récapitulatives en entrant une valeur spécifique dans sent_len. Si vous pouvez implémenter l'option de 3.1.2, ce sera pratique car vous pouvez spécifier sent_len comme argument.

> python cotoha_test.py -s 1

<Résumé>

J'ai rencontré Michael à la gare de Tokyo hier.

3.3.3 Autre traitement du langage naturel

D'autres API peuvent être implémentées de la même manière, je les omettrai donc.

4 Résumé

Enfin, un programme capable d'effectuer une analyse de syntaxe, une extraction d'expressions uniques et une synthèse est présenté et résumé. Encore une fois, d'autres API peuvent être implémentées de la même manière, donc si vous êtes intéressé par le traitement du langage naturel, essayez de l'implémenter vous-même.

import argparse
import requests
import json
import os


BASE_URL = 'https://api.ce-cotoha.com/api/dev/'
CLIENT_ID = ''  #Réécrire selon le cas
CLIENT_SECRET = ''  #Réécrire selon le cas


def get_args(document):
    argparser = argparse.ArgumentParser(description='Code pour lire le traitement du langage naturel à l'aide de l'API Cotoha')
    argparser.add_argument('-t', '--text', type=str, default=document, help='Texte que vous souhaitez analyser')
    argparser.add_argument('-f', '--file_name', type=str, help='Chemin du fichier texte que vous souhaitez analyser')
    argparser.add_argument('-p', '--parse', action='store_true', help='Analyse')
    argparser.add_argument('-n', '--ne', action='store_true', help='Extraction d'expression unique')
    argparser.add_argument('-s', '--summarize', type=int, help='Nombre de phrases récapitulatives dans la synthèse automatique')

    return argparser.parse_args()


def auth(client_id, client_secret):
    """
Fonction pour obtenir un jeton d'accès
    """
    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):
    """
En-tête, etc. commun à toutes les API
    """
    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):
    """
Analyse
    """
    data = {'sentence': sentence}
    result = base_api(data, sentence, 'nlp/v1/parse', access_token)

    print('\n<Analyse>\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):
    """
Extraction d'expression unique
    """
    data = {'sentence': sentence}
    result = base_api(data, sentence, 'nlp/v1/ne', access_token)
    
    print('\n<Extraction d'expression unique>\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):
    """
emballer
    """
    data = {
        'document': document,
        'sent_len': sent_len
    }
    result = base_api(data, document, 'nlp/beta/summary', access_token)

    print('\n <Résumé>\n')
    result_list = list()

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


if __name__ == "__main__":

    doc = 'J'ai rencontré Michael à la gare de Tokyo hier. J'ai commencé à sortir avec lui il y a un mois.'
    args = get_args(doc)  #Obtenir des arguments

    #Si vous spécifiez un fichier, celui-ci est priorisé
    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)  #Obtenez un jeton d'accès
    
    #Appel API
    l = [doc, access_token]  #Arguments communs

    parse(*l) if (args.parse) else None  #Analyse
    ne(*l) if (args.ne) else None  #Extraction d'expression unique
    summarize(*l, args.summarize) if (args.summarize) else None  #emballer

[^ 1]: Dans le plan commercial (pour le plan Entreprise), non seulement les restrictions sur le type de dictionnaire et le nombre d'appels seront assouplies, mais aussi l'API pour la reconnaissance vocale et la synthèse vocale sera disponible. Cependant, il n'est pas couvert dans cet article car il n'est pas réaliste pour un usage personnel.