introduction

Ceci est le premier article de l'article Qiita.

J'ai essayé de créer Shiritori AI en utilisant Python. Cliquez ici pour voir le code source https://github.com/takumi13/SiritoriAI

Le plan est comme suit.

Vous pouvez jouer à l'IA et au Shiritori interactif avec CUI
AI augmentera le vocabulaire en apprenant des mots qui n'existent pas dans le dictionnaire de mots (ci-après dénommés mots inconnus), le cas échéant.
Vous pouvez également obtenir un tweet approprié de Twitter et apprendre des mots inconnus de ce tweet.
En raison du scraping, ** environnement Internet ** et ** API Twitter ** sont requis

Sur le campus ouvert de l'université l'année dernière, quand j'ai demandé aux visiteurs de faire une démonstration de jeu en tant que fonctionnalité du laboratoire, c'était mieux que ce à quoi je m'attendais, alors j'en ai fait un article de Qiita (même si cela fait pas mal de temps) J'ai décidé de le voir.

Dans cet article, je vais vous expliquer comment jouer à Shiritori AI et un aperçu du code.

Bien qu'il soit nommé AI, il n'utilise aucun apprentissage automatique. Veuillez pardonner.

table des matières

--Environnement

Préparation préalable
Python3
TwitterAPI & tweepy
janome --Autres modules
Fonctionnement de l'IA Shiritori --Structure du dictionnaire de mots AI
Apprenez des mots inconnus à partir de tweets en utilisant tweepy et janome --Résumé
URL de référence

1 Environnement

> ver
Microsoft Windows [Version 10.0.18362.900]

> python -V
Python 3.7.5

> pip -V
pip 20.1.1

2 Préparation préalable

Pour exécuter le programme, vous avez besoin de:

Python3
TwitterAPI & tweepy
janome --Autres modules

2.1 Python3 Python peut être installé à partir du lien ci-dessous. https://www.python.org/downloads/

Pour la procédure d'installation, reportez-vous au lien ci-dessous, par exemple. Comment installer Python (Windows)

2.2 TwitterAPI & tweepy Pour utiliser ** API Twitter **, vous devez demander l'API Twitter à partir de la page Twitter Developper (https://developer.twitter.com/en).

La demande a souvent pris plusieurs jours, et dans mon cas, je l'ai reçue en avril 2019 et il a fallu 4 à 5 jours pour terminer la procédure.

Veuillez vous référer au lien ci-dessous pour la procédure d'acquisition. Résumé des procédures depuis l'enregistrement de l'API Twitter (méthode de demande de compte) jusqu'à l'approbation * Informations en août 2019

Après avoir terminé ce qui précède, installez ** tweepy **, une bibliothèque pratique pour appeler l'API Twitter en Python. tweepy peut être facilement installé avec la commande pip.

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

De plus, si l'application d'utilisation de l'API Twitter est acceptée, Vous pouvez obtenir des informations sur les jetons d'accès pour gérer votre compte Twitter à partir de l'API. Vous pouvez obtenir les 4 jetons suivants.

API key
Consumer_secret
Access_token
Access_secret

Copiez-les sous forme de chaînes aux endroits appropriés dans config.py. Une fois le travail terminé, vous pouvez appeler en toute sécurité l'API Twitter à partir de Python et Vous pourrez exploiter Twitter.

`config.py`


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

D'ailleurs, pour obtenir l'API Twitter, il est nécessaire d'échanger des emails avec Twitter une ou deux fois (** Expliquez le but de l'utilisation de l'API en anglais 200 caractères ou plus **), ce qui est un peu gênant pour être honnête. .. Dans mon programme, l'interaction avec l'IA elle-même fonctionne sans l'API Twitter, l'application n'est donc pas une exigence. Cependant, si vous ne voulez pas l'obtenir, vous devez commenter la partie liée à tweepy dans le programme.

2.3 janome ** janome ** est l'un des nombreux analyseurs morphologiques et est une bibliothèque Python. Comme tweepy, cela peut également être installé avec la commande pip.

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

L'utilisation de «janome» sera décrite plus loin.

