Einführung

Dies ist der erste Beitrag des Qiita-Artikels.

Ich habe versucht, Shiritori AI mit Python zu machen. Klicken Sie hier, um den Quellcode anzuzeigen https://github.com/takumi13/SiritoriAI

Der Umriss ist wie folgt.

Sie können KI und interaktive Shiritori mit CUI spielen --AI erhöht den Wortschatz, indem Wörter, die nicht im Wortwörterbuch vorhanden sind (im Folgenden als unbekannte Wörter bezeichnet), entsprechend gelernt werden.
Sie können auch einen entsprechenden Tweet von Twitter erhalten und unbekannte Wörter aus diesem Tweet lernen.
Wegen Scraping sind ** Internetumgebung ** und ** Twitter API ** erforderlich

Als ich die Besucher letztes Jahr bat, dies als Merkmal des Labors auf dem offenen Campus der Universität zu demonstrieren, war es besser als ich erwartet hatte, also machte ich es zu einem Artikel von Qiita (obwohl es schon eine ganze Weile her ist). Ich beschloss es zu sehen.

In diesem Artikel werde ich erklären, wie man Shiritori AI spielt und einen Überblick über den Code geben.

Obwohl es AI heißt, verwendet es kein maschinelles Lernen. Bitte entschuldigen Sie.

Inhaltsverzeichnis

--Umgebung

Vorbereitungen
Python3
TwitterAPI & tweepy
janome
Andere Module
Shiritori AI-Betrieb
Struktur des AI-Wortwörterbuchs --Lerne unbekannte Wörter aus Tweets mit Tweepy und Janome --Zusammenfassung
Referenz-URL

1 Umwelt

> ver
Microsoft Windows [Version 10.0.18362.900]

> python -V
Python 3.7.5

> pip -V
pip 20.1.1

2 Vorbereitungen

Um das Programm auszuführen, benötigen Sie:

Python3
TwitterAPI & tweepy
janome
Andere Module

2.1 Python3 Python kann über den folgenden Link installiert werden. https://www.python.org/downloads/

Informationen zum Installationsverfahren finden Sie beispielsweise unter dem folgenden Link. So installieren Sie Python (Windows)

