[PYTHON] Verarbeiten Sie den Namen der Yugioh-Karte in natürlicher Sprache - Yugiou Data Science 2. NLP

Einführung

Dies ist die Serie "Yugio DS (Data Science)", die verschiedene Yugioh-Kartendaten mit Python analysiert. Der Artikel wird insgesamt viermal gehalten, und schließlich werden wir ein Programm implementieren, das offensive und defensive Attribute aus dem Kartennamen durch Verarbeitung natürlicher Sprache + maschinelles Lernen vorhersagt. Darüber hinaus hat das Wissen des Autors über Yugioh bei etwa E ・ HERO aufgehört. Es tut mir leid, dass sowohl Karten als auch Data Science Amateure sind, aber bitte bleiben Sie in Kontakt.

Zweck dieses Artikels

1. EDA geht tiefer in den "Kartennamen" ein, der nicht fokussiert war. In Yugioh werden verschiedene Monster wie Drachen, Zauberer und Helden auftauchen, aber wir werden untersuchen, welche Art von Wörtern im Namen häufig verwendet werden. Außerdem würde ich gerne sehen, welche Ähnlichkeiten jeder hat, wenn er nach Attribut / Typ / Ebene getrennt ist. Die technischen Themen dieses Artikels sind morphologische Analyse mit "MeCab", häufige Wortvisualisierung mit "WordCloud", verteilte Darstellung von Wörtern mit "Word2Vec" und "Doc2Vec", Dimensionskomprimierung und Wortzuordnung mit "t-SNE". Ich werde Schritt für Schritt mit dem Implementierungscode erklären.

Erläuterung der Voraussetzungen (Nutzungsumgebung, Daten, Analyserichtlinie)

Nutzungsumgebung

Python==3.7.4

Daten

Die in diesem Artikel erfassten Daten werden mit einem handgefertigten Code aus Yugio OCG Card Database erfasst. .. Es ist spätestens ab Juni 2020. Abhängig vom anzuzeigenden Diagramm werden verschiedene Datenrahmen verwendet, aber alle Datenrahmen enthalten die folgenden Spalten.

• Beispieldaten

Analyserichtlinie

Alle Analysen sollen in einem interaktiven Interpreter wie "Jupter Lab" durchgeführt werden.

Implementierung

1. Paketimport

Importieren Sie die erforderlichen Pakete. Ich glaube nicht, dass "MeCab", "Gensim" und "Wordcloud" von Anfang an in Anaconda enthalten sind, also werde ich bei Bedarf "Pip Install" durchführen.

python

import matplotlib.pyplot as plt
import MeCab
import numpy as np
import pandas as pd
import re
import seaborn as sns
from gensim.models.doc2vec import Doc2Vec
from gensim.models.doc2vec import TaggedDocument
from gensim.models import word2vec
from sklearn.decomposition import TruncatedSVD
from sklearn.manifold import TSNE
from PIL import Image
from wordcloud import WordCloud
%matplotlib inline
sns.set(font="IPAexGothic") #Unterstützt Python auf Japanisch

2. Datenimport

Die Erfassungsmethode für jeden Datensatz ist in 0 beschrieben. Scraping (Kein Artikel ab Juni 2020).

python

#Diesmal nicht verwendet
# all_data = pd.read_csv("./input/all_data.csv") #Datensatz für alle Karten (Karten mit demselben Namen haben doppelte Aufzeichnungspakete)
# print("all_data: {}rows".format(all_data.shape[0]))

cardlist = pd.read_csv("./input/cardlist.csv") #Datensatz für alle Karten (keine Vervielfältigung)
print("cardlist: {}rows".format(cardlist.shape[0]))

#Diesmal nicht verwendet
# monsters = pd.read_csv("./input/monsters.csv") #Nur Monsterkarte
# print("monsters: {}rows".format(monsters.shape[0]))

monsters_norank = pd.read_csv("./input/monsters_norank.csv") #Entferne Rangmonster von Monsterkarten
print("monsters_norank: {}rows".format(monsters_norank.shape[0]))

cardlist: 10410rows
monsters_norank: 6206rows

3. MeCab-Überprüfung

