Je vais presser celui-ci

Tout à coup, jetez un coup d'œil aux phrases suivantes.

Bonjour, qu'est-ce que Misa? Je suis Genki. C'est le Kebunriji d'Irigisu, mais c'est le Keikinu d'Iku. Quand tu presses l'œuf

Si vous avez le même temps Jiban-n est un gâchis, mais c'est aussi une suite à lire J'ai délibérément mis trop de lettres Jinban. Comment ça va? Chinya et Yachimeu, n'est-ce pas?

comment c'est? N'est-ce pas étonnamment facile à lire? Cette phrase est (personnellement) un copier-coller relativement célèbre, et son nom officiel est [Typogrisemia](https://ja.wikipedia.org/wiki/%E3%82%BF%E3%82%A4%E3% 83% 9D% E3% 82% B0% E3% 83% AA% E3% 82% BB% E3% 83% 9F% E3% 82% A2).

En gros, lorsqu'ils reconnaissent un mot, les humains ne le comprennent pas caractère par caractère, mais le reconnaissent visuellement comme un ensemble de caractères **. À ce moment-là, les mots sont instantanément compris et prédits dans le cerveau, donc même si les caractères qui composent les mots sont légèrement remplacés, ils peuvent être corrigés et lus **. *** * Ces corrections dépendent des connaissances et du vocabulaire individuels, il existe donc des différences individuelles. *** ***

Cette fois, l 'API d'analyse de syntaxe fournie par API COTOHA (reference / apireference.html # parsing) est utilisé pour analyser le texte d'entrée et le sortir sous forme de texte de typoglisémie.

C'est comme ça.

before :
Sortie de texte post-typogrisémie en utilisant Python et COTOHA vers Qiita
after :
Jouons au pothyn et au choota. Envoyons le taposei miriguabushon à qiita.

Quel résultat comme ça! !!

Quel type d'API est CHOOTA?

«COTOHA» est une ** plate-forme API de traitement du langage naturel / de la voix ** fournie par NTT Communications. En plus de l '«analyse de syntaxe» présentée dans cet article, «extraction d'expressions uniques», «analyse de correspondance», «extraction de mots-clés», «calcul de similarité», «jugement de type de phrase», «estimation d'attribut utilisateur» et «analyse des émotions Diverses fonctions telles que «・« résumé »sont fournies.

L'enregistrement des utilisateurs est facile et chaque API peut être utilisée ** 1000 appels / jour ** même dans le cadre du niveau gratuit, vous pouvez donc jouer avec. Maintenant, je collabore avec Qiita et je fais ce genre de projet, alors rejoignez-nous. S'il te plait donne moi! !!

L'inscription gratuite des utilisateurs peut être effectuée à partir du Portail API COTOHA. Après avoir entré certains éléments de base, un ID utilisateur et un secret pour l'utilisation de l'API seront émis, veuillez donc en prendre note si vous souhaitez essayer les scripts suivants à portée de main.

Je vais presser Pothyn

J'ai fait référence à l'article suivant. Les deux articles sont très faciles à comprendre et sont fortement recommandés!

La base est basée sur l'article ci-dessus, mais j'ai légèrement modifié la partie point de terminaison de l'API. À l'origine, BASE_URL incluait nlp, mais il est omis selon le format officiel COTOHA.

<détails>

Programme principal </ summary>

`cotoha_api.py`


import os
import urllib.request
import json
import configparser
import codecs
import re
import jaconv
import random


#Classe d'opération API COTOHA
class CotohaApi:
    #Initialisation
    def __init__(self, client_id, client_secret, developer_api_base_url, access_token_publish_url):
        self.client_id = client_id
        self.client_secret = client_secret
        self.developer_api_base_url = developer_api_base_url
        self.access_token_publish_url = access_token_publish_url
        self.getAccessToken()

    #Obtenez un jeton d'accès
    def getAccessToken(self):
        #Spécification d'URL d'acquisition de jeton d'accès
        url = self.access_token_publish_url

        #Spécification d'en-tête
        headers={
            "Content-Type": "application/json;charset=UTF-8"
        }

        #Demander les spécifications du corps
        data = {
            "grantType": "client_credentials",
            "clientId": self.client_id,
            "clientSecret": self.client_secret
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()

        #Demande de génération
        req = urllib.request.Request(url, data, headers)

        #Envoyez une demande et recevez une réponse
        res = urllib.request.urlopen(req)

        #Obtenir le corps de la réponse
        res_body = res.read()

        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)

        #Obtenir un jeton d'accès à partir du corps de la réponse
        self.access_token = res_body["access_token"]


    #API d'analyse syntaxique
    def parse(self, sentence):
        #Spécification de l'URL de l'API d'analyse syntaxique
        url = self.developer_api_base_url + "nlp/v1/parse"
        #Spécification d'en-tête
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Demander les spécifications du corps
        data = {
            "sentence": sentence
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()
        #Demande de génération
        req = urllib.request.Request(url, data, headers)
        #Envoyez une demande et recevez une réponse
        try:
            res = urllib.request.urlopen(req)
        #Que faire si une erreur se produit dans la demande
        except urllib.request.HTTPError as e:
            #Si le code d'état est 401 Non autorisé, réacquérir le jeton d'accès et demander à nouveau
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Si l'erreur est différente de 401, la cause est affichée.
            else:
                print ("<Error> " + e.reason)

        #Obtenir le corps de la réponse
        res_body = res.read()
        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)
        #Obtenir le résultat de l'analyse à partir du corps de la réponse
        return res_body


    #API d'extraction d'expression unique
    def ne(self, sentence):
        #Spécification d'URL de l'API d'extraction d'expression unique
        url = self.developer_api_base_url + "nlp/v1/ne"
        #Spécification d'en-tête
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Demander les spécifications du corps
        data = {
            "sentence": sentence
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()
        #Demande de génération
        req = urllib.request.Request(url, data, headers)
        #Envoyez une demande et recevez une réponse
        try:
            res = urllib.request.urlopen(req)
        #Que faire si une erreur se produit dans la demande
        except urllib.request.HTTPError as e:
            #Si le code d'état est 401 Non autorisé, réacquérir le jeton d'accès et demander à nouveau
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Si l'erreur est différente de 401, la cause est affichée.
            else:
                print ("<Error> " + e.reason)

        #Obtenir le corps de la réponse
        res_body = res.read()
        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)
        #Obtenir le résultat de l'analyse à partir du corps de la réponse
        return res_body


    #API d'analyse de correspondance
    def coreference(self, document):
        #Spécification de l'URL d'acquisition de l'API d'analyse de correspondance
        url = self.developer_api_base_url + "beta/coreference"
        #Spécification d'en-tête
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Demander les spécifications du corps
        data = {
            "document": document
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()
        #Demande de génération
        req = urllib.request.Request(url, data, headers)
        #Envoyez une demande et recevez une réponse
        try:
            res = urllib.request.urlopen(req)
        #Que faire si une erreur se produit dans la demande
        except urllib.request.HTTPError as e:
            #Si le code d'état est 401 Non autorisé, réacquérir le jeton d'accès et demander à nouveau
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Si l'erreur est différente de 401, la cause est affichée.
            else:
                print ("<Error> " + e.reason)

        #Obtenir le corps de la réponse
        res_body = res.read()
        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)
        #Obtenir le résultat de l'analyse à partir du corps de la réponse
        return res_body


    #API d'extraction de mots-clés
    def keyword(self, document):
        #Spécification de l'URL de l'API d'extraction de mots-clés
        url = self.developer_api_base_url + "nlp/v1/keyword"
        #Spécification d'en-tête
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Demander les spécifications du corps
        data = {
            "document": document
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()
        #Demande de génération
        req = urllib.request.Request(url, data, headers)
        #Envoyez une demande et recevez une réponse
        try:
            res = urllib.request.urlopen(req)
        #Que faire si une erreur se produit dans la demande
        except urllib.request.HTTPError as e:
            #Si le code d'état est 401 Non autorisé, réacquérir le jeton d'accès et demander à nouveau
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Si l'erreur est différente de 401, la cause est affichée.
            else:
                print ("<Error> " + e.reason)

        #Obtenir le corps de la réponse
        res_body = res.read()
        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)
        #Obtenir le résultat de l'analyse à partir du corps de la réponse
        return res_body


    #API de calcul de similarité
    def similarity(self, s1, s2):
        #Spécification de l'URL de l'API de calcul de similarité
        url = self.developer_api_base_url + "nlp/v1/similarity"
        #Spécification d'en-tête
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Demander les spécifications du corps
        data = {
            "s1": s1,
            "s2": s2
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()
        #Demande de génération
        req = urllib.request.Request(url, data, headers)
        #Envoyez une demande et recevez une réponse
        try:
            res = urllib.request.urlopen(req)
        #Que faire si une erreur se produit dans la demande
        except urllib.request.HTTPError as e:
            #Si le code d'état est 401 Non autorisé, réacquérir le jeton d'accès et demander à nouveau
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Si l'erreur est différente de 401, la cause est affichée.
            else:
                print ("<Error> " + e.reason)

        #Obtenir le corps de la réponse
        res_body = res.read()
        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)
        #Obtenir le résultat de l'analyse à partir du corps de la réponse
        return res_body


    #API de détermination du type de déclaration
    def sentenceType(self, sentence):
        #Spécification de l'URL de l'API de détermination du type de déclaration
        url = self.developer_api_base_url + "nlp/v1/sentence_type"
        #Spécification d'en-tête
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Demander les spécifications du corps
        data = {
            "sentence": sentence
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()
        #Demande de génération
        req = urllib.request.Request(url, data, headers)
        #Envoyez une demande et recevez une réponse
        try:
            res = urllib.request.urlopen(req)
        #Que faire si une erreur se produit dans la demande
        except urllib.request.HTTPError as e:
            #Si le code d'état est 401 Non autorisé, réacquérir le jeton d'accès et demander à nouveau
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Si l'erreur est différente de 401, la cause est affichée.
            else:
                print ("<Error> " + e.reason)

        #Obtenir le corps de la réponse
        res_body = res.read()
        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)
        #Obtenir le résultat de l'analyse à partir du corps de la réponse
        return res_body


    #API d'estimation des attributs utilisateur
    def userAttribute(self, document):
        #Spécification de l'URL de l'API d'estimation des attributs utilisateur
        url = self.developer_api_base_url + "beta/user_attribute"
        #Spécification d'en-tête
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Demander les spécifications du corps
        data = {
            "document": document
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()
        #Demande de génération
        req = urllib.request.Request(url, data, headers)
        #Envoyez une demande et recevez une réponse
        try:
            res = urllib.request.urlopen(req)
        #Que faire si une erreur se produit dans la demande
        except urllib.request.HTTPError as e:
            #Si le code d'état est 401 Non autorisé, réacquérir le jeton d'accès et demander à nouveau
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Si l'erreur est différente de 401, la cause est affichée.
            else:
                print ("<Error> " + e.reason)

        #Obtenir le corps de la réponse
        res_body = res.read()
        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)
        #Obtenir le résultat de l'analyse à partir du corps de la réponse
        return res_body



if __name__ == '__main__':
    #Obtenez l'emplacement du fichier source
    APP_ROOT = os.path.dirname(os.path.abspath( __file__)) + "/"

    #Obtenir la valeur définie
    config = configparser.ConfigParser()
    config.read(APP_ROOT + "config.ini")
    CLIENT_ID = config.get("COTOHA API", "Developer Client id")
    CLIENT_SECRET = config.get("COTOHA API", "Developer Client secret")
    DEVELOPER_API_BASE_URL = config.get("COTOHA API", "Developer API Base URL")
    ACCESS_TOKEN_PUBLISH_URL = config.get("COTOHA API", "Access Token Publish URL")

    #Instanciation de l'API COTOHA
    cotoha_api = CotohaApi(CLIENT_ID, CLIENT_SECRET, DEVELOPER_API_BASE_URL, ACCESS_TOKEN_PUBLISH_URL)

    #Phrase cible d'analyse
    sentence = "Sortie de texte post-typogrisémie en utilisant Python et COTOHA vers Qiita"

    #Affichage avant mise en forme
    print('before :')
    print(sentence)

    #Exécution de l'API d'analyse syntaxique
    result_json = cotoha_api.parse(sentence)

    #Liste des chaînes de caractères avant le formatage
    word_list_base = []
    #Liste des caractères formatés
    word_list = []

    #Expression régulière pour le jugement alphanumérique
    alnumReg = re.compile(r'^[a-zA-Z0-9 ]+$')

    #Traitement en boucle des résultats d'analyse
    for i in range(len(result_json['result'])):
        for j in range(len(result_json['result'][i]['tokens'])):
            #Pour les caractères alphanumériques'form'Pour le japonais, la valeur de'kana'Utilisez la valeur de
            word = result_json['result'][i]['tokens'][j]['form']
            kana = result_json['result'][i]['tokens'][j]['kana']
            #Juger s'il s'agit de caractères alphanumériques demi-largeur
            if alnumReg.match(word) is not None:
                #Déterminez s'il s'agit d'un mot ou non
                if ' ' in word:
                    #Si plus d'un est configuré plus tard, démonter davantage
                    word_list_base.extend(word.split(' '))
                else :
                    word_list_base.append(word)
            #Japonais
            else :
                #Convertir katakana en hiragana et ajouter à la liste
                word_list_base.append(jaconv.kata2hira(kana))
            
    #Analysez chaque mot et remplacez les caractères autres que le début et la fin de 4 caractères ou plus
    for i in range(len(word_list_base)):
        #4 caractères ou plus
        if len(word_list_base[i]) > 3:
            #Découpez d'abord en une liste caractère par caractère
            wl_all = list(word_list_base[i])
            #Gardez les premier et dernier caractères
            first_word = wl_all[0]
            last_word = wl_all[len(wl_all) - 1]
            #Obtenez les caractères à l'intérieur sous forme de liste
            wl = wl_all[1:len(wl_all) - 1]
            #Mélanger
            random.shuffle(wl)
            word_list.append(first_word + ''.join(wl) + last_word)
        #S'il contient moins de 4 caractères, laissez-le tel quel
        else :
            word_list.append(word_list_base[i])

    #Afficher le résultat du formatage
    print('after :')
    print(' '.join(word_list))

fichier de configuration

`config.ini`


[COTOHA API]
Developer API Base URL: https://api.ce-cotoha.com/api/dev/
Developer Client id:[Identité du client]
Developer Client secret:【secret】
Access Token Publish URL: https://api.ce-cotoha.com/v1/oauth/accesstokens

Pour l'utiliser, entrez l'ID client et le secret dans config.ini et placez-le dans la même hiérarchie que cotoha_api.py. L'exécution est la suivante.

python cotoha_api.py

`Résultat d'exécution`


before :
Sortie de texte post-typogrisémie en utilisant Python et COTOHA vers Qiita
after :
Jouons au pothyn et au choota. Envoyons le taposei miriguabushon à qiita.

Résumé

Même si je n'avais aucune connaissance de «Python» ou du «traitement du langage naturel», j'ai continué à l'implémenter (** script presque humain **). Cependant, même dans un tel état, j'ai personnellement obtenu des résultats satisfaisants, donc «COTOHA» est très facile à manipuler et je pense que c'est la meilleure introduction.

Nous espérons que vous serez intéressé par COTOHA même un peu après avoir lu cet article.

Sakonbubuken

Quand

En passant, ** "Erreur typographique" ** signifie ** "erreur typographique" ** et ** "Hypoglycemi" ** signifie hypoglycémique [langue du sac](https: //ja.wikipedia) .org / wiki /% E3% 81% 8B% E3% 81% B0% E3% 82% 93% E8% AA% 9E). Kaban est un mot composé de plusieurs mots, tels que "Netsusama-to" et "Nespresso".

cette? Cela semble intéressant si vous le gérez avec COTOHA ...

Si je devais le faire, ce serait ** "J'ai essayé de créer un langage maintenant squid en utilisant COTOHA" ** (rires)

Créez des phrases "Typogrisemia" en utilisant COTOHA