2.4 Autres modules

Les modules suivants doivent être installés, principalement pour les requêtes HTTP et le scraping.

requests
beautifulsoup4
lxml

Tout d'abord, à propos des ** requêtes ** Selon Comment utiliser les requêtes (bibliothèque Python)

Requests est la bibliothèque HTTP moderne de Python. Vous pouvez faire une requête GET avec requests.get ('URL'). Vous pouvez obtenir le corps de la réponse au format texte en définissant .text sur la réponse.

Ensuite, à propos de ** beautifulsoup4 **

Beautiful Soup est une bibliothèque Python qui récupère les données des fichiers HTML et XML. Utilisez votre analyseur préféré (analyseur de syntaxe) pour explorer, rechercher et modifier l'arborescence de perspective. Cela réduit considérablement le temps de travail du programmeur.

De plus, puisque ** lxml ** est utilisé dans beautifulsoup4, il doit également être installé séparément.

Les trois utilisations simples ci-dessus sont décrites. Tout d'abord, installez chacun avec la commande 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

Écrivons réellement le code. Le code ci-dessous récupère le HTML sous forme de texte via la requête et en extrait les informations requises. À titre d'exemple, la page de commentaires "Word" de Kotobank (https://kotobank.jp/word/%E5%8D%98%E8%AA%9E) De, grattons l'information mot (tango).

