[PYTHON] Ich möchte mit dem Reim part4 umgehen

__ Inhalt __

Lassen Sie uns im bisherigen Ablauf eine Netzwerkanalyse durchführen, indem wir die geteilten Eingabetextdaten als Knoten und die Übereinstimmung der Vokale zwischen den geteilten als Kantengewichte verwenden. Ziel ist es, den Graphen zu zeichnen und die Zentralität zu erkennen.

__ Teilen Sie die Daten und erstellen Sie ein Wörterbuch __

from pykakasi import kakasi
import re
from collections import defaultdict
from janome.tokenizer import Tokenizer

with open("./gennama.txt","r") as f:
    data = f.read()
    
tokenizer = Tokenizer()
tokens = tokenizer.tokenize(data)

surface_list = []
part_of_speech_list = []
for token in tokens:
    surface_list.append(token.surface)
    part_of_speech_list.append(token.part_of_speech.split(",")[0])
    
segment_text = []
for i in range(len(surface_list)):
    if part_of_speech_list[i] == "Symbol":
        continue
    elif part_of_speech_list[i] == "Partikel" or part_of_speech_list[i] == "Hilfsverb":
        row = segment_text.pop(-1) + surface_list[i]
    else:
        row = surface_list[i]
    segment_text.append(row)

kakasi = kakasi()

kakasi.setMode('H', 'a')
kakasi.setMode('K', 'a')
kakasi.setMode('J', 'a')

conv = kakasi.getConverter()
text_data = [conv.do(text) for text in segment_text]
vowel_data = [re.sub(r"[^aeiou]+","",text) for text in text_data]
#{0:"oea"}
dic_vo = {k:v for k,v in enumerate(vowel_data)}
#voel_Erstellen Sie ein Wörterbuch, damit Sie die Daten vor der Vokalkonvertierung aus dem Datenindex sehen können.{0:"ich bin"}
dic = {k:v for k,v in enumerate(segment_text)}

Verwenden Sie, was Sie in Teil 3 getan haben. Zu urteilen, dass N-Gramm diesmal nicht geeignet ist. Es gibt so viele Knoten wie Schlüssel von dic_vo, und die Verbindung wird überprüft, ob zwischen den Knoten eine Vokalübereinstimmung besteht. Je länger die passenden Vokale sind, desto mehr Gewicht wird gegeben. Verwenden Sie die in Teil 1 erstellte Methode, aber ermöglichen Sie es, eine Kante aus der Verbindung zu sich selbst und der Übereinstimmung von zwei oder mehr Zeichen zu erstellen.

__ Machen Sie ein Diagramm __

#dic_Pass vo und Index ist Knoten,Der Wert ist Kante,Das Gewicht ist Punktzahl(node,node,score)machen.
def create_edge(dic_vo):
    node_len = len(dic_vo)
    
    edge_list = []
    for i in range(node_len):
        for j in range(node_len):
            score = create_weight(dic_vo[i],dic_vo[j])
            if score != 0:
                edge_list.append((i,j,score))
    return edge_list
            
def create_weight(word_a, word_b):
    weight = 0
    if len(word_a) > len(word_b):
        max_len = len(word_b)
        for i in range(max_len):
            for j in range(max_len + 1):
                if word_b[i:j] in word_a:
                    if word_b == word_a:
                        continue
                    elif len(word_b[i:j]) < 2:
                        continue
                    else:
                        weight += len(word_b[i:j])
    else:
        max_len = len(word_a)
        for i in range(max_len):
            for j in range(max_len + 1):
                if word_a[i:j] in word_b:
                    if word_a == word_b:
                        continue
                    elif len(word_b[i:j]) < 2:
                        continue
                    else:
                        weight += len(word_a[i:j])
    return weight

edge_list = create_edge(dic_vo)            

Zeichnen Sie danach ein Diagramm basierend auf dieser edge_list. Als nächstes erhalten Sie einen Knoten mit hoher Eigenvektorzentralität und Mediationszentralität und zeigen die Originaldaten an.

import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph()
G.add_weighted_edges_from(edge_list)
pos = nx.spring_layout(G)
nx.draw_networkx_edges(G, pos)

plt.show()

#Intrinsische Vektorzentralität
cent = nx.eigenvector_centrality_numpy(G)
max_cent_node = max(list(cent.keys()), key=lambda val: cent[val])
#Mediationszentralität
between_cent = nx.communicability_betweenness_centrality(G, weight="weight)
max_betw_node = max(list(between_cent.keys()), key=lambda val: between_cent[val])

print("Hohe Eigenvektorzentralität:" + dic[max_cent_node])
print("Hohe Vermittlungszentralität:" + dic[max_betw_node])

Wie erwartet ist das Ergebnis dasselbe wie "Ich kann das Zielwort eingrenzen", das ich in Teil 2 durchgeführt habe. Nun, es ist natürlich, weil es dasselbe tut, aber mit networkx scheint es etwas zu geben, das basierend auf diesem Diagramm noch getan werden kann, also werde ich es weiterverfolgen.

Plan von nun an

Achten Sie beim Scoring auf "i" und "u". Wenn der vorherige Sound "e" und "o" ist, dh wenn "e i" "o u", konvertieren Sie ihn in "ee" "oo". Ich denke daran, die Übereinstimmung von Vokalen zu sehen. Selbst auf Japanisch ist es schwierig zu unterscheiden (bezogen auf die Aussprache von Fremdwörtern), und man kann sagen, dass der Klang der gleiche ist. Es scheint NG bei der Behandlung von Nachhall in der Rundenwelt zu sein, aber ich werde es versuchen. ~~ Hast du übrigens jemals das echte "ABC-Lied" gehört? Das macht "LMNOP" auf einmal zu "elenenopy". "Rhythm" kommt mir seit meiner Kindheit bekannt vor. Ich werde den Respekt vor japanischem Rap nicht vergessen, aber ich werde versuchen, den Reim ein wenig zu erweitern ~~