Dernière fois Est-il nécessaire d'améliorer la méthode de division des données d'entrée? J'ai ressenti cela, alors j'ai essayé différentes méthodes de division. Les données d'entrée utilisent les paroles d'un certain wrapper comme auparavant. Pour le moment, j'ai aussi un thème de la rime que je préparais pour vérification.
import MeCab
mecab = MeCab.Tagger("-Owakati")
mecab_text = mecab.parse(data).split()
Il y a une partie où les "paroles" comme les paroles peuvent être extraites, mais elle ne peut pas être reconnue car la partie sur laquelle on marche à "des dizaines de milliers de yens" est divisée en "dizaines de milliers, yens" par la division. En passant, il semble que vous ne pouvez pas transmettre beaucoup de données à conv.do de kakashi à la fois. text_data = [conv.do (texte) pour le texte dans mecab_text]. À propos, la longueur maximale du mot converti en voyelle après la division était de 8 caractères et la moyenne était de 2,16 caractères. On peut dire que la division par division ne convient pas car elle est trop finement divisée.
~~ J'ai été frustré plusieurs fois avant de pouvoir utiliser cette MeCab. J'ai peut-être oublié divers articles. Ici Merci ~~
Mais que se passe-t-il si nous le divisons simplement par N caractères? N essaiera de 4.
def make_ngram(words, N):
ngram = []
for i in range(len(words)-N+1):
#Supprimer les espaces codés sur deux octets et les sauts de ligne
row = "".join(words[i:i+N]).replace("\u3000","").replace("\n","")
ngram.append(row)
return ngram
Quant à l'expérience, N semble être bon à 5 ou plus. (S'il est de 4 ou moins, il n'y a pas de différence de partition.) La rime peut être détectée en fonction des paroles. Lorsque j'ai mis les données de vérification à titre d'essai, j'ai pu détecter une rime apparemment inaperçue. Puisque les mots sont découpés de différentes manières, essayez de changer la façon dont ils sont notés.
def make_score_ngram(word_a, word_b):
score = 0
for i in range(len(word_a)):
if word_a[-i:] == word_b[-i:]:
score += i
return score
La sortie est facile à voir en voyant la correspondance de voyelle à partir de la fin du mot. Pour la valeur de N, len (target_word_vo) (la longueur de la voyelle du mot original pour rechercher la rime) serait bien. J'ai l'impression d'avoir pu exprimer ce que je veux faire.
J'ai eu du mal à rendre possible l'utilisation de MeCab, et j'ai pensé à "quantifier la rime" à ma manière, donc je veux l'utiliser. Combinons ces deux.
Dans la "quantification de la rime", la partie où les voyelles concordent a été recherchée et la longueur correspondante len (mot [i: j) a été utilisée comme score. Ce mot [i: j] a une forme telle que "eoi", et si vous comptez le nombre d'occurrences, vous devriez être capable de trouver la voyelle la plus apparente dans les données d'entrée. L'idée est que si vous spécifiez un mot qui l'inclut dans target_word, vous pouvez vous attendre à de nombreuses recommandations. Je suis désolé d'utiliser le texte préparé pour le fractionnement et la vérification.
from pykakasi import kakasi
import re
from collections import defaultdict
import MeCab
with open("./test.txt","r",encoding="utf-8") as f:
data = f.read()
mecab = MeCab.Tagger("-Owakati")
mecab_text = mecab.parse(data).split()
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 mecab_text]
vowel_data = [re.sub(r"[^aeiou]+","",text) for text in text_data]
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.
dic = {k:v for k,v in enumerate(mecab_text)}
#Utilisez defaultdict pour ignorer l'initialisation lors de l'ajout de nouvelles clés{voyelle:Nombre d'apparitions}
dic_rhyme = defaultdict(int)
for word_a in vowel_data:
for word_b in vowel_data:
if len(word_a) > len(word_b):
word_len = len(word_b)
for i in range(word_len):
for j in range(word_len + 1):
#Ne comptez que 2 caractères ou plus
if word_b[i:j] in word_a and not len(word_b[i:j])<2:
dic_rhyme[word_b[i:j]] += 1
else:
word_len = len(word_a)
for i in range(word_len):
for j in range(word_len + 1):
if word_a[i:j] in word_b and not len(word_a[i:j])<2:
dic_rhyme[word_a[i:j]] += 1
#Trier par ordre décroissant du nombre
dic_rhyme = sorted(dic_rhyme.items(), key=lambda x:x[1], reverse=True)
print(dic_rhyme)
#dic_Recherchez ceux qui sont plus riches en rimes. ici"ai"utilisation
bool_index = ["ai" in text for text in vowel_data]
for i in range(len(vowel_data)):
if bool_index[i]:
print(dic[i])
J'ai pu obtenir la séquence de voyelles qui apparaissent fréquemment et afficher là où elles sont utilisées. Cependant, les mots subdivisés par la division étaient difficiles à comprendre. Peut-être y avait-il une rime un peu plus longue.
Je ne ressens pas le besoin de restreindre le target_word (parce que je veux spécifier ce que je veux dire le plus), mais il peut être bon de pouvoir confirmer quelle séquence de voyelles est fréquente. Cela ne s'est pas bien passé avec la division, mais je veux l'améliorer en utilisant MeCab (~~ plusieurs fois, j'ai lutté jusqu'à ce qu'il devienne utilisable ~~). De plus, en adoptant N-gramme, nous avons pu simplifier la «quantification de la rime», nous allons donc nous demander si nous pouvons redéfinir «rhin» d'une manière légèrement plus compliquée. (Actuellement, "tsu" n'est pas pris en compte) Cependant, j'ai fait un détour. La «numérisation de la rime» est quelque chose à laquelle j'ai pensé à ma manière afin de pouvoir gérer les données d'entrée afin de ne pas fuir la rime. Pas question, le découpage de divers arguments peut résoudre les données d'entrée en découpant de manière variée (l'expression peut être différente) ... ou en ne le remarquant pas. Les bases sont importantes. Mais ne pensez-vous pas que N-gram peut rendre le japonais sans signification? Cependant, il existe un moyen de souligner la partie «lyrique» et de la prononcer. Après tout, il est important d'essayer quand même d'utiliser des données simples.
Recommended Posts