Bitte werfen Sie plötzlich einen kurzen Blick auf die folgenden Sätze.
Hallo, was ist Misa? Ich bin Genki. Dies ist der Kebunriji von Irigisu, aber es ist der Keikinu von Iku. Wenn Sie das Ei drücken
Wenn Sie die gleiche Zeit haben Jiban-n ist ein Chaos, aber es ist auch eine Fortsetzung zu lesen Ich habe absichtlich zu viel in die Buchstaben Jinban geschrieben. Wie geht es dir? Chinya und Yachimeu richtig?
Wie ist das? Ist es nicht überraschend leicht zu lesen? Dieser Satz ist (persönlich) ein relativ berühmtes Copy & Paste und heißt offiziell [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).
Grob gesagt verstehen Menschen beim Erkennen eines Wortes es nicht Zeichen für Zeichen, sondern erkennen es visuell als eine Reihe von Zeichen **. Zu diesem Zeitpunkt werden die Wörter sofort im Gehirn verstanden und vorhergesagt. Selbst wenn die Zeichen, aus denen die Wörter bestehen, leicht ersetzt werden, können sie korrigiert und gelesen werden **. *** * Diese Korrekturen hängen vom individuellen Wissen und Vokabular ab, daher gibt es individuelle Unterschiede. *** ***
Diesmal die Syntaxanalyse-API, die von der [COTOHA-API] bereitgestellt wird (https://api.ce-cotoha.com/contents/index.html). (reference / apireference.html # parsing) wird verwendet, um den Eingabetext zu analysieren und als Typoglisämie-Text auszugeben.
before :
Post Typogrisemia Textausgabe mit Python und COTOHA an Qiita
after :
Lass uns Pothyn und Choota spielen. Lass uns das Taposei Miriguabushon an Qiita schicken.
Was für ein Ergebnis! !!
COTOHA ist eine ** Plattform für die Verarbeitung natürlicher Sprache / Sprachverarbeitung **, die von NTT Communications bereitgestellt wird.
Zusätzlich zu der in diesem Artikel vorgestellten "Syntaxanalyse", "eindeutige Ausdrucksextraktion", "Korrespondenzanalyse", "Schlüsselwortextraktion", "Ähnlichkeitsberechnung", "Satztypbeurteilung", "Benutzerattributschätzung" und "Emotionsanalyse" Verschiedene Funktionen wie "Zusammenfassung" werden bereitgestellt.
Die Benutzerregistrierung ist einfach und jede API kann sogar innerhalb der kostenlosen Ebene verwendet werden ** 1000 Anrufe / Tag **, sodass Sie damit herumspielen können.
Jetzt arbeite ich mit Qiita zusammen und mache diese Art von Projekt, also mach bitte mit. Bitte gib mir! !!
Die kostenlose Benutzerregistrierung kann über das COTOHA API Portal erfolgen. Nach Eingabe einiger grundlegender Elemente werden eine Benutzer-ID und ein Geheimnis für die Verwendung der API ausgegeben. Notieren Sie sich diese, wenn Sie die folgenden Skripte ausprobieren möchten.
Ich habe auf den folgenden Artikel verwiesen. Beide Artikel sind sehr leicht zu verstehen und sehr zu empfehlen!
Die Basis basiert auf dem obigen Artikel, aber ich habe den Endpunktteil der API ein wenig optimiert.
Ursprünglich enthielt BASE_URL`` nlp, wird aber gemäß dem offiziellen COTOHA-Format weggelassen.
cotoha_api.py
import os
import urllib.request
import json
import configparser
import codecs
import re
import jaconv
import random
#COTOHA API-Operationsklasse
class CotohaApi:
#Initialisieren
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()
#Zugriffstoken erhalten
def getAccessToken(self):
#Zugriff auf die URL-Angabe für die Token-Erfassung
url = self.access_token_publish_url
#Header-Spezifikation
headers={
"Content-Type": "application/json;charset=UTF-8"
}
#Körperspezifikation anfordern
data = {
"grantType": "client_credentials",
"clientId": self.client_id,
"clientSecret": self.client_secret
}
#Codieren Sie die Anforderungshauptteilspezifikation in JSON
data = json.dumps(data).encode()
#Anforderungsgenerierung
req = urllib.request.Request(url, data, headers)
#Senden Sie eine Anfrage und erhalten Sie eine Antwort
res = urllib.request.urlopen(req)
#Antwortkörper erhalten
res_body = res.read()
#Dekodieren Sie den Antworttext von JSON
res_body = json.loads(res_body)
#Holen Sie sich das Zugriffstoken vom Antworttext
self.access_token = res_body["access_token"]
#Syntax-Parsing-API
def parse(self, sentence):
#Syntax-Parsing-API-URL-Spezifikation
url = self.developer_api_base_url + "nlp/v1/parse"
#Header-Spezifikation
headers={
"Authorization": "Bearer " + self.access_token,
"Content-Type": "application/json;charset=UTF-8",
}
#Körperspezifikation anfordern
data = {
"sentence": sentence
}
#Codieren Sie die Anforderungshauptteilspezifikation in JSON
data = json.dumps(data).encode()
#Anforderungsgenerierung
req = urllib.request.Request(url, data, headers)
#Senden Sie eine Anfrage und erhalten Sie eine Antwort
try:
res = urllib.request.urlopen(req)
#Was tun, wenn in der Anforderung ein Fehler auftritt?
except urllib.request.HTTPError as e:
#Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
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)
#Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
else:
print ("<Error> " + e.reason)
#Antwortkörper erhalten
res_body = res.read()
#Dekodieren Sie den Antworttext von JSON
res_body = json.loads(res_body)
#Holen Sie sich das Analyseergebnis vom Antworttext
return res_body
#Einzigartige Ausdrucksextraktions-API
def ne(self, sentence):
#API-URL-Spezifikation für die eindeutige Expressionsextraktion
url = self.developer_api_base_url + "nlp/v1/ne"
#Header-Spezifikation
headers={
"Authorization": "Bearer " + self.access_token,
"Content-Type": "application/json;charset=UTF-8",
}
#Körperspezifikation anfordern
data = {
"sentence": sentence
}
#Codieren Sie die Anforderungshauptteilspezifikation in JSON
data = json.dumps(data).encode()
#Anforderungsgenerierung
req = urllib.request.Request(url, data, headers)
#Senden Sie eine Anfrage und erhalten Sie eine Antwort
try:
res = urllib.request.urlopen(req)
#Was tun, wenn in der Anforderung ein Fehler auftritt?
except urllib.request.HTTPError as e:
#Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
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)
#Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
else:
print ("<Error> " + e.reason)
#Antwortkörper erhalten
res_body = res.read()
#Dekodieren Sie den Antworttext von JSON
res_body = json.loads(res_body)
#Holen Sie sich das Analyseergebnis vom Antworttext
return res_body
#Korrespondenzanalyse-API
def coreference(self, document):
#URL-Angabe der API für die Korrespondenzanalyse-Erfassung
url = self.developer_api_base_url + "beta/coreference"
#Header-Spezifikation
headers={
"Authorization": "Bearer " + self.access_token,
"Content-Type": "application/json;charset=UTF-8",
}
#Körperspezifikation anfordern
data = {
"document": document
}
#Codieren Sie die Anforderungshauptteilspezifikation in JSON
data = json.dumps(data).encode()
#Anforderungsgenerierung
req = urllib.request.Request(url, data, headers)
#Senden Sie eine Anfrage und erhalten Sie eine Antwort
try:
res = urllib.request.urlopen(req)
#Was tun, wenn in der Anforderung ein Fehler auftritt?
except urllib.request.HTTPError as e:
#Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
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)
#Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
else:
print ("<Error> " + e.reason)
#Antwortkörper erhalten
res_body = res.read()
#Dekodieren Sie den Antworttext von JSON
res_body = json.loads(res_body)
#Holen Sie sich das Analyseergebnis vom Antworttext
return res_body
#Keyword-Extraktions-API
def keyword(self, document):
#API-URL-Spezifikation für die Keyword-Extraktion
url = self.developer_api_base_url + "nlp/v1/keyword"
#Header-Spezifikation
headers={
"Authorization": "Bearer " + self.access_token,
"Content-Type": "application/json;charset=UTF-8",
}
#Körperspezifikation anfordern
data = {
"document": document
}
#Codieren Sie die Anforderungshauptteilspezifikation in JSON
data = json.dumps(data).encode()
#Anforderungsgenerierung
req = urllib.request.Request(url, data, headers)
#Senden Sie eine Anfrage und erhalten Sie eine Antwort
try:
res = urllib.request.urlopen(req)
#Was tun, wenn in der Anforderung ein Fehler auftritt?
except urllib.request.HTTPError as e:
#Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
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)
#Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
else:
print ("<Error> " + e.reason)
#Antwortkörper erhalten
res_body = res.read()
#Dekodieren Sie den Antworttext von JSON
res_body = json.loads(res_body)
#Holen Sie sich das Analyseergebnis vom Antworttext
return res_body
#API zur Ähnlichkeitsberechnung
def similarity(self, s1, s2):
#API-URL-Spezifikation für die Ähnlichkeitsberechnung
url = self.developer_api_base_url + "nlp/v1/similarity"
#Header-Spezifikation
headers={
"Authorization": "Bearer " + self.access_token,
"Content-Type": "application/json;charset=UTF-8",
}
#Körperspezifikation anfordern
data = {
"s1": s1,
"s2": s2
}
#Codieren Sie die Anforderungshauptteilspezifikation in JSON
data = json.dumps(data).encode()
#Anforderungsgenerierung
req = urllib.request.Request(url, data, headers)
#Senden Sie eine Anfrage und erhalten Sie eine Antwort
try:
res = urllib.request.urlopen(req)
#Was tun, wenn in der Anforderung ein Fehler auftritt?
except urllib.request.HTTPError as e:
#Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
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)
#Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
else:
print ("<Error> " + e.reason)
#Antwortkörper erhalten
res_body = res.read()
#Dekodieren Sie den Antworttext von JSON
res_body = json.loads(res_body)
#Holen Sie sich das Analyseergebnis vom Antworttext
return res_body
#API zur Bestimmung des Anweisungstyps
def sentenceType(self, sentence):
#API-URL-Spezifikation zur Bestimmung des Anweisungstyps
url = self.developer_api_base_url + "nlp/v1/sentence_type"
#Header-Spezifikation
headers={
"Authorization": "Bearer " + self.access_token,
"Content-Type": "application/json;charset=UTF-8",
}
#Körperspezifikation anfordern
data = {
"sentence": sentence
}
#Codieren Sie die Anforderungshauptteilspezifikation in JSON
data = json.dumps(data).encode()
#Anforderungsgenerierung
req = urllib.request.Request(url, data, headers)
#Senden Sie eine Anfrage und erhalten Sie eine Antwort
try:
res = urllib.request.urlopen(req)
#Was tun, wenn in der Anforderung ein Fehler auftritt?
except urllib.request.HTTPError as e:
#Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
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)
#Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
else:
print ("<Error> " + e.reason)
#Antwortkörper erhalten
res_body = res.read()
#Dekodieren Sie den Antworttext von JSON
res_body = json.loads(res_body)
#Holen Sie sich das Analyseergebnis vom Antworttext
return res_body
#API zur Schätzung von Benutzerattributen
def userAttribute(self, document):
#API-URL-Spezifikation zur Schätzung von Benutzerattributen
url = self.developer_api_base_url + "beta/user_attribute"
#Header-Spezifikation
headers={
"Authorization": "Bearer " + self.access_token,
"Content-Type": "application/json;charset=UTF-8",
}
#Körperspezifikation anfordern
data = {
"document": document
}
#Codieren Sie die Anforderungshauptteilspezifikation in JSON
data = json.dumps(data).encode()
#Anforderungsgenerierung
req = urllib.request.Request(url, data, headers)
#Senden Sie eine Anfrage und erhalten Sie eine Antwort
try:
res = urllib.request.urlopen(req)
#Was tun, wenn in der Anforderung ein Fehler auftritt?
except urllib.request.HTTPError as e:
#Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
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)
#Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
else:
print ("<Error> " + e.reason)
#Antwortkörper erhalten
res_body = res.read()
#Dekodieren Sie den Antworttext von JSON
res_body = json.loads(res_body)
#Holen Sie sich das Analyseergebnis vom Antworttext
return res_body
if __name__ == '__main__':
#Rufen Sie den Speicherort der Quelldatei ab
APP_ROOT = os.path.dirname(os.path.abspath( __file__)) + "/"
#Stellen Sie den eingestellten Wert ein
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")
#COTOHA API-Instanziierung
cotoha_api = CotohaApi(CLIENT_ID, CLIENT_SECRET, DEVELOPER_API_BASE_URL, ACCESS_TOKEN_PUBLISH_URL)
#Zu analysierende Aussage
sentence = "Post Typogrisemia Textausgabe mit Python und COTOHA an Qiita"
#Vor dem Formen anzeigen
print('before :')
print(sentence)
#Ausführung der Syntax-Parsing-API
result_json = cotoha_api.parse(sentence)
#Zeichenfolgenliste vor dem Formatieren
word_list_base = []
#Liste der formatierten Zeichen
word_list = []
#Regulärer Ausdruck für alphanumerisches Urteilsvermögen
alnumReg = re.compile(r'^[a-zA-Z0-9 ]+$')
#Schleifenverarbeitung von Analyseergebnissen
for i in range(len(result_json['result'])):
for j in range(len(result_json['result'][i]['tokens'])):
#Für alphanumerische Zeichen'form'Für Japaner ist der Wert von'kana'Verwenden Sie den Wert von
word = result_json['result'][i]['tokens'][j]['form']
kana = result_json['result'][i]['tokens'][j]['kana']
#Beurteilung, ob es sich um alphanumerische Zeichen halber Breite handelt
if alnumReg.match(word) is not None:
#Bestimmen Sie, ob es sich um ein Wort handelt oder nicht
if ' ' in word:
#Wenn später mehr als eine konfiguriert wird, zerlegen Sie sie weiter
word_list_base.extend(word.split(' '))
else :
word_list_base.append(word)
#japanisch
else :
#Konvertiere Katakana in Hiragana und füge es der Liste hinzu
word_list_base.append(jaconv.kata2hira(kana))
#Analysieren Sie jedes Wort und ersetzen Sie die anderen Zeichen als den Anfang und das Ende von 4 oder mehr Zeichen
for i in range(len(word_list_base)):
#4 Zeichen oder mehr
if len(word_list_base[i]) > 3:
#Zerlegen Sie zuerst in eine zeichenweise Liste
wl_all = list(word_list_base[i])
#Behalten Sie das erste und das letzte Zeichen
first_word = wl_all[0]
last_word = wl_all[len(wl_all) - 1]
#Holen Sie sich die Zeichen im Listenformat
wl = wl_all[1:len(wl_all) - 1]
#Mischen
random.shuffle(wl)
word_list.append(first_word + ''.join(wl) + last_word)
#Wenn es weniger als 4 Zeichen sind, lassen Sie es wie es ist
else :
word_list.append(word_list_base[i])
#Zeigen Sie das Formatierungsergebnis an
print('after :')
print(' '.join(word_list))
config.ini
[COTOHA API]
Developer API Base URL: https://api.ce-cotoha.com/api/dev/
Developer Client id:[Kunden ID]
Developer Client secret:【Geheimnis】
Access Token Publish URL: https://api.ce-cotoha.com/v1/oauth/accesstokens
Um es zu verwenden, geben Sie die Client-ID und das Geheimnis in config.ini ein und platzieren Sie es in derselben Hierarchie wie cotoha_api.py.
Die Ausführung ist wie folgt.
python cotoha_api.py
Ausführungsergebnis
before :
Post Typogrisemia Textausgabe mit Python und COTOHA an Qiita
after :
Lass uns Pothyn und Choota spielen. Lass uns das Taposei Miriguabushon an Qiita schicken.
Obwohl ich keine Kenntnisse über "Python" oder "Verarbeitung natürlicher Sprache" hatte, implementierte ich es weiter (** fast menschliches Skript **). Aber selbst in einem solchen Zustand habe ich persönlich zufriedenstellende Ergebnisse erzielt, so dass "COTOHA" sehr einfach zu handhaben ist und ich denke, es ist die beste Einführung.
Wir hoffen, dass Sie sich auch nach dem Lesen dieses Artikels für "COTOHA" interessieren.
Nebenbei bemerkt bedeutet ** "Tippfehler" ** "Tippfehler" ** und ** "Hypoglykämie" ** bedeutet Hypoglykämie [Beutelsprache](https: //ja.wikipedia) .org / wiki /% E3% 81% 8B% E3% 81% B0% E3% 82% 93% E8% AA% 9E). Kaban ist ein Wort, das aus mehreren Wörtern besteht, wie "Netsusama-to" und "Nespresso".
Das? Dies scheint interessant zu sein, wenn Sie mit "COTOHA" umgehen ...
Wenn ich es tun würde, wäre es ** "Ich habe versucht, mit COTOHA eine jetzt Tintenfischsprache zu erstellen" ** (lacht)
Recommended Posts