• Die Quelle ist ein Blog, den ich vor langer Zeit geschrieben habe. Zitiert aus Data Science ~ Natural Language Processing ~](https://fyiwdwytm.hatenablog.com/entry/2019/10/13/184435).

Das Verfahren zur Verwendung von MeCab besteht ungefähr aus den folgenden 2 Schritten.

1. Instanziieren Sie einen morphologischen Analysator in Form von "Mecab Tagger"
2. Führen Sie die Methode parseToNode () aus, die eine morphologische Analyse durchführt, und speichern Sie das Ergebnis im Objekt node.

Infolgedessen enthält das "Knoten" -Objekt zwei Attribute.

• ** Oberfläche **: Das Wort selbst. Format, das als Zeichenfolge in einem Satz angezeigt wird
• ** Funktion **: Liste der Wortinformationen

python

# 1.Instanziieren Sie einen morphologischen Analysator und speichern Sie das Verarbeitungsergebnis in einem Objekt mit der parseToNode-Methode
text = "Blauäugiger weißer Drache"
mecabTagger = MeCab.Tagger("-Ochasen -d /usr/local/lib/mecab/dic/mecab-ipadic-neologd/") #Wörterbuch: Mecab-ipadic-Verwenden Sie neologd
node = mecabTagger.parseToNode(text)

#2.Oberflächentyp(surface)Und Identität(feature)Erstellen Sie einen Datenrahmen zum Speichern
surface_and_feature = pd.DataFrame()
surface = []
feature = []

#3.Extrahieren Sie Oberflächenform und Identität aus den Attributen des Knotenobjekts
while node:
    surface.append(node.surface)
    feature.append(node.feature)
    node = node.next
    
surface_and_feature['surface'] = surface
surface_and_feature['feature'] = feature

surface_and_feature

Es scheint, dass feature eine Liste enthält, daher werden wir sie weiter in einen Datenrahmen konvertieren. Bei Verwendung des Wörterbuchs "mecab-ipadic-neologd" sind die Inhalte der Funktion ** Teiltexte (pos), Teiltexte Unterklassifizierung 1 (pos1), Teilteilunterklassifizierung 2 (pos2), Teilteilunterklassifizierung 3 (pos3) ), Verwendungstyp (ctype), Verwendungstyp (cform), Prototyp (Basis), Lesen (lesen), Aussprache (aussprechen) ** werden als Liste gespeichert. Außerdem ist "BOS / EOS" am Anfang und Ende des Datenrahmens ein Wert, der direkt den Anfang und das Ende von "Knoten" darstellt.

python

text = "Blauäugiger weißer Drache"
mecabTagger = MeCab.Tagger("-Ochasen -d /usr/local/lib/mecab/dic/mecab-ipadic-neologd/")
node = mecabTagger.parseToNode(text)

#Identität(feature)Inhalt der Liste(Teil,Teil細分類1,Teil細分類2,Teil細分類3,Nutzungsart,Nutzungsart,Prototyp,lesen,Aussprache)In einem Datenrahmen
features = pd.DataFrame(columns=["pos","pos1","pos2","pos3","ctype","cform","base","read","pronounce"])
posses = pd.DataFrame
while node:
    tmp = pd.Series(node.feature.split(','), index=features.columns)
    features = features.append(tmp, ignore_index=True)
    node = node.next
    
features

4. Morphologische Analyse

Die gelesenen Daten werden auf den morphologischen Analysator MeCab angewendet.

4-1. Implementierung einer Funktion, die eine morphologische Analyse durchführt

Erstellen Sie eine Funktion get_word_list, die eine Liste von Kartennamen in Wörter zerlegt. Wenn Sie Hilfswörter wie "to" und "mo" hinzufügen, wird es laut. Verwenden Sie daher nur ** Nomenklatur, Verben und Adjektive **.

python

def get_word_list(text_list):
    m = MeCab.Tagger ("-Ochasen -d /usr/local/lib/mecab/dic/mecab-ipadic-neologd/")
    lines = []
    for text in text_list:
        keitaiso = []
        m.parse('')
        node = m.parseToNode(text)
        while node:
            #Fügen Sie die Morphologie in das Wörterbuch ein
            tmp = {}
            tmp['surface'] = node.surface
            tmp['base'] = node.feature.split(',')[-3] #Prototyp(base)
            tmp['pos'] = node.feature.split(',')[0] #Teil(pos)
            tmp['pos1'] = node.feature.split(',')[1] #Neuklassifizierung von Teilwörtern(pos1)
            
            #BOS repräsentiert den Anfang und das Ende eines Satzes/EOS weglassen
            if 'BOS/EOS' not in tmp['pos']:
                keitaiso.append(tmp)
                
            node = node.next
        lines.append(keitaiso)
    
    #Speichern Sie das Oberflächensystem für die Nomenklatur und die Originalform für Verben / Adjektive in der Liste.
    word_list = [] 
    for line in lines:
        for keitaiso in line:
            if (keitaiso['pos'] == 'Substantiv'):
                word_list.append(keitaiso['surface'])
            elif  (keitaiso['pos'] == 'Verb') | (keitaiso['pos'] == 'Adjektiv') :
                if not keitaiso['base'] == '*' :
                    word_list.append(keitaiso['base'])
                else: 
                    word_list.append(keitaiso['surface'])
