[PYTHON] Ich möchte mit dem Reim part6 umgehen (einmal organisieren)

__ Inhalt __

Während Sie organisieren, was Sie bisher getan haben, organisieren Sie Ihre Gedanken und klären Sie Ihre zukünftige Politik. Einführung der derzeit als am besten geeignet erachteten Methode. Als Thema möchte ich zunächst, dass Sie sich "Rhythmus" näher fühlen. Daher dachte ich, es würde Spaß machen, wenn ich mit den Worten verweilen könnte, die ich normalerweise benutze. Ich dachte an so etwas wie eine Reimsuchfunktion, aber die Idee war, dass jeder dem gleichen Reim folgen und seine Individualität verlieren würde. Dies ist ein Versuch, die Daten aus der Perspektive von "Texten" zu betrachten, wenn etwas eingegeben wird, das normalerweise gedacht, gesprochen oder so etwas wie ein Bulletin über solche Dinge ist.

__ Datenvorverarbeitung __

from pykakasi import kakasi
import re
import numpy as np

with open("./gennama.txt","r", encoding="utf-8") as f:
    data = f.read()
    
kakasi = kakasi()
kakasi.setMode('J', 'K')
kakasi.setMode('H', 'K')
conv = kakasi.getConverter()
#Katakana Bekehrung. (Der Hauptzweck ist das Lesen von Kanji. Es erleichtert auch das Konvertieren von e-i.)
text_data = conv.do(data)

#e i → ee,Holen Sie sich den konvertierten Text wie o u → oo
def expansion(text_data):
    text_data_len = len(text_data)
    text_data = text_data.replace("gut", "Ich ich").replace("U.","U u")
    text_data = text_data.split("ich")
    new_text_data = []
    kakasi.setMode('K', 'a')
    conv = kakasi.getConverter()
    for i in range(len(text_data)):
        if len(text_data[i]) > 0:
            if ("e" in conv.do(text_data[i][-1])):
                new_text_data.append(text_data[i] + "e")
            else:
                new_text_data.append(text_data[i] + "i")
            
    text_data = "".join(new_text_data).split("C.")
    new_text_data = []
    for i in range(len(text_data)):
        if len(text_data[i]) > 0:
            if ("o" in conv.do(text_data[i][-1])):
                new_text_data.append(text_data[i] + "o")
            else:
                new_text_data.append(text_data[i] + "u")
    return "".join(new_text_data)[:text_data_len]

#Trennungen wie Leerzeichen werden als sinnvoll und geteilt angesehen.
def ngram(text_data, N):
    #Leerzeichen und Zeilenumbrüche in voller Breite werden aufgeteilt
    text_data = re.split("\u3000|\n", text_data)
    ngram = []
    for text in text_data:
        if len(text) < N:
            ngram.append(text)
        else:
            for i in range(len(text)-N+1):
                row = "".join(text[i:i+N])
                ngram.append(row)
    return ngram

#Text teilen und transformieren
ex_text_data = expansion(text_data)
n = 5
n_text_data = ngram(text_data, n)
n_ex_text_data = ngram(ex_text_data, n)

dic_text_data = {k:v for k,v in enumerate(n_text_data)}
kakasi.setMode('K', 'a')
conv = kakasi.getConverter()
#Romaji-Konvertierung → Lassen Sie nur Vokale und geben Sie den Schlüsseln Seriennummern, um ein Wörterbuch zu erstellen.
vowel_text_data = [conv.do(t) for t in n_text_data]
vowel_text_data = [re.sub(r"[^aeiou]+","",text) for text in vowel_text_data]
vowel_ex_data = [conv.do(t) for t in n_ex_text_data]
vowel_ex_data = [re.sub(r"[^aeiou]+","",text) for text in vowel_ex_data]
dic_vo_t = {k:v for k,v in enumerate(vowel_text_data)}
dic_vo_ex = {k:v for k,v in enumerate(vowel_ex_data)}

Hier wird der gesamte Text zuerst in Katakana konvertiert. Durch das Lesen von Kanji (das Lesen hängt von den Fähigkeiten des Wörterbuchs ab) wird der Reim erweitert und das Erfassen erleichtert. Ich denke, der beste Weg zum Teilen ist die N-Zeichen-Teilung. Zum Beispiel sind "viele (ooi)" bis "weit (ooi)" leicht zu finden, aber "Technologie (~~ eu ~~ ooi)" und "die Ansicht (ooi ~~ aa ~~)" sollten schwer zu finden sein. Ich denke, dass es möglich ist, die Teile abzudecken, die wahrscheinlich durch Binden von Teilen und Segmentieren übersehen werden. Nach dem Teilen wird es in römische Zeichen konvertiert und es werden Seriennummern angegeben, sodass nur noch Vokale übrig bleiben, sodass es wie eine Wort-ID wird und Sie mit dieser ID auf drei Arten von DIC-Elementen zugreifen können.

__ Wie man den Reim fängt __

