[PYTHON] J'ai fait apprendre à RNN la vague de péché et j'ai essayé de prédire

0. En gros

• Implémentation d'un simple RNN (Recurrent Neural Network) avec TensorFlow.
• En utilisant RNN, l'onde sin a été formée pour prédire «sin (t + 1)» (étape suivante) à partir de «sin (t)».
• En chaînant les résultats de sortie de RNN, nous avons pu réaliser la prédiction de «sin (t + n)» (étapes multiples).
• LSTM (Long Short-Term Memory) a été utilisé pour la cellule RNN.

*** Ajouté le 27 mai 2016: ***

J'ai écrit la suite "J'ai fait apprendre à RNN les ondes de péché et j'ai prédit: Hyper réglage des paramètres".

1. À propos de TensorFlow, RNN, LSTM

Je vais l'omettre grossièrement. Je pense que le tutoriel TensorFlow et les articles référencés seront utiles.

• Recurrent Neural Networks
• Understanding LSTM Networks -- colah's blog
• Présentation du réseau LSTM --Qiita (Traduction de l'article ci-dessus)

2. Préparation des données de formation

Une onde sinusoïdale avec 50 étapes par cycle a été générée pendant 100 cycles, pour un total de 5 000 étapes, et utilisée comme données d'entraînement. De plus, nous avons préparé deux types de données d'entraînement, pas de bruit et pas de bruit.

Les données d'apprentissage se composent d'une paire de «sin (t)» (valeur sin au temps t) et «sin (t + 1)» (valeur sin au temps t + 1). Pour plus de détails sur la génération des données d'entraînement, veuillez vous référer au fichier ʻipynb (IPython Notebook). (En passant, j'ai été surpris que le fichier ʻipynb ait été prévisualisé sur GitHub)

2.1. Pas de bruit

train_data/normal.ipynb

2.2. Bruyant

train_data/noised.ipynb

3. Apprentissage / prédiction

Cette fois, nous apprenons et prédisons avec un seul code. Le code source est présenté en annexe à la fin de la phrase.

3.1. Flux de processus

Le flux d'apprentissage et de prédiction est le suivant.

1. Apprendre à l'aide des données d'entraînement
2. Prédire «sin (t + 1)» en utilisant les données initiales (le début des données d'entraînement)
3. Prédire «sin (t + 2)» en utilisant le «sin (t + 1)» prédit 4.3 Répéter 3

3.2. Configuration du réseau

J'ai utilisé un réseau appelé "couche d'entrée cachée couche-RNN cellule-couche de sortie". Nous avons également utilisé LSTM pour la cellule RNN.

3.3. Hyper paramètres

Les hyper paramètres utilisés pour l'apprentissage et la prédiction sont les suivants.

4. Résultat de la prédiction

La figure ci-dessous représente les résultats de la prédiction. La légende est la suivante.

• Ligne pointillée noire: données d'entraînement
• Bleu fixe: données initiales
• Vert fixe: données prédictives

4.1. Pas de bruit

Une forme d'onde comme celle-ci est sortie. L'amplitude globale est peu profonde, les sommets sont déformés et la fréquence est un peu plus basse. Veuillez vous référer à basic / output.ipynb pour des valeurs spécifiques.

4.2. Bruyant

L'amplitude est encore moins profonde et la fréquence est légèrement plus élevée que sans bruit. De plus, il semble que la composante de bruit contenue dans les données d'apprentissage ait été réduite. Voir noised / output.ipynb pour des valeurs spécifiques.

5. Plans futurs

J'aimerais essayer de changer la configuration du réseau et les hyper paramètres pour voir quel type de résultats de prédiction sera obtenu.

*** Ajouté le 27 mai 2016: ***

J'ai écrit la suite "J'ai fait apprendre à RNN les ondes de péché et j'ai prédit: Hyper réglage des paramètres".

Annexe: code source

Le code source de la version silencieuse est indiqué ci-dessous. Veuillez vous référer à GitHub pour le code source de la version bruyante. La version bruyante et la version bruyante ne diffèrent que par le nom du fichier d'entrée.

• Version sans bruit: basic / rnn.py (code ci-dessous)
• Version bruyante: noised / rnn.py

rnn.py

import tensorflow as tf
from tensorflow.models.rnn import rnn, rnn_cell
import numpy as np
import random

def make_mini_batch(train_data, size_of_mini_batch, length_of_sequences):
    inputs  = np.empty(0)
    outputs = np.empty(0)
    for _ in range(size_of_mini_batch):
        index   = random.randint(0, len(train_data) - length_of_sequences)
        part    = train_data[index:index + length_of_sequences]
        inputs  = np.append(inputs, part[:, 0])
        outputs = np.append(outputs, part[-1, 1])
    inputs  = inputs.reshape(-1, length_of_sequences, 1)
    outputs = outputs.reshape(-1, 1)
    return (inputs, outputs)

def make_prediction_initial(train_data, index, length_of_sequences):
    return train_data[index:index + length_of_sequences, 0]

train_data_path             = "../train_data/normal.npy"
num_of_input_nodes          = 1
num_of_hidden_nodes         = 2
num_of_output_nodes         = 1
length_of_sequences         = 50
num_of_training_epochs      = 2000
length_of_initial_sequences = 50
num_of_prediction_epochs    = 100
size_of_mini_batch          = 100
learning_rate               = 0.1
forget_bias                 = 1.0
print("train_data_path             = %s" % train_data_path)
print("num_of_input_nodes          = %d" % num_of_input_nodes)
print("num_of_hidden_nodes         = %d" % num_of_hidden_nodes)
print("num_of_output_nodes         = %d" % num_of_output_nodes)
print("length_of_sequences         = %d" % length_of_sequences)
print("num_of_training_epochs      = %d" % num_of_training_epochs)
print("length_of_initial_sequences = %d" % length_of_initial_sequences)
print("num_of_prediction_epochs    = %d" % num_of_prediction_epochs)
print("size_of_mini_batch          = %d" % size_of_mini_batch)
print("learning_rate               = %f" % learning_rate)
print("forget_bias                 = %f" % forget_bias)

train_data = np.load(train_data_path)
print("train_data:", train_data)

#Fixez la graine de nombre aléatoire.
random.seed(0)
np.random.seed(0)
tf.set_random_seed(0)

optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)