#Kommentar ausschließen, wenn Nomenklatur, Verben und Adjektive enthalten sind
#             else:
#                 word_list.append(keitaiso['surface'])

    return word_list

4-2. Erstellen eines Datenrahmens

Erstellen Sie zwei Datenrahmen zur Verwendung in nachfolgenden Visualisierungs- und Modellierungsprozessen.

• ** cardlist_word_count **: Erstellt basierend auf dem eindeutigen Datensatz cardlist für alle Karten. Die Spalte enthält das Wort "Wort", das auf allen Karten verwendet wird, und die Anzahl der Auftritte "Wortzahl".
• ** monsters_words **: Erstellt basierend auf dem Datensatz monsters_norank ohne Rangmonster von allen Monstern. Es hat das Wort "Wort" in der Spalte und die Merkmale "Name", "Stufe", "Attr", "Seltenheit", "Art", "Art" der Karte, auf der das Wort vorkommt. Beachten Sie, dass Zeileneinheiten Wörter und keine Karten sind.

Übrigens gibt es im Namen der Yugioh-Karte viele Wortunterteilungen durch das Symbol "・", aber "Mecab" teilt dieses Symbol nicht. Fügen Sie daher vor dem Ausführen der obigen Funktion den Vorgang des Teilens des Wortes mit "・" im Voraus ein.

cardlist_word_count

python

#"・" Erstellt eine vorgetrennte Listennamenliste
namelist = []
for name in cardlist.name.to_list():
    for name_ in name.split("・"):
        namelist.append(name_)
    
#Funktion bekommen_word_Zeichenfolgenliste Wort für Liste_Liste erstellen
word_list = get_word_list(namelist)

# word_Datenrahmenwörter, die Wörter und ihre Häufigkeit aus der Liste abbilden_Erzeugung von df
word_freq = pd.Series(word_list).value_counts()
cardlist_word_count = pd.DataFrame({'word' : word_freq.index,
             'word_count' : word_freq.tolist()})

cardlist_word_count

monsters_words

python

monsters_words= pd.DataFrame(columns=["word","name","level","attr","rarity","species","kind"])
for i, name in enumerate(monsters_norank.name.to_list()):
    words = get_word_list(name.split("・"))
    names = [monsters_norank.loc[i, "name"] for j in words]
    levels = [monsters_norank.loc[i, "level"] for j in words]
    attrs = [monsters_norank.loc[i, "attr"] for j in words]
    rarities = [monsters_norank.loc[i, "rarity"] for j in words]
    species = [monsters_norank.loc[i, "species"] for j in words]
    kinds = [monsters_norank.loc[i, "kind"] for j in words]
    tmp = pd.DataFrame({"word" : words, "name" : names, "level" : levels, "attr" : attrs, "rarity" : rarities, "species" : species, "kind" : kinds})
    monsters_words = pd.concat([monsters_words, tmp])
    
monsters_words

5. Visualisierung

5-1. Verwendete Wortrangfolge

Nehmen Sie aus cardlist_word_count 50 häufige Wörter aller Karten heraus und erstellen Sie eine Rangliste. "Dragon" ist mit 326 Mal die Nummer eins. Insgesamt 610 Auftritte, darunter ähnliche Wörter "Drache (3.)" und "Drache (98.)".

python

df4visual = cardlist_word_count.head(50)

f, ax = plt.subplots(figsize=(20, 10))
ax = sns.barplot(data=df4visual, x="word", y="word_count")
ax.set_ylabel("frequency")
ax.set_title("Wortrang, der in allen Karten verwendet wird")

for i, patch in enumerate(ax.patches):
    ax.text(i, patch.get_height()/2, int(patch.get_height()), ha='center')

plt.xticks(rotation=90)
plt.savefig('./output/nlp5-1.png', bbox_inches='tight', pad_inches=0)

Plötzlich war ich neugierig auf die richtige Verwendung von "Drache" und "Drache" in der Rangliste, also werde ich einen Umweg machen und mit der Suche fortfahren. Nehmen Sie eine Ebene auf der x-Achse und zeichnen Sie die Ergebnisse der Schätzung der Kerneldichte für jedes der Wörter "Drache" und "Drache". Jeder Berg ist so gezeichnet, dass die Gesamtfläche 1 beträgt, und es kann interpretiert werden, dass viele Monster im hohen Teil des Berges versammelt sind. Der Drache hat im Vergleich zum Drachen einen Berggipfel auf der rechten Seite des Diagramms, sodass Sie sehen können, dass er für Karten mit relativ hohem Level und starken Karten verwendet wird.

