La dernière fois, j'ai créé un article intitulé J'ai essayé de créer automatiquement un rapport avec la chaîne Markov. À ce moment-là, j'utilisais la chaîne de Markov, donc je me suis retrouvé avec une phrase qui ignorait le flux de la phrase. Par conséquent, cette fois, nous prévoyons de créer des phrases qui sont conscientes du contexte en utilisant une technologie appelée GRU.
Je pense que RNN et LSTM sont bien connus en matière de génération de phrases, mais j'ai choisi cela car cela demande moins de temps d'apprentissage que le LSTM. Je ne connais pas la structure détaillée, donc je ne l'écrirai pas, mais je peux pratiquement l'écrire avec presque le même code que LSTM.
Implémentons-le maintenant.
Commencez par charger la bibliothèque à utiliser.
import re
import MeCab
import numpy as np
from sklearn.model_selection import train_test_split
from gensim.models import word2vec
from keras.layers.core import Activation
from keras.layers.core import Dense, Dropout
from keras.layers.core import Masking
from keras.models import Sequential
from keras.layers.recurrent import GRU
from keras.layers.embeddings import Embedding
from keras.layers.normalization import BatchNormalization
from keras.utils import np_utils
from keras.optimizers import RMSprop
Les données utilisées cette fois-ci proviennent de Aozora Bunko. Cette fois, j'ai utilisé "Phantom Twenty Faces" de Ranpo Edogawa.
Définissez une fonction qui supprime les données inutiles de ces données et effectue une analyse morphologique.
def convert(text, train):
if train:
#Supprimer les éléments inutiles tels que le rubis
text = re.split(r"\-{5,}", text)[2]
text = re.split(r"Livre du bas:", text)[0]
text = re.sub(r"《.*?》", "", text)
text = re.sub(r"［.*?］", "", text)
text = re.sub(r"[｜]", "", text)
text = re.sub("(\n){2,}", "\n", text)
text = re.sub(r"\u3000", "", text)
#Analyse morphologique
mecab = MeCab.Tagger("-Owakati")
return mecab.parse(text).split()
Ici, je veux l'utiliser pour le prétraitement des données de prédiction, j'ai donc préparé un argument de valeur booléenne appelé train et ruby supprimé, etc. uniquement au moment de la formation. Maintenant, exécutons cette fonction.
path = "text_raw/kaijin_nijumenso.txt"
with open(path, "r") as f:
text = f.read()
text_split = convert(text, True)
Lorsqu'il est lu comme ceci, text = Phantom Twenty Faces \ n Edogawa Ranpo \ n \ n -----------
C'est lu comme.
Et il est divisé comme text_split = ['hashi', 'is', 'ki', 'that', 'koro', ',' ,,,.
Commencez par convertir les mots analysés morphologiquement en nombres. Ce n'est qu'un nombre, alors procédez comme suit: Ici, 0 est utilisé pour le masquage (les données excédentaires sont traitées comme 0), il est donc nécessaire de «+ 1».
#Créer un dictionnaire de mots et de nombres
vocab_r = dict((key + 1, word) for (key, word) in enumerate(set(text_split)))
vocab = dict((word, key) for (key, word) in vocab_r.items())
text_num = list(map(lambda x:vocab[x], text_split))
Ensuite, créez un ensemble de données pour l'entraînement. Comme cela sera décrit plus loin, puisque les données d'entrée vectorisent les mots dans la couche Embedding, définissez la dimension sur (n_sample, n_seq) = (nombre de données d'entrée, combien de mots à apprendre). De plus, puisque l'étiquette de réponse correcte sera convertie en one-hot plus tard, cela devrait également être dans la dimension de (n_sample) = (nombre de données d'entrée).
n_seq = 10 #Combien de mots à apprendre
num_char = len(set(text_split)) + 1 #Type de mot (y compris le masquage)
n_sample = len(text_num) - n_seq #Nombre de données d'entrée
#Créer des données
input_data = np.zeros((n_sample, n_seq))
correct_data = np.zeros((n_sample))
for i in range(n_sample):
input_data[i] = text_num[i:i + n_seq]
correct_data[i] = text_num[i + n_seq]
x_train, x_test, y_train, y_test = train_test_split(input_data, correct_data, test_size=0.1, shuffle=True)
Pour les données d'entrée, les mots sont vectorisés dans la couche Embedding, mais si vous le faites simplement, la taille des données deviendra énorme, nous utiliserons donc une représentation distribuée. Il s'agit de vectoriser les mots en tenant compte de la relation entre les mots, et en l'utilisant, il est possible d'exprimer des mots dans un petit nombre de dimensions.
model_w2v = word2vec.Word2Vec([text_split], size=100, min_count=1, window=5, iter=10)
embedding_matrix = np.zeros((num_char, 100))
for w, vec in zip(model_w2v.wv.index2word, model_w2v.wv.vectors):
embedding_matrix[vocab[w]] = vec
Utilisation de model_w2v.wv.index2word, model_w2v.wv.vectors
'Baguettes':[ 0.04145062, -0.01713059, -0.0444374 ,,,],
'Mais':[ 0.554178 , -0.19353375, -0.56997895,,,]
Il peut être vectorisé comme. Combinez cela avec le dictionnaire de mots et de nombres que vous avez créé précédemment
[[ 0. , 0. , 0. , ..., 0. ],
[ 0.00860965, -0.00045624, -0.00883528, ..., -0.00861127],
...
[ 0.00662873, -0.00499085, -0.01188819, ..., -0.01252057]]
J'ai pu créer un vecteur de poids comme celui-ci.
Étudions avec GRU. Le modèle lui-même peut apprendre les paramètres tels quels en changeant simplement le LSTM en GRU.
#Créer un modèle
model = Sequential()
model.add(Embedding(num_char, 100, weights=[embedding_matrix], trainable=False, input_length=n_seq))
model.add(BatchNormalization(axis=-1))
model.add(Masking(mask_value=0, input_shape=(n_seq, 100)))
model.add(GRU(128, input_shape=(n_seq, 100), kernel_initializer='random_uniform'))
model.add(Dropout(0.2))
model.add(Dense(num_char))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer=RMSprop(lr=0.01), metrics=['categorical_accuracy'])
model.fit(x_train, np_utils.to_categorical(y_train, num_char), batch_size=128, validation_split=0.05, epochs=100,
shuffle=True)
Je ne connais pas les paramètres, j'ai donc fait référence à cet article.
Jetons un coup d'œil aux données de test.
y_pred = model.predict(x_test)
print(list(map(lambda x:vocab_r[x], np.argmax(y_pred, axis=1))))
La sortie ressemble à ceci:
Hahaha ……. ", Félicitez constamment"À"
J'ai levé les yeux. En effet, la longue main"Les gars"
Vous êtes un aventurier naturel et vous êtes au collège"、"
Il a une atmosphère légèrement subtile.
Essayons quels types de phrases sont réellement créés en supposant la chaîne de caractères saisie.
Premièrement, le mot est analysé et divisé morphologiquement. Je vais l'essayer avec les nouvelles qui se sont avérées être dans la tendance sur Twitter.
input_text = "Accumulation de substances responsables de la démence due à la maladie parodontale Université Kyushu et autres annoncées"
input_text_split = convert(input_text, False)
Convertissez des mots en nombres. À ce stade, les mots qui ne figurent pas dans les données d'apprentissage ne sont pas enregistrés dans le dictionnaire et une erreur se produit, si bien que le traitement des exceptions qui renvoie 0 est effectué.
def word2vec_input(x):
"""
Convertir des nombres en mots
Renvoie 0 pour les caractères ne figurant pas dans le dictionnaire
"""
try:
return vocab[x]
except:
return 0
vocab_r[0] = "<nodata>"
#Convertir des mots en nombres
input_text_num = list(map(lambda x:word2vec_input(x), input_text_split))
Lorsque vous faites des prédictions, assurez-vous que les données d'entrée sont (nombre de données d'entrée, combien de mots à apprendre) = (1, n_seq).
#Remplissez avec 0 si le nombre de mots est court
if len(input_text_num) < n_seq:
input_text_num = [0]*(n_seq - len(input_text_num)) + input_text_num
#Fonction de prédiction
def prediction(input_text_num):
input_test = np.zeros((1, n_seq))
input_test[0] = input_text_num[-n_seq:]
y_pred = model.predict(input_test)
return np.append(input_text_num, np.where(y_pred == np.sort(y_pred)[:, -1].reshape(-1, 1))[1]) # np.argmax(y_pred))
#J'ai écrit ceci parce que je jouais avec l'écriture de phrases avec la deuxième probabilité la plus élevée, mais argmax suffit
#Exécuter des prédictions
for i in range(1000):
input_text_num = prediction(input_text_num)
Après l'apprentissage, les nombres sont reconvertis en mots pour créer des phrases.
test_pred = list(map(lambda x:vocab_r[x], input_text_num[len(input_text_split):])) #Découpez le nombre de mots à apprendre
pred_text = input_text + "".join(test_pred) #Utilisez l'entrée telle quelle
print(pred_text)
La chaîne créée ressemble à ceci.
Accumulation de substances responsables de la démence due à la maladie parodontale L'Université Kyushu et d'autres ont annoncé. "Vous, vous, comment, vous, quel genre de chose, j'ai regardé à l'intérieur." Oui, vous, comment, comme vous, regardez ce genre de chose, "voyez. En plus, aux subordonnés du ministre aux vingt visages, l'un d'eux "battait, c'est tout." Hahaha ... "Akechi a dit:" Oui, quoi, "soir ... "..." "Oh, qu'en est-il de Kobayashi? J'ai regardé en toi et j'ai vu le nigiri." Oh, comment es-tu venu? La gentillesse était sur le visage comme un voleur. "... De nos jours, c'est tout." L'art disait: "Alors, l'étagère." "Et le voleur a saisi son teint, et M. Sotaro a dit
Mon japonais est devenu fou ...
Après cela, enregistrez le modèle selon vos besoins.
#Enregistrer le modèle
model.save('test.h5')
model.save_weights('param.hdf5')
#Lis
from tensorflow.python.keras.models import load_model
model = load_model('model/test.h5')
model.load_weights('model/param.hdf5')
Comme vous pouvez le voir, la précision est devenue très faible. Si vous avez des idées d'amélioration, faites-le moi savoir.
Recommended Posts