`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              #Obtenir du HTML sous forme de texte par module de requête
soup = BeautifulSoup(html, 'html.parser')  #Belle initialisation de soupe
real_page_tag = soup.find("title")         #Rechercher et stocker la partie de la balise de titre
title_read_tmp  = real_page_tag.string     #Faites-en une chaîne<title>, </title>Supprimer
title_read = title_read_tmp[:-10]          #Retirez les pièces inutiles(Normalisation)
print(title_read)

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

J'entre avec désinvolture dans le sujet principal, mais dans le programme, l'IA génère l'URL de la page Kotobank du mot à partir du mot saisi par les humains, et à travers les opérations ci-dessus, que le mot existe réellement ou non Juge. Dans le même temps, le début et la fin du pseudonyme de lecture du mot sont également mémorisés.

De plus, Kotobank https://kotobank.jp/word/ [chaîne de caractères convertie du mot en utf-8] L'URL de la page d'explication du mot est gérée au format.

Par conséquent, tout le processus de conversion en utf-8 peut être codé comme suit:

`sample_make_url.py`


import requests
from bs4 import BeautifulSoup
import binascii

word = 'mot'
url_top = 'https://kotobank.jp/word/'
word_byte = word.encode('utf-8')
hex_string = str(binascii.hexlify(word_byte), 'utf-8')  #Convertir une chaîne d'octets en chaîne de caractères
hex_string = hex_string.upper()         #Convertir en majuscules

words = []                              #Stocker la chaîne d'octets de 2 caractères chacun
for i in range(len(hex_string)//2):     #Nombre de caractères dans la chaîne d'octets/Répéter deux fois
    words.append(hex_string[i*2:i*2+2]) #Découpez deux caractères du début et des mots[i]Stocker dans

url_latter = ""                         #La seconde moitié de l'URL.Utf la chaîne de caractères saisie par les humains-Converti en 8

for i in range(len(words)):
    words[i] = '%' + words[i]           #Tous les deux caractères%Mettez(spécification)
    url_latter = url_latter + words[i]  #Concaténé à la fin

url = url_top + url_latter              #URL complétée
print("URL : " + url)

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

3 Fonctionnement de l'IA Shiritori

C'est finalement le sujet principal. Commençons par le jeu de démonstration.

>python main.py
[menu]
Je veux me débarrasser de l'IA: 1
Je veux me débarrasser de l'IA(debug mode)  ：2
Je veux apprendre des mots inconnus à partir de tweets: 3
Je souhaite recevoir des tweets de Twitter: 4
Sélection: 1

Quand tu veux finir le shiritori,Appuyez sur la touche Entrée trois fois de suite(Cette opération est valable même pendant le jeu).
Dites-moi votre nom: humain

C'est un humain.Je vous remercie.
Shiritori est de vous.Commencez par votre mot préféré.
----------------------------------------------------------------------------------------------
Humain:Shiritori
AI :Château de Ryugu(Ryugujo)

Humain:anguille
AI :Gilbert

Humain:Urbain
AI :Problème

Humain:Yukiguni
Je suis désolé.Ce mot ne peut pas être utilisé pour ce shiri.
Si c'est un mot qui peut être converti en kanji,Désolé de vous déranger,Veuillez convertir en Kanji et entrer à nouveau

Humain:Pays des neiges
AI :La patience(Nintai)

Humain:vocabulaire
Ce n'est pas humide
Veuillez saisir les mots commençant par "i"

Humain:Hôpital
Il s'est terminé par "n"
Cela a duré 4 fois
je gagne
----------------------------------------------------------------------------------------------

Comme mentionné dans la section précédente, AI demande à Kotobank de déterminer l'existence d'un mot. Par conséquent, les mots avec des kanji qui ont des notations communes telles que «sour» ne pourront pas créer d'URL. De plus, le nombre de rallyes sera affiché à la fin du squeeze. Enfin, s'il y a un mot inconnu dans la série de shiritori, il sera ajouté au dictionnaire AI en tant que nouveau vocabulaire. À ce stade, AI connaît 5169 mots.

Le flux est illustré ci-dessous.

Le jugement de la victoire humaine est omis de la figure pour simplifier l'explication, mais il est mis en œuvre dans le programme.

4 Structure du dictionnaire de mots AI

J'ai expliqué dans la section précédente que l'IA obtient le drapeau d'existence et lit les mots d'entrée humains via une demande à Kotobank. D'autre part, AI conserve une liste de mots qu'elle connaît (ci-après dénommés mots connus) sous le nom de «dictionary.txt». Le format du fichier de dictionnaire est le suivant.

`dictionary.txt`


Ah:Ahさひ,Ahみだくじ,Parapluie Sogo,Compte,jouer,Comme un,guider,Anime,Aiko,Un d,Accablant,Aoyama,Asagiri,Arakida,Compatibilité,rouge,...
je:Irima,Ou plus tard,c'est tout,ensemble,Autre que,Dans,Iizuka,Inoue,Temporaire,Izumi,prière,jeや,Migration,Ino,un événement,Moins que,impression,Boisson,papier coloré,maintenant,...
...
Pe:paire,Animal de compagnie,pâte,Payer,pinces,Poiré,Nom du stylo,page,Crayon,papier
Po:Chips de pommes de terre,Affiche,poche,Pochette,Porno,Police,point,Pause

Le dictionnaire de mots peut avoir une structure aussi simple car il confie à Kotobank tout le jugement de l'existence des mots et la compréhension de leur lecture. En lisant ce dictionary.txt comme type de dictionnaire dans le programme, d ['A'] [0](= Asahi) Vous pouvez accéder au mot comme ceci. En réalité, les arguments pour une clé avec un type de dictionnaire sont déterminés aléatoirement.

5 Apprenez des mots inconnus à partir de tweets en utilisant Tweepy et Janome

C'est assez ennuyeux de se suivre pour amener l'IA à apprendre des mots inconnus. Alors, utilisez tweepy pour obtenir des tweets appropriés, en extraire uniquement les mots et en apprendre des mots inconnus.

> python .\main.py
[menu]
Je veux me débarrasser de l'IA: 1
Je veux me débarrasser de l'IA(debug mode)  ：2
Je veux apprendre des mots inconnus à partir de tweets: 3
Je souhaite recevoir des tweets de Twitter: 4
Choix: 3
Nombre de tweets que vous souhaitez recevoir(Jusqu'à 10)：2
----------------------------------------------------------------------------------------------Afficher une partie des tweets acquis
Tweets cachés acquis pour protéger la confidentialité
----------------------------------------------------------------------------------------------[ 0 ]Toutes les personnes(Seulement)
[ 1 ]ventilateur(U)
[ NG ]Pas bien
[ 2 ]L'écriture(Chi)
Nombre de mots dans le dictionnaire d'origine: 5179
Nombre de mots acquis: 3
Nombre de mots réellement augmenté: 2
Nombre de mots dans le dictionnaire mis à jour: 5181
Taux d'apprentissage des mots: 66.66666666666667 %
----------------------------------------------------------------------------------------------

De cette manière, seule la nomenclature est extraite en utilisant «janome» à partir des tweets obtenus en utilisant «tweepy». Seuls des mots inconnus sont appris d'eux. Ici, tous les mots pertinents sont lus via une demande à Kotobank. Faire un grand nombre de demandes à un site Web dans un court laps de temps impose une lourde charge sur le site Web. Pour être prudent, le nombre maximum de tweets pouvant être obtenus est limité à 10 dans le programme.

Le code suivant montre un exemple d'utilisation de 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

#--------------------------------------------------
#Obtenez l'API Twitter
#--------------------------------------------------
def get_twieetr_api(CK, CS, AT, ATK):
    try:                                    #Gestion des exceptions
        auth = tweepy.OAuthHandler(CK, CS)  #CONSOMMATEUR à authentifier_CLÉ et CONSOMMATEUR_Passer SECRET
        auth.set_access_token(AT, ATK)      #Définir le jeton d'accès dans auth
        API = tweepy.API(auth)              #Facilitez l'écriture
    except tweepy.TweepError as e:          #Si une erreur se produit, TweetError sera renvoyé.
        print(e.reason)                     #Détails de l'erreur de sortie
    return API

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

#-----------------------------------------------------
#Obtenez le nombre de tweets sous forme de texte à l'aide de l'API Twitter
#-----------------------------------------------------
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='agréable', count=3)
for text in text_list:
    print('-------------------------------------------------')
    print(text)

Vous pouvez obtenir le tweet sous forme de texte avec le code ci-dessus. De plus, le code suivant montre un exemple d'utilisation de janome.

`sample_janome.py`


from janome.tokenizer import Tokenizer
t = Tokenizer()
#Le texte suivant est un tweet fictif
text_list = ['Je vous remercie! Je vais continuer à l'utiliser avec précaution!', 'Non, j'ai l'impression que je ne peux plus rien faire...Mmm']
for text in text_list:
    for token in t.tokenize(text):
        if token.part_of_speech.split(',')[0] == 'nom' and len(token.surface) >= 2 and token.reading != '*':
            print(token.surface)

'''
> python sample_janome.py
Important
Pas bien
cette
c'est tout
'''

De cette manière, des mots d'une longueur de lecture de 2 ou plus et une nomenclature peuvent être obtenus à partir du texte. En stockant temporairement le mot ci-dessus token.surface dans une liste séparée, puis en le comparant avec le contenu de la variable de type dictionnaire qui lit dictionary.txt, seuls les mots qui n'existent pas dans le dictionnaire sont nouvellement stockés. Vous pouvez apprendre des mots inconnus à partir de tweets.

6 Résumé

c'est tout. Si vous décrivez la partie du système qui effectue réellement la compression et le traitement, comme l'identification de mots inconnus ici, ce sera long. Je vais omettre cette fois. Si vous êtes intéressé, veuillez vérifier le code source sur GitHub.

Je peux le publier à nouveau sous forme d'article si j'en ai l'occasion. En particulier, si je peux implémenter de nouvelles fonctions, j'écrirai un article séparé.

Merci d'avoir lu jusqu'ici.

7 URL de référence

Je vais joindre les URL des principaux sites Web auxquels j'ai fait référence lors de la création du programme. Merci beaucoup.

Opération de chaîne de caractères japonais, jugement Hiragana, etc. Journal de capture python de Remrin [Version préservée] Explication approfondie pour les débutants sur la façon de gratter avec Python! Résumé des bases du grattage à Beautiful Soup [pour les débutants] [Python] Convertir le tableau d'octets en chaîne Une histoire sur la difficulté à ouvrir un fichier autre que CP932 (Shift-JIS) encodé sous Windows

[Python] J'ai essayé de créer une IA Shiritori qui améliore le vocabulaire grâce aux batailles