Je veux gérer la rime part4

__ Contenu __

Dans le flux jusqu'à présent, effectuons une analyse de réseau en utilisant les données de texte d'entrée divisées en tant que nœuds et la correspondance des voyelles entre celles divisées en tant que poids de bord. Le but est de dessiner le graphique et de voir la centralité.

__ Divisez les données et faites un dictionnaire __

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] == "symbole":
        continue
    elif part_of_speech_list[i] == "Particule" or part_of_speech_list[i] == "Verbe auxiliaire":
        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_Créez un dictionnaire afin que vous puissiez voir les données avant la conversion de voyelle à partir de l'index de données.{0:"je suis"}
dic = {k:v for k,v in enumerate(segment_text)}

Utilisez ce que vous avez fait dans la partie 3. Juger que N-gram ne convient pas cette fois. Il y a autant de nœuds qu'il y a de clés de dic_vo, et la connexion est vérifiée par s'il y a une correspondance de voyelle entre les nœuds. Plus les voyelles correspondantes sont longues, plus le poids est donné. Utilisez la méthode qui a été créée dans la partie 1, mais permettez de créer une arête à partir de la connexion à elle-même et de la correspondance de deux caractères ou plus.

__ Faire un graphique __

#dic_Passer vo et l'index est le nœud,La valeur est edge,Le poids est le score(node,node,score)faire.
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)            

Après cela, dessinez un graphique basé sur cette edge_list. Ensuite, obtenez un nœud avec une centralité de vecteur propre et une centralité de médiation élevées, et affichez les données d'origine.

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()

#Centralité vectorielle intrinsèque
cent = nx.eigenvector_centrality_numpy(G)
max_cent_node = max(list(cent.keys()), key=lambda val: cent[val])
#Centralité de la médiation
between_cent = nx.communicability_betweenness_centrality(G, weight="weight)
max_betw_node = max(list(between_cent.keys()), key=lambda val: between_cent[val])

print("Centralité élevée du vecteur propre:" + dic[max_cent_node])
print("Centralité élevée de la médiation:" + dic[max_betw_node])

Comme prévu, le résultat est le même que "Je peux affiner le mot_cible" fait dans part2. Eh bien, c'est naturel parce que je fais la même chose, mais avec networkx, il semble y avoir quelque chose que je peux encore faire sur la base de ce graphique, donc je vais continuer.

Planifiez à partir de maintenant

Dans la façon de marquer, faites attention à "i" et "u", et si le son précédent est "e" et "o", c'est-à-dire si "e i" "o u", convertissez-le en "ee" "oo" Je pense voir la correspondance des voyelles. Il est difficile de distinguer même en japonais (se référant à la prononciation de mots étrangers), et on peut dire que le son est le même. Cela semble être NG dans le traitement de la réverbération dans le monde du tour, mais je vais l'essayer. ~~ Au fait, avez-vous déjà entendu la vraie "chanson ABC"? C'est ce qui fait de "LMNOP" "elenenopy" d'un seul coup. «Rhythm» me semble familier depuis que je suis enfant. Je n'oublierai pas le respect du rap japonais, mais je vais essayer d'élargir un peu la rime ~~