2.2 TwitterAPI & tweepy Um die ** Twitter API ** verwenden zu können, müssen Sie die Twitter API auf der Twitter Developper-Seite (https://developer.twitter.com/en) beantragen.

Die Bewerbung dauerte oft mehrere Tage, und in meinem Fall bekam ich sie im April 2019 und es dauerte 4-5 Tage, um das Verfahren abzuschließen.

Informationen zum Erwerb finden Sie unter dem folgenden Link. Zusammenfassung der Verfahren von der Registrierung der Twitter-API (Kontoantragsmethode) bis zur Genehmigung * Informationen ab August 2019

Installieren Sie nach Abschluss des oben beschriebenen Vorgangs ** tweepy **, eine praktische Bibliothek zum Aufrufen der Twitter-API in Python. tweepy kann einfach mit dem Befehl pip installiert werden.

> pip install tweepy
> pip show tweepy
Name: tweepy
Version: 3.8.0

Wenn die Anwendung zur Verwendung der Twitter-API übergeben wird, Über die API können Sie Zugriffstokeninformationen für den Betrieb Ihres Twitter-Kontos abrufen. Sie können die folgenden 4 Token erhalten.

API key
Consumer_secret
Access_token
Access_secret

Kopieren Sie diese als Zeichenfolgen an die entsprechenden Stellen in config.py. Wenn die Arbeit bis zu diesem Punkt abgeschlossen ist, können Sie die Twitter-API sicher von Python und aus aufrufen Sie können Twitter bedienen.

`config.py`


CONSUMER_KEY        = "##############################"
CONSUMER_SECRET     = "##############################"
ACCESS_TOKEN        = "##############################"
ACCESS_TOKEN_SECRET = "##############################"

Um die Twitter-API zu erhalten, müssen Sie übrigens ein- oder zweimal E-Mails mit Twitter austauschen (** Erklären Sie den Zweck der Verwendung der API in Englisch mit 200 Zeichen oder mehr **), was ehrlich gesagt etwas mühsam ist. .. In meinem Programm funktioniert die Interaktion mit AI selbst ohne die Twitter-API, sodass eine Anwendung nicht erforderlich ist. Wenn Sie es jedoch nicht erhalten möchten, müssen Sie den Teil im Zusammenhang mit "tweepy" im Programm auskommentieren.

2.3 janome ** janome ** ist einer von vielen morphologischen Analysatoren und eine Python-Bibliothek. Wie tweepy kann dies auch mit dem Befehl pip installiert werden.

> pip install janome
> pip show janome
Name: Janome
Version: 0.3.10

Wie man "janome" benutzt, wird später beschrieben.

2.4 Andere Module

Die folgenden Module müssen installiert werden, hauptsächlich für HTTP-Anforderungen und Scraping.

requests
beautifulsoup4
lxml

Zunächst zu ** Anfragen ** Laut Verwendung von Anfragen (Python-Bibliothek)

Requests ist die moderne HTTP-Bibliothek von Python. Sie können eine GET-Anfrage mit request.get ('URL') stellen. Sie können den Antworttext im Textformat abrufen, indem Sie für die Antwort ".text" festlegen.

Als nächstes über ** beautifulsoup4 **

Beautiful Soup ist eine Python-Bibliothek, die Daten aus HTML- und XML-Dateien abruft. Verwenden Sie Ihren bevorzugten Parser (Syntaxanalysator), um den Perspektivenbaum zu erkunden, zu suchen und zu ändern. Dies reduziert die Arbeitszeit des Programmierers erheblich.

Da ** lxml ** in beautifulsoup4 verwendet wird, muss dies auch separat installiert werden.

Die obigen drei einfachen Verwendungen werden beschrieben. Installieren Sie zuerst jedes mit dem Befehl pip.

> pip install requests
> pip install beautifulsoup4
> pip install lxml

> pip show requests
Name: requests
Version: 2.23.0

> pip show beautifulsoup4
Name: beautifulsoup4
Version: 4.9.1

> pip show lxml
Name: lxml
Version: 4.3.3

Lassen Sie uns den Code tatsächlich schreiben. Der folgende Code ruft den HTML-Code als Text über die Anforderung ab und entfernt die erforderlichen Informationen. Als Beispiel die "Wort" -Kommentarseite der Kotobank (https://kotobank.jp/word/%E5%8D%98%E8%AA%9E) Lassen Sie uns die Information "Wort (Tango)" abkratzen.

`sample_scraping.py`


import requests
from bs4 import BeautifulSoup

url = 'https://kotobank.jp/word/%E5%8D%98%E8%AA%9E'
html = requests.get(url).text              #Holen Sie sich HTML als Text per Anforderungsmodul
soup = BeautifulSoup(html, 'html.parser')  #Schöne Suppeninitialisierung
real_page_tag = soup.find("title")         #Suchen und speichern Sie den Titel-Tag-Teil
title_read_tmp  = real_page_tag.string     #Mach daraus eine Schnur<title>, </title>Löschen
title_read = title_read_tmp[:-10]          #Entfernen Sie unnötige Teile(Normalisierung)
print(title_read)

'''
> python sample_scraping.py
Wort(Tango)
'''

Ich gehe beiläufig auf das Hauptthema ein, aber im Programm generiert AI die URL der Kotobank-Seite des Wortes aus dem von einem Menschen eingegebenen Wort und durch die obigen Operationen, ob das Wort tatsächlich existiert oder nicht Richter. Gleichzeitig werden auch der Anfang und das Ende des Lesepseudonyms des Wortes gespeichert.

Darüber hinaus Kotobank https://kotobank.jp/word/ [Zeichenfolge von Wort in utf-8 konvertiert] Die URL der Erklärungsseite des Wortes wird im Format verwaltet.

Daher kann der gesamte Konvertierungsprozess zu utf-8 wie folgt codiert werden:

`sample_make_url.py`


import requests
from bs4 import BeautifulSoup
import binascii

word = 'Wort'
url_top = 'https://kotobank.jp/word/'
word_byte = word.encode('utf-8')
hex_string = str(binascii.hexlify(word_byte), 'utf-8')  #Konvertieren Sie die Byte-Zeichenfolge in eine Zeichenfolge
hex_string = hex_string.upper()         #In Großbuchstaben konvertieren

words = []                              #Speichern Sie die Byte-Zeichenfolge mit jeweils 2 Zeichen
for i in range(len(hex_string)//2):     #Anzahl der Zeichen in der Byte-Zeichenfolge/Wiederholen Sie zweimal
    words.append(hex_string[i*2:i*2+2]) #Schneiden Sie zwei Zeichen von Anfang an und Wörter aus[i]Speichern in

url_latter = ""                         #Die zweite Hälfte der URL.Utt die von Menschen eingegebene Zeichenkette-Umgerechnet auf 8

for i in range(len(words)):
    words[i] = '%' + words[i]           #Alle zwei Zeichen%Anziehen(Spezifikation)
    url_latter = url_latter + words[i]  #Am Ende verkettet

url = url_top + url_latter              #URL abgeschlossen
print("URL : " + url)

'''
> python sample_make_url.py
URL : https://kotobank.jp/word/%E5%8D%98%E8%AA%9E
'''

3 Shiritori AI-Operation

Es ist endlich das Hauptthema. Beginnen wir mit dem Demo-Spiel.

>python main.py
[Speisekarte]
Ich möchte AI: 1 loswerden
Ich möchte die KI loswerden(debug mode)  ：2
Ich möchte unbekannte Wörter aus Tweets lernen: 3
Ich möchte Tweets von Twitter erhalten: 4
Auswahl: 1

Wenn Sie die Shiritori beenden möchten,Drücken Sie dreimal hintereinander die Eingabetaste(Dieser Vorgang ist auch während des Spiels gültig).
Sag mir deinen Namen: Mensch

Es ist ein Mensch.Vielen Dank.
Shiritori ist von dir.Beginnen Sie mit Ihrem Lieblingswort.
----------------------------------------------------------------------------------------------
Mensch:Shiritori
AI :Ryugu Schloss(Ryugujo)

Mensch:Aal
AI :Gilbert

Mensch:Städtisch
AI :Problem

Mensch:Yukiguni
Es tut mir Leid.Dieses Wort kann nicht für diesen Shiri verwendet werden.
Wenn es sich um ein Wort handelt, das in Kanji konvertiert werden kann,Es tut mir leid Sie zu stören,Bitte konvertieren Sie zu Kanji und geben Sie erneut ein

Mensch:Schneeland
AI :Die Geduld(Nintai)

Mensch:Wortschatz
Es ist nicht feucht
Bitte geben Sie die Wörter ein, die mit "i" beginnen.

Mensch:Krankenhaus
Es endete mit "n"
Es dauerte 4 mal
ich gewinne
----------------------------------------------------------------------------------------------

Wie im vorherigen Abschnitt erwähnt, fordert AI die Kotobank auf, die Existenz eines Wortes festzustellen. Daher können Wörter mit Kanji, die allgemeine Notationen wie "sauer" haben, keine URLs erstellen. Zusätzlich wird die Anzahl der Rallyes am Ende des Squeeze angezeigt. Wenn die Reihe der Shiritori ein unbekanntes Wort enthält, wird es dem AI-Wörterbuch als neues Vokabular hinzugefügt. Zu diesem Zeitpunkt kennt AI 5169 Wörter.

Das folgende Diagramm zeigt den Durchfluss.

Das menschliche Siegesurteil ist der Einfachheit halber in der Abbildung weggelassen, wird jedoch im Programm implementiert.

4 AI-Wörterbuchstruktur

Ich habe im vorherigen Abschnitt erklärt, dass AI das Existenzflag erhält und durch eine Anfrage an die Kotobank nach menschlichen Eingabewörtern liest. Andererseits führt AI eine Liste von Wörtern, die es kennt (im Folgenden als bekannte Wörter bezeichnet), als "dictionary.txt". Das Format der Wörterbuchdatei ist wie folgt.

`dictionary.txt`


Ah:Ahさひ,Ahみだくじ,Sogo Regenschirm,Konto,abspielen,Als ein,führen,Anime,Aiko,Anzeige,Überwältigend,Aoyama,Asagiri,Arakida,Kompatibilität,rot,...
ich:Irima,Oder später,das ist alles,zusammen,Außer,Innerhalb,Iizuka,Inoue,Temporär,Izumi,Gebet,ichや,Migration,Ino,Veranstaltung,Weniger als,Eindruck,Getränk,buntes Papier,jetzt,...
...
Sport:Paar,Haustier,Einfügen,Zahlen,Zange,Perry,Stift name,Seite,Bleistift,Papier-
Po:Kartoffelchips,Poster,Tasche,Pochette,Porno,Polizei,Punkt,Pause

Das Wortwörterbuch kann eine so einfache Struktur haben, weil es der Kotobank das gesamte Urteil über die Existenz von Wörtern und das Verständnis, wie man sie liest, anvertraut. Durch Lesen dieser dictionary.txt als Wörterbuchtyp im Programm d ['A'] [0](= Asahi) Sie können auf das Wort wie folgt zugreifen. In der Realität werden die Argumente für einen Schlüssel mit einem Wörterbuchtyp zufällig bestimmt.

5 Lernen Sie unbekannte Wörter aus Tweets mit Tweepy und Janome

Es ist ziemlich ärgerlich, miteinander Schritt zu halten, damit die KI unbekannte Wörter lernt. Verwenden Sie also "tweepy", um geeignete Tweets zu erhalten, extrahieren Sie nur die Wörter aus ihnen und lernen Sie unbekannte Wörter aus ihnen.

> python .\main.py
[Speisekarte]
Ich möchte AI: 1 loswerden
Ich möchte die KI loswerden(debug mode)  ：2
Ich möchte unbekannte Wörter aus Tweets lernen: 3
Ich möchte Tweets von Twitter erhalten: 4
Auswahl: 3
Anzahl der Tweets, die Sie erhalten möchten(Bis zu 10)：2
----------------------------------------------------------------------------------------------Teil der erfassten Tweets anzeigen
Versteckte Tweets zum Schutz der Privatsphäre
----------------------------------------------------------------------------------------------[ 0 ]Jedermann(Nur)
[ 1 ]Ventilator(U.)
[ NG ]Nicht gut
[ 2 ]Schreiben(Chi)
Anzahl der Wörter im Originalwörterbuch: 5179
Anzahl der erworbenen Wörter: 3
Anzahl der tatsächlich erhöhten Wörter: 2
Anzahl der Wörter im aktualisierten Wörterbuch: 5181
Wortlernrate: 66.66666666666667 %
----------------------------------------------------------------------------------------------

Auf diese Weise wird nur die Nomenklatur mit "janome" aus den mit "tweepy" erhaltenen Tweets extrahiert. Von ihnen werden nur unbekannte Wörter gelernt. Hier werden alle relevanten Wörter durch eine Anfrage an die Kotobank gelesen. Wenn Sie in kurzer Zeit eine große Anzahl von Anfragen an eine Website stellen, wird die Website stark belastet. Um auf der sicheren Seite zu sein, ist die maximale Anzahl von Tweets, die erfasst werden können, im Programm auf 10 begrenzt.

Der folgende Code zeigt ein Beispiel für die Verwendung von "tweepy".

`sample_tweepy.py`


import tweepy
import config
from janome.tokenizer import Tokenizer

##################################################333
CK = config.CONSUMER_KEY
CS = config.CONSUMER_SECRET
AT = config.ACCESS_TOKEN
ATK = config.ACCESS_TOKEN_SECRET
##################################################333

#--------------------------------------------------
#Holen Sie sich Twitter API
#--------------------------------------------------
def get_twieetr_api(CK, CS, AT, ATK):
    try:                                    #Ausnahmebehandlung
        auth = tweepy.OAuthHandler(CK, CS)  #VERBRAUCHER zu auth_SCHLÜSSEL und VERBRAUCHER_Pass SECRET
        auth.set_access_token(AT, ATK)      #Legen Sie das Zugriffstoken in auth fest
        API = tweepy.API(auth)              #Erleichtern Sie das Schreiben
    except tweepy.TweepError as e:          #Wenn ein Fehler auftritt, wird TweetError zurückgegeben.
        print(e.reason)                     #Details zu Ausgabefehlern
    return API

###########################################################################
api = get_twieetr_api(CK, CS, AT, ATK)
############################################################################

#-----------------------------------------------------
#Ermitteln Sie mithilfe der Twitter-API die Anzahl der Tweets als Text
#-----------------------------------------------------
def get_text(q, count=100):
    text_list = []
    search_results = api.search(q=q, count=count)
    for tweet in search_results:
        text = tweet.text.encode('cp932', "ignore")
        text = text.decode('cp932')
        text = text.encode('utf-8', "ignore")
        text_list.append(text.decode('utf-8'))
    return text_list

text_list = get_text(q='angenehm', count=3)
for text in text_list:
    print('-------------------------------------------------')
    print(text)

Sie können den Tweet als Text mit dem obigen Code erhalten. Darüber hinaus zeigt der folgende Code ein Beispiel für die Verwendung von "janome".

`sample_janome.py`


from janome.tokenizer import Tokenizer
t = Tokenizer()
#Der folgende Text ist ein fiktiver Tweet
text_list = ['Vielen Dank! Ich werde es weiterhin vorsichtig verwenden!', 'Nein, ich habe das Gefühl, ich kann nichts mehr tun...Mmm']
for text in text_list:
    for token in t.tokenize(text):
        if token.part_of_speech.split(',')[0] == 'Substantiv' and len(token.surface) >= 2 and token.reading != '*':
            print(token.surface)

'''
> python sample_janome.py
Wichtig
Nicht gut
Dies
das ist alles
'''

Auf diese Weise können Wörter mit einer Leselänge von 2 oder mehr und einer Nomenklatur aus dem Text erhalten werden. Durch vorübergehendes Speichern des obigen Wortes "token.surface" in einer separaten Liste und anschließendes Vergleichen mit dem Inhalt der Wörterbuchtypvariablen, die "dictionary.txt" lautet, werden nur die Wörter neu gespeichert, die nicht im Wörterbuch vorhanden sind. Sie können unbekannte Wörter aus Tweets lernen.

6 Zusammenfassung

das ist alles. Wenn Sie den Systemteil beschreiben, der das Zusammendrücken und die Verarbeitung tatsächlich ausführt, z. B. unbekannte Wörter hier identifizieren, wird es lang sein. Ich werde diesmal weglassen. Wenn Sie interessiert sind, überprüfen Sie bitte den Quellcode auf GitHub.

Ich kann es wieder als Artikel posten, wenn ich eine Chance habe. Insbesondere wenn ich neue Funktionen implementieren kann, werde ich einen separaten Artikel schreiben.

Vielen Dank, dass Sie so weit gelesen haben.

7 Referenz-URL

Ich werde die URLs der wichtigsten Websites anhängen, auf die ich beim Erstellen des Programms verwiesen habe. Vielen Dank.

Japanische Zeichenkettenoperation, Hiragana-Urteil usw. Remrins Python-Erfassungstagebuch [Erhaltene Version] Gründliche Erklärung für Anfänger, wie man mit Python kratzt! Zusammenfassung der Grundlagen des Schabens bei Beautiful Soup [für Anfänger] [Python] Byte-Array in Zeichenfolge konvertieren Eine Geschichte darüber, dass es schwierig ist, eine andere Datei als CP932 (Shift-JIS) zu öffnen, die unter Windows codiert ist

[Python] Ich habe versucht, eine Shiritori-KI zu erstellen, die den Wortschatz durch Schlachten verbessert