python

monsters_words_dragon = monsters_words.query("word == 'Drachen' | word == 'Drachen'")
df4visual = monsters_words_dragon

f, ax = plt.subplots(figsize = (20, 5))
ax = sns.kdeplot(df4visual.query("word == 'Drachen'").level, label="Drachen")
ax = sns.kdeplot(df4visual.query("word == 'Drachen'").level, label="Drachen")
ax.set_xlim([0, 12]);
ax.set_title("Drachen/Drachenkernverteilung")
ax.set_xlabel("level")
plt.savefig('./output/nlp5-1a.png', bbox_inches='tight', pad_inches=0)

Der Quellcode und die Interpretation werden weggelassen, aber die Ergebnisse des "Zählplots" nach Ebene und Attribut werden ebenfalls veröffentlicht.

5-2. WordCloud

Word Cloud ist eine Bibliothek zur Wortvisualisierung. Extrahieren Sie die häufig vorkommenden Wörter und zeichnen Sie die häufiger vorkommenden Wörter in einer größeren Größe. wordcloud.generate_from_frequancies () verwendet ein Wörterbuch mit Wörtern und deren Häufigkeit, um ein WordCloud-Objekt zu generieren. Wenn Sie sich die Abbildung ansehen, können Sie sehen, dass der "Drache" in der größten Größe dargestellt ist, wie in 5-1.

python

def make_wordcloud(df,col_name_noun,col_name_quant):
    word_freq_dict = {}
    for i, v in df.iterrows(): #Wörterbuch der Wörter und ihre Häufigkeit aus Datenrahmen
        word_freq_dict[v[col_name_noun]] = v[col_name_quant]
    fpath = "/System/Library/Fonts/Hiragino Kaku Gothic W3.ttc"
    
    #WordCloud instanziieren
    wordcloud = WordCloud(background_color='white',
                        font_path = fpath,
                          min_font_size=10,
                         max_font_size=200,
                         width=2000,
                         height=500
                         )
    wordcloud.generate_from_frequencies(word_freq_dict)
    return wordcloud

f, ax = plt.subplots(figsize=(20, 5))
ax.imshow(make_wordcloud(cardlist_word_count, 'word', 'word_count'))
ax.axis("off")
ax.set_title("Alle Karten WordCloud")
plt.savefig('./output/nlp5-2a.png', bbox_inches='tight', pad_inches=0)

Die Extraktionsergebnisse nach Ebene und Attribut werden ebenfalls angezeigt. Es wird ein wenig vertikal sein, aber wenn Sie nicht interessiert sind, scrollen Sie bitte und überspringen Sie es.

** Nach Level ** Es gibt "Drachen" gleichmäßig auf Level 1-12, aber auf Level 9 gibt es mehr "Drachen", und auf Level 11 scheint es überhaupt keinen Drachen zu geben.

** Nach Attribut ** Kriegerartige Wörter wie Krieger und Retter fallen im Erdattribut auf. Es versteht sich von selbst, dass es viele dunkle Attribute wie "Teufel", "Dunkel" und "Dämon" gibt.

python

def make_wordclouds(df, colname):
    wordclouds = []
    df = df.sort_values(colname)
    for i in df[colname].unique():
        # word_freq = df.query("{} == {}".format(colname,i))["word"].value_counts() #In Pandas konvertieren Serie und Wert_counts()
        word_freq = df[df[colname] == i]["word"].value_counts()
        monsters_word_count = pd.DataFrame({'word' : word_freq.index, 'word_count' : word_freq.tolist()})
        wordclouds.append(make_wordcloud(monsters_word_count, 'word', 'word_count'))

    f, ax = plt.subplots(len(wordclouds), 1, figsize=(20, 5*int(len(wordclouds))))
    for i, wordcloud in enumerate(wordclouds):
        ax[i].imshow(wordcloud)
        ax[i].set_title("{}:".format(colname) + str(df[colname].unique()[i]))
        ax[i].axis("off");
        
make_wordclouds(monsters_words, "level")
plt.savefig('./output/nlp5-2b.png', bbox_inches='tight', pad_inches=0)

make_wordclouds(monsters_words, "attr")
plt.savefig('./output/nlp5-2c.png', bbox_inches='tight', pad_inches=0)

