[PYTHON] Je veux gérer la rime part6 (organiser une fois)

__ Contenu __

Tout en organisant ce que vous avez fait jusqu'à présent, organisez vos réflexions et clarifiez votre future politique. Présentation de la méthode jugée la plus adaptée actuellement. Tout d'abord, en tant que thème, je veux que vous ressentiez le «rythme» de plus près. Par conséquent, j'ai pensé que ce serait amusant si je pouvais m'attarder sur les mots que j'utilise habituellement. J'ai pensé à quelque chose comme une fonction de recherche de rimes, mais l'idée était que tout le monde suivrait la même rime et perdrait son individualité. Il s'agit d'une tentative de regarder les données du point de vue des "paroles" quand quelque chose qui est habituellement pensé, prononcé ou quelque chose comme un bulletin de telles choses est entré.

__ Prétraitement des données __

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()
#Conversion Katakana. (Le but principal est de lire les kanji. Cela facilite également la conversion d'e-i.)
text_data = conv.do(data)

#e i → ee,Obtenez le texte converti comme o u → oo
def expansion(text_data):
    text_data_len = len(text_data)
    text_data = text_data.replace("bien", "Je je").replace("U","U u")
    text_data = text_data.split("je")
    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]

#La séparation comme les espaces est considérée comme significative et divisée.
def ngram(text_data, N):
    #Les espaces pleine largeur et les sauts de ligne sont fractionnés
    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

#Diviser et transformer du texte
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()
#Conversion Romaji → Ne laissez que les voyelles et donnez des numéros de série aux touches pour créer un dictionnaire.
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)}

Ici, tout le texte est d'abord converti en katakana. En lisant des kanji (la lecture dépend de la capacité du dictionnaire), l'idée que la variation de division augmente et la partie appelée «expansion» élargit la rime et la rend plus facile à saisir. Je pense que la meilleure façon de diviser est la division en N caractères. Par exemple, "many (ooi)" à "far (ooi)" sont faciles à trouver, mais "technology (~~ eu ~~ ooi)" et "the view (ooi ~~ aa ~~)" devraient être difficiles à trouver. Je pense qu'il est possible de couvrir les parties qui risquent d'être négligées par les parties de reliure et la segmentation. Après la division, il est converti en caractères romains et les numéros de série sont donnés de sorte qu'il ne reste que les voyelles, il devient donc comme un identifiant de mot, et les trois types d'éléments dic sont accessibles par cet identifiant.

__ Comment saisir la rime __

#Découpez le mot le plus court, et s'il est inclus dans l'autre, considérez-le comme une "rime" et ajoutez sa longueur en tant que partition
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

#Passez chaque dic et l'index est node,La valeur est edge,Le poids est le poids(node,node,weight)faire.
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])
            #Est-il possible de changer le ratio?
            weight = text_weight*1.0 + vo_weight*1.0 + ex_weight*1.0
            #Vous pouvez peut-être faire un seuil ici. Aussi je-Il peut également être possible d'ajouter le score à j.
            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)

Je pense que la meilleure correspondance de voyelle est celle que j'ai utilisée en premier. Par exemple, pour récupérer "iu, ue, iue" de "aiueo", il ne suffit pas de voir la voyelle concordante de l'avant ou de l'arrière. Au départ, je pensais comparer les données d'entrée avec un mot arbitraire appelé target_word, mais j'ai décidé qu'il serait préférable de le compléter dans les données d'entrée. Et puisque ce que nous faisons ici est d'examiner la relation et la similitude de chaque mot divisé, nous allons regarder le graphique. De plus, en utilisant trois types de dic pour le poids, la correspondance des consonnes et autres, la correspondance des voyelles et la correspondance des voyelles lorsque la rime est développée sont additionnées.

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

Comme vous pouvez le voir, je ne sais pas ce que c'est. Puisqu'il est divisé en N caractères, mot adjacent = nœuds sont inévitablement connectés. Ce à quoi je pense maintenant, c'est comme commenter une fonction nommée create_edge_list. Pour le moment, essayez de regrouper avec ceci

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("communauté:"+str(i))
        for k in p:
            print(dic_text_data[k])

Il y a quelques bons points, mais il est frustrant de voir certains qui sont légèrement désalignés. Avec un regroupement très modulaire, les connexions au sein de chaque communauté sont fortes (elles peuvent être rimées), et les connexions entre les communautés sont faibles (elles ne peuvent pas être rimées avec d'autres communautés), et une phrase est utilisée pour chaque communauté. Je sens que je peux marcher dessus. Pour cette raison, je ne peux nier le sentiment que les bords sont trop importants.

__ Résumé __

Vous n'avez pas besoin de voir une correspondance avec text_data_dic. Si vous le faites, il est préférable d'ajouter quand les voyelles correspondent et si les consonnes correspondent. Il semble que le regroupement et la division de N caractères soient incompatibles. Cependant, j'ai estimé que le regroupement pourrait être le but ultime. En tant que politique future, je reconsidérerai la méthode de division, rechercherai une méthode d'amélioration telle que la connexion si la distance entre les nœuds n'est pas supérieure à une certaine distance, et je serai tout le temps troublé par la division, donc je vais la comparer sans la diviser du tout. Je vais réfléchir à la méthode. En tout cas, je ne peux pas nier le sentiment d'avoir une longueur d'avance et un pas de moins ...