with tf.Graph().as_default():
    input_ph      = tf.placeholder(tf.float32, [None, length_of_sequences, num_of_input_nodes], name="input")
    supervisor_ph = tf.placeholder(tf.float32, [None, num_of_output_nodes], name="supervisor")
    istate_ph     = tf.placeholder(tf.float32, [None, num_of_hidden_nodes * 2], name="istate") #Nécessite deux valeurs par cellule.

    with tf.name_scope("inference") as scope:
        weight1_var = tf.Variable(tf.truncated_normal([num_of_input_nodes, num_of_hidden_nodes], stddev=0.1), name="weight1")
        weight2_var = tf.Variable(tf.truncated_normal([num_of_hidden_nodes, num_of_output_nodes], stddev=0.1), name="weight2")
        bias1_var   = tf.Variable(tf.truncated_normal([num_of_hidden_nodes], stddev=0.1), name="bias1")
        bias2_var   = tf.Variable(tf.truncated_normal([num_of_output_nodes], stddev=0.1), name="bias2")

        in1 = tf.transpose(input_ph, [1, 0, 2])         # (batch, sequence, data) -> (sequence, batch, data)
        in2 = tf.reshape(in1, [-1, num_of_input_nodes]) # (sequence, batch, data) -> (sequence * batch, data)
        in3 = tf.matmul(in2, weight1_var) + bias1_var
        in4 = tf.split(0, length_of_sequences, in3)     # sequence * (batch, data)

        cell = rnn_cell.BasicLSTMCell(num_of_hidden_nodes, forget_bias=forget_bias)
        rnn_output, states_op = rnn.rnn(cell, in4, initial_state=istate_ph)
        output_op = tf.matmul(rnn_output[-1], weight2_var) + bias2_var

    with tf.name_scope("loss") as scope:
        square_error = tf.reduce_mean(tf.square(output_op - supervisor_ph))
        loss_op      = square_error
        tf.scalar_summary("loss", loss_op)

    with tf.name_scope("training") as scope:
        training_op = optimizer.minimize(loss_op)

    summary_op = tf.merge_all_summaries()
    init = tf.initialize_all_variables()

    with tf.Session() as sess:
        saver = tf.train.Saver()
        summary_writer = tf.train.SummaryWriter("data", graph=sess.graph)
        sess.run(init)

        for epoch in range(num_of_training_epochs):
            inputs, supervisors = make_mini_batch(train_data, size_of_mini_batch, length_of_sequences)

            train_dict = {
                input_ph:      inputs,
                supervisor_ph: supervisors,
                istate_ph:     np.zeros((size_of_mini_batch, num_of_hidden_nodes * 2)),
            }
            sess.run(training_op, feed_dict=train_dict)

            if (epoch + 1) % 10 == 0:
                summary_str, train_loss = sess.run([summary_op, loss_op], feed_dict=train_dict)
                summary_writer.add_summary(summary_str, epoch)
                print("train#%d, train loss: %e" % (epoch + 1, train_loss))

        inputs  = make_prediction_initial(train_data, 0, length_of_initial_sequences)
        outputs = np.empty(0)
        states  = np.zeros((num_of_hidden_nodes * 2)),

        print("initial:", inputs)
        np.save("initial.npy", inputs)

        for epoch in range(num_of_prediction_epochs):
            pred_dict = {
                input_ph:  inputs.reshape((1, length_of_sequences, 1)),
                istate_ph: states,
            }
            output, states = sess.run([output_op, states_op], feed_dict=pred_dict)
            print("prediction#%d, output: %f" % (epoch + 1, output))

            inputs  = np.delete(inputs, 0)
            inputs  = np.append(inputs, output)
            outputs = np.append(outputs, output)

        print("outputs:", outputs)
        np.save("output.npy", outputs)

        saver.save(sess, "data/model")