6. Modellierung (verteilter Ausdruck von Wörtern / Sätzen)

Wir führen eine Vektorisierung durch, um es Maschinen zu erleichtern, die Bedeutung von Wörtern zu interpretieren, um zur Ähnlichkeit zwischen Wörtern und dem nachfolgenden maschinellen Lernprozess zu gelangen. Das Konvertieren eines Wortes in einen Vektor mit mehreren Dimensionen in mehrere hundert Dimensionen wird als ** verteilte Darstellung ** bezeichnet. Dieses Mal werden wir "word2vec" für den verteilten Ausdruck von Wörtern verwenden. Durch Übergeben einer Liste von Wörtern können Sie diese einfach in einen Vektor mit einer beliebigen Anzahl von Dimensionen konvertieren. Zusätzlich wird "Doc2Vec" zur Vektorisierung von Satzeinheiten verwendet.

Unter den folgenden Links finden Sie detaillierte Informationen zum Mechanismus und zur Verwendung von Word2Vec und Doc2Vec.

• Word2Vec verstehen
• Zusammenfassung von Doc2Vec

6-1. Word2Vec

Ändern Sie als vorläufige Vorbereitung den im vorherigen Kapitel erstellten Datenrahmen "monsters_words" weiter, um "monsters_wordlist" zu erstellen. Bringe die Zeileneinheit zur Monstereinheit zurück und füge der Spalte "Wortliste" und der Anzahl der Wörter als Spalte "Länge" eine neue Liste der in dieser Karte enthaltenen Wörter hinzu.

python

wordlist = monsters_words.groupby("name")["word"].apply(list).reset_index()
wordlist.columns = ["name", "wordlist"]
wordlist["length"] = wordlist["wordlist"].apply(len)

monsters_wordlist = pd.merge(wordlist, monsters_norank, how="left")
monsters_wordlist

Hier ist der Code, der die Modellierung tatsächlich durchführt. size ist die Anzahl der Dimensionen, iter ist die Anzahl der Wiederholungen des Lernens und windwow ist ein Parameter, der angibt, wie viele Wörter vor und nach dem Lernen vorhanden sind.

python

%time model_w2v = word2vec.Word2Vec(monsters_wordlist["wordlist"], size=30, iter=3000, window=3)
model_w2v

Lassen Sie es uns nach dem Lernen einfach überprüfen. Mit der Methode wv.most_similar () können Sie die obersten n Wörter anzeigen, die eine ähnliche Bedeutung wie ein Wort haben. Als ich versuchte, "rot" einzugeben, stand "** schwarz **", das auch die Farbe darstellt, an erster Stelle. Es ist ein gutes Gefühl! Wenn dieses Empfehlungsergebnis nicht korrekt ist, verschieben Sie die obigen Parameter auf verschiedene Arten und wiederholen Sie die Überprüfung.

python

model_w2v.wv.most_similar(positive="rot", topn=20)

[('schwarz', 0.58682781457901),
 ('Teufel', 0.5581836700439453),
 ('Artefakt', 0.5535239577293396),
 ('Phantom', 0.4850098788738251),
 ('Sein', 0.460792601108551),
 ('von', 0.4455495774745941),
 ('Uralt', 0.43780404329299927),
 ('Wasser', 0.4303821623325348),
 ('Drachen', 0.4163920283317566),
 ('Heilig', 0.4114375710487366),
 ('Genesis', 0.3962644040584564),
 ('Sin', 0.36455491185188293),
 ('Weiß', 0.3636135756969452),
 ('Riese', 0.3622574210166931),
 ('Straße', 0.3602677285671234),
 ('Wächter', 0.35134968161582947),
 ('Leistung', 0.3466736972332001),
 ('Elf', 0.3355366587638855),
 ('Ausrüstung', 0.3334060609340668),
 ('Treiber', 0.33207967877388)]

Als nächstes betrachten wir die Visualisierung dieses Ergebnisses. Da Word2Vec diesmal Wörter in 30-dimensionale Vektoren konvertiert, müssen die Dimensionen (** Dimensionsreduktion **) reduziert werden, um grafisch dargestellt zu werden. t-SNE ist eines der Modelle des unbeaufsichtigten Lernens, das Dimensionen reduziert, und es ist möglich, Daten in jeder Dimension zu aggregieren, um Informationen (Verteilung) nicht so weit wie möglich zu löschen. Ziehen Sie in Betracht, ein Streudiagramm mit der xy-Achse zu zeichnen, und implementieren Sie den Vorgang des Ablegens von 30 Dimensionen in zwei Dimensionen.