#Schneiden Sie das kürzere Wort in Scheiben, und wenn es im anderen enthalten ist, betrachten Sie es als "Reim" und fügen Sie seine Länge als Partitur hinzu
def create_weight(word_a, word_b):
    weight = 0
    if len(word_a) > len(word_b):
        for i in range(len(word_b)):
            for j in range(len(word_b) + 1):
                if word_b[i:j] in word_a and len(word_b[i:j]) > 1 and not word_a==word_b:
                    weight += len(word_b[i:j])
    else:
        for i in range(len(word_a)):
            for j in range(len(word_a) + 1):
                if word_a[i:j] in word_b and len(word_a[i:j]) > 1 and not word_a==word_b:
                    weight += len(word_a[i:j])
    return weight

#Übergeben Sie jedes Würfel und der Index ist Knoten,Der Wert ist Kante,Das Gewicht ist Gewicht(node,node,weight)machen.
def create_edge_list(dic_text_data, dic_vo_t, dic_vo_ex):
    edge_list = []
    for i in dic_text_data.keys():
        for j in dic_text_data.keys():
            text_weight = create_weight(dic_text_data[i],dic_text_data[j])
            vo_weight = create_weight(dic_vo_t[i],dic_vo_t[j])
            ex_weight = create_weight(dic_vo_ex[i],dic_vo_ex[j])
            #Ist es möglich, das Verhältnis zu ändern?
            weight = text_weight*1.0 + vo_weight*1.0 + ex_weight*1.0
            #Vielleicht können Sie hier eine Schwelle setzen. Auch ich-j kann auch Punkte hinzufügen.
            if weight != 0:
                edge_list.append((i,j,weight))
    return edge_list

edge_list = create_edge_list(dic_text_data, dic_vo_t, dic_vo_ex)

Ich denke, das beste Vokal-Match ist das, das ich zuerst verwendet habe. Um beispielsweise "iu, ue, iue" von "aiueo" abzurufen, reicht es nicht aus, die Vokalübereinstimmung von vorne oder hinten zu sehen. Anfangs dachte ich daran, die Eingabedaten mit einem beliebigen Wort namens target_word zu vergleichen, entschied aber, dass es besser wäre, sie innerhalb der Eingabedaten zu vervollständigen. Und da wir hier die Beziehung und Ähnlichkeit jedes geteilten Wortes betrachten, werden wir uns die Grafik ansehen. Durch die Verwendung von drei Arten von Dics für das Gewicht werden außerdem die Übereinstimmung von Konsonanten und dergleichen, die Übereinstimmung von Vokalen und die Übereinstimmung von Vokalen, wenn der Reim erweitert wird, addiert.

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.figure(figsize=(20,20))
plt.show()

Wie Sie sehen können, weiß ich nicht, was es ist. Da es in N Zeichen unterteilt ist, sind benachbarte Wort = Knoten unvermeidlich verbunden. Was ich jetzt denke, ist wie das Auskommentieren in einer Funktion namens "create_edge_list". Versuchen Sie vorerst, mit diesem Cluster zu arbeiten

from networkx.algorithms.community import greedy_modularity_communities

com = list(greedy_modularity_communities(G, weight="weight"))
for i in range(len(com)):
    if len(com[i]) > 2:
        p = com[i]
        print("Gemeinschaft:"+str(i))
        for k in p:
            print(dic_text_data[k])

Es gibt einige gute Punkte, aber es ist frustrierend, einige zu sehen, die leicht falsch ausgerichtet sind. Bei hochmodularem Clustering sind die Verbindungen innerhalb jeder Community stark (sie können gereimt werden) und die Verbindungen zwischen den Communitys sind schwach (sie können nicht mit anderen Communitys gereimt werden), und für jede Community wird ein Satz verwendet. Ich habe das Gefühl, ich kann darauf treten. Aus diesem Grund kann ich das Gefühl nicht leugnen, dass die Kanten zu groß sind.

__ Zusammenfassung __

Sie müssen keine Übereinstimmung mit text_data_dic sehen. Wenn Sie dies tun, ist es besser hinzuzufügen, wann die Vokale übereinstimmen und ob die Konsonanten übereinstimmen. Es scheint, dass Clustering und N-Zeichen-Division nicht kompatibel sind. Ich war jedoch der Meinung, dass Clustering das ultimative Ziel sein könnte. Als zukünftige Richtlinie werde ich die Teilungsmethode überdenken, nach einer Verbesserungsmethode suchen, z. B. ob eine Verbindung hergestellt werden soll, wenn der Abstand zwischen den Knoten nicht mehr als eine bestimmte Entfernung beträgt, und ich werde die ganze Zeit über von der Teilung beunruhigt sein, also werde ich sie vergleichen, ohne sie überhaupt zu teilen. Ich werde über die Methode nachdenken. Auf jeden Fall kann ich das Gefühl nicht leugnen, einen Schritt voraus und einen Schritt zurück zu sein ...