python

#Extrahieren Sie 200 häufig verwendete Wörter
n=200
topwords = monsters_words["word"].value_counts().head(n)
w2v_vecs = np.zeros((topwords.shape[0],30))
for i, word in enumerate(topwords.index):
    w2v_vecs[i] = model_w2v.wv[word]

    
# t-Dimensionsreduzierung mit SNE: Von 30 Dimensionen auf 2 Dimensionen fallen lassen
tsne= TSNE(n_components=2, verbose=1, n_iter=500)
tsne_w2v_vecs = tsne.fit_transform(w2v_vecs)

w2v_x = tsne_w2v_vecs[:, 0]
w2v_y = tsne_w2v_vecs[:, 1]

Da jedes Wort zweidimensionale Vektordaten enthält, zeichnen Sie ein Streudiagramm, indem Sie jedes auf der x- und der y-Achse nehmen. Wenn die Informationen der Originaldaten auch nach der Dimensionsreduzierung erhalten bleiben, sollte es möglich sein, zu interpretieren, dass die Wörter, die näher beieinander liegen, ähnliche Bedeutungen haben. Auf den ersten Blick sieht das Plot-Ergebnis so aus, als wären die Wörter zufällig angeordnet, aber es kann auch eine ähnliche Bedeutung wie unten gezeigt haben.

• In der Nähe der Mitte links: Nomenklatur für Personen wie "Person", "Dame" und "Mann".
• In der Nähe unten: Nomenklaturen wie "Meister", "König", "Gott" usw., die Menschen darstellen, die vergöttert und überlegen sind

python

df4visual = pd.DataFrame({"word":topwords.index, "x":w2v_x, "y":w2v_y})
f, ax = plt.subplots(figsize=(20, 20))
ax = sns.regplot("x","y",data=df4visual,fit_reg=False, scatter_kws={"alpha": 0.2})
for i, text in enumerate(topwords.index):
    ax.text(df4visual.loc[i, 'x'], df4visual.loc[i, 'y'], text)
ax.axis("off")
ax.set_title("Visualisierung der Ähnlichkeit von 200 Wörtern, die häufig in Kartentiteln vorkommen")
plt.savefig('./output/nlp6-1.png', bbox_inches='tight', pad_inches=0)

5-2. Doc2Vec

Während "Word2Vec" den verteilten Ausdruck von Wörtern erfasst, kann "Doc2Vec" den verteilten Ausdruck von Sätzen erfassen, indem der Satz, zu dem das Wort gehört, zum Zeitpunkt des Lernens als Tag-Information hinzugefügt wird. Auf diese Weise können Sie die Bedeutung zwischen Sätzen (Kartennamen) und dann dem Regenschirm messen.

Erstellen Sie als vorläufige Vorbereitung ein "TaggedDocument" als Eingabe des Modells. Weisen Sie den Kartennamen, aus dem das Wort besteht, der Liste der Wörter als Tag zu.

python

document = [TaggedDocument(words = wordlist, tags = [monsters_wordlist.name[i]]) for i, wordlist in enumerate(monsters_wordlist.wordlist)]
document[0]

TaggedDocument(words=['A', 'BF', 'Könnte regnen', 'Sohaya'], tags=['A BF－Könnte regnenのSohaya'])

Die Lernmethode ist fast die gleiche wie bei "word2vec". Die Lernmethode "dm" wird auf den Standardwert 0 gesetzt, die Anzahl der Dimensionen "vector_size" wird auf 30 gesetzt und die Anzahl der Wiederholungen "epochs" wird auf 200 gesetzt. 1 Epoche bedeutet übrigens, alle Wörter im Datensatz einmal einzugeben.

python

%time model_d2v = Doc2Vec(documents = document, dm = 0, vector_size=30, epochs=200)

Lassen Sie uns den Test auf die gleiche Weise ausführen. Verwenden Sie die Methode docvecs.most_similar (), um die wenigen ähnlichen Kartennamen mit dem Kartennamen als Eingabe zu überprüfen. Als ich "Black Magician" betrat, kehrte das Black Magician Girl auf den 1. Platz zurück. Da die Kartennamen mit demselben Wort folgen, scheint das Lernen fast richtig gemacht zu sein!

python

model_d2v.docvecs.most_similar("Schwarzer Magier")

[('Schwarzes Magier-Mädchen', 0.9794564843177795),
 ('Toon Black Magician', 0.9433020949363708),
 ('Toon Black Magician Girl', 0.9370808601379395),
 ('Dragon Knight Black Magician', 0.9367024898529053),
 ('Dragon Knight Black Magician Girl', 0.93293297290802),
 ('Black Bull Drago', 0.9305672645568848),
 ('Magier der schwarzen Illusion', 0.9274455904960632),
 ('Astrograph Magier', 0.9263750314712524),
 ('Chronograph Magier', 0.9257084727287292),
 ('Scheibenmagier', 0.9256418347358704)]

Die Dimensionsreduzierung wird ebenfalls auf die gleiche Weise wie "word2vec" durchgeführt, und 200 Karten werden zur Visualisierung zufällig ausgewählt. Ähnliche Wörter kommen fast an der gleichen Stelle vor, was es etwas schwierig macht, sie zu sehen. .. Sie können jedoch sehen, dass die Kartennamen mit demselben Wort in der Nähe verstreut sind.

python

d2v_vecs = np.zeros((monsters_wordlist.name.shape[0],30))
for i, word in enumerate(monsters_wordlist.name):
    d2v_vecs[i] = model_d2v.docvecs[word]

tsne = TSNE(n_components=2, verbose=1, n_iter=500)
tsne_d2v_vecs = tsne.fit_transform(d2v_vecs)

d2v_x = tsne_d2v_vecs[:, 0]
d2v_y = tsne_d2v_vecs[:, 1]

monsters_vec = monsters_wordlist.copy()
monsters_vec["x"] = d2v_x
monsters_vec["y"] = d2v_y

df4visual = monsters_vec.sample(200, random_state=1).reset_index(drop=True)
f, ax = plt.subplots(figsize=(20, 20))
ax = sns.regplot("x","y",data=df4visual, fit_reg=False, scatter_kws={"alpha": 0.2})
for i, text in enumerate(df4visual.name):
    ax.text(df4visual.loc[i, 'x'], df4visual.loc[i, 'y'], text)
ax.axis("off")
ax.set_title("Visualisierung der Ähnlichkeit von 200 Monstern")
plt.savefig('./output/nlp6-2a.png', bbox_inches='tight', pad_inches=0)

Da es eine große Sache ist, werde ich alle Karten ohne Kartennamen zeichnen. Das Folgende ist ein Streudiagramm, das die Bedeutungsnähe (Vektor) aller Karten zeigt, gemalt nach Rasse. Ich denke es war ein tolles Ergebnis! Die kreisförmige Gruppe am unteren Rand des Diagramms kann als Sammlung von Nicht-Serienkarten abgeleitet werden. Karten sind nur spärlich darüber verteilt, aber Sie können wahrscheinlich sehen, dass sie eine kleine Gruppe in derselben Serie bilden.

python

df4visual = monsters_vec
g = sns.lmplot("x","y",data=df4visual, fit_reg=False, hue="attr", height=10)
g.ax.set_title("Verteilung der Bedeutungsnähe aller Kartennamen")

Zum Beispiel gibt es eine Gruppe von Erdattributen um die Koordinaten (x, y) = (-40, -20). Wenn Sie diese Informationen mit einer Abfrage durchsuchen, werden Sie feststellen, dass es sich um eine Sammlung der "Ancient Machines" -Serie handelt. wohlfühlen!

python

monsters_vec.query("-42 <= x <= -38 & -22 <= y <= -18")["name"]

2740 Perfekter Maschinenkönig
3952 Alter Eidechsenkrieger
3953 Alter mechanischer Soldat
3954 Altes mechanisches synthetisches Tier
3955 Alter mechanischer synthetischer Drache
3956 Alter Mechaniker
3957 Alter mechanischer Riese
3958 Altes mechanisches Riesen-Ultimatives Pfund
3959 Alter mechanischer Riesendrache
3960 Alter mechanischer Chaosriese
3961 Alter mechanischer Kerndrache
3962 Alter mechanischer Jagdhund
3963 Altes mechanisches Tier
3964 Alter mechanischer Turm
3965 Ancient Machine Ultimate Giant
3966 Alter Maschinenkasten
3967 Alter mechanischer Körper
3968 Alter mechanischer Superriese
3969 Alter mechanischer fliegender Drache
3970 Alter mechanischer Ritter
3971 Alter mechanischer Geist
3972 Alte Ausrüstung
3973 Alte Getriebemaschine
3974 Alter Magier
4036 Erdriesen-Gaia-Platte
4279 Riesenbrille
4491 Foltermaschine für Pendelklingen
4762 Mechanische Soldaten
4764 Maschinenhund Maron
4765 Maschinenkönig
4766 Machine King-Prototyp
4767 Mechanisches Drachen-Elektrowerkzeug
4768 Mechanischer Sergeant
4994 Lavariese
5247 Schlafender Riese Zushin
5597 Super altes Monster

Lassen Sie uns abschließend die Ähnlichkeit nach Attribut, Rasse und Stufe überprüfen, nicht nach Kartennamen. Der für jede Karte erhaltene Vektor wird für jedes Attribut, jede Rasse und jedes Level gemittelt und für jeden Schnitt jeder Daten aufgezeichnet.

** Nach Attribut **

Nur das Dunkelattribut wurde einem unangenehmen Ort zugeordnet.

python

df4visual = monsters_vec.groupby("attr").mean()[["x", "y"]].reset_index().query("attr != 'Gott Attribut'").reset_index(drop=True) # Gott Attributは外れ値になるため省略する
f, ax = plt.subplots(figsize=(10, 10))
ax = sns.regplot("x","y",data=df4visual, fit_reg=False, scatter_kws={"alpha": 0.2})
for i, text in enumerate(df4visual.attr):
    ax.text(df4visual.loc[i, 'x'], df4visual.loc[i, 'y'], text)

ax.set_title("Visualisierung der Ähnlichkeit von Kartennamen nach Attributen")
plt.savefig('./output/nlp6-2c.png', bbox_inches='tight', pad_inches=0)

** Nach Rennen **

Wenn Sie versuchen, es zu erzwingen, sind der Fisch und die Reptilien nahe beieinander.

python

df4visual = monsters_vec.groupby("species").mean()[["x", "y"]].reset_index().query("species != 'Kreative Götter' & species != 'Phantomtier'").reset_index(drop=True) #Die Rasse des Gottattributs wird weggelassen, weil es ein Ausreißer ist.
f, ax = plt.subplots(figsize=(15, 15))
ax = sns.regplot("x","y",data=df4visual, fit_reg=False, scatter_kws={"alpha": 0.2})
for i, text in enumerate(df4visual.species):
    ax.text(df4visual.loc[i, 'x'], df4visual.loc[i, 'y'], text)
ax.axis("on")
ax.set_title("Visualisierung der Ähnlichkeit von Kartennamen nach Rasse")
plt.savefig('./output/nlp6-2d.png', bbox_inches='tight', pad_inches=0)

** Nach Level **

Sie können sehen, dass das Low-Level-Band (1 ~ 4) ziemlich nahe ist. Selbst im High-Level-Band sind 10 und 11 nahe beieinander, aber 12 ist weit voneinander entfernt, sodass geschlossen werden kann, dass sie unterschiedliche Namenseigenschaften haben.

python

df4visual = monsters_vec.groupby("level").mean()[["x", "y"]].reset_index().query("level != '0'").reset_index(drop=True) #Level 0 ist ein Ausreißer, also lass es weg
f, ax = plt.subplots(figsize=(10, 10))
ax = sns.regplot("x","y",data=df4visual, fit_reg=False, scatter_kws={"alpha": 0.2})
for i, text in enumerate(df4visual.level):
    ax.text(df4visual.loc[i, 'x'], df4visual.loc[i, 'y'], text)

ax.set_title("Visualisierung der Ähnlichkeit von Kartennamen nach Ebene")
plt.savefig('./output/nlp6-2e.png', bbox_inches='tight', pad_inches=0)

Zusammenfassung

Vielen Dank, dass Sie so weit gelesen haben. Um den Namen der Yugioh-Karte weiter zu vertiefen, führten wir eine Reihe von Analysen der morphologischen Analyse durch "Mecab", der Visualisierung durch "WordCloud" und der Erfassung des verteilten Ausdrucks durch "Word2Vec" und "Doc2Vec" durch. Ich denke, das Streudiagramm aller Karten in Doc2Vec fühlt sich für mich gut an. Im maschinellen Lernteil des nächsten Prozesses werden die hier erhaltenen Funktionen unverändert verwendet. Wir erwarten daher, dass wir ein hochgenaues Vorhersagemodell erstellen können.

Vorschau beim nächsten Mal

Es ist endlich maschinelles Lernen. Ich habe es noch nicht implementiert und denke über das Thema nach, aber ich möchte das folgende Vorhersagemodell im Allgemeinen erstellen. Bitte freuen Sie sich darauf.

1. Vorhersage von Offensivkraft, Defensivkraft, Attributen, Rassen usw. aus jedem Kartennamen mit "Doc2Vec" und "LightGBM"
2. Generieren Sie einen Kartennamen mit LSTM (dies kann aus zeitlichen Gründen weggelassen werden ...)