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

0. En gros

*** 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.

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

train_data_normal.png

2.2. Bruyant

train_data/noised.ipynb

train_data_noised.png

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.

Nom de variable sens valeur
num_of_input_nodes Nombre de nœuds dans la couche d'entrée 1 nœud
num_of_hidden_nodes Nombre de nœuds de couche masqués 2 nœuds
num_of_output_nodes Nombre de nœuds dans la couche de sortie 1 nœud
length_of_sequences Longueur de séquence RNN 50 étapes
num_of_training_epochs Nombre de répétitions d'apprentissage 2,000 fois
length_of_initial_sequences Longueur de séquence des données initiales 50 étapes
num_of_prediction_epochs Nombre de répétitions de la prédiction 100 fois
size_of_mini_batch Nombre d'échantillons par mini-lot 100 échantillons
learning_rate Taux d'apprentissage 0.1
forget_bias (Je ne suis pas sûr) 1.0 (valeur par défaut)

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.

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.

output_normal.png

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.

output_noised.png

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.

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

Recommended Posts

J'ai fait apprendre à RNN la vague de péché et j'ai essayé de prédire
J'ai essayé d'entraîner la fonction péché avec chainer
J'ai essayé d'apprendre PredNet
J'ai essayé de prédire le match de la J League (analyse des données)
J'ai essayé de prédire la présence ou l'absence de neige par apprentissage automatique.
J'ai essayé de prédire l'évolution de la quantité de neige pendant 2 ans par apprentissage automatique
J'ai essayé de déplacer le ballon
J'ai essayé d'estimer la section.
J'ai essayé de résumer les langues que les débutants devraient désormais apprendre par but
J'ai essayé de prédire les ventes de logiciels de jeux avec VARISTA en me référant à l'article du Codexa
J'ai essayé de visualiser l'ensemble de données de préférence de boisson par décomposition tenseur.
J'ai fait apprendre à RNN l'onde de péché et j'ai essayé de prédire: l'ajustement des paramètres hyper
J'ai essayé de résoudre le problème de planification des équipes par diverses méthodes
J'ai essayé de résumer la commande umask
J'ai essayé de reconnaître le mot de réveil
J'ai essayé de résumer la modélisation graphique.
J'ai essayé d'estimer le rapport de circonférence π de manière probabiliste
J'ai essayé de toucher l'API COTOHA
J'ai essayé de déplacer l'image vers le dossier spécifié en faisant un clic droit et un clic gauche
J'ai essayé de résumer moi-même le flux général jusqu'à la création de services.
765 J'ai essayé d'identifier les trois familles professionnelles par CNN (avec Chainer 2.0.0)
J'ai essayé de trouver l'itinéraire optimal du pays des rêves par recuit (quantique)
J'ai essayé de vérifier et d'analyser l'accélération de Python par Cython
J'ai essayé de résumer les commandes Linux utilisées par les ingénieurs débutants aujourd'hui - Partie 1-
J'ai essayé l'histoire courante de l'utilisation du Deep Learning pour prédire la moyenne Nikkei
J'ai essayé de vérifier le résultat du test A / B avec le test du chi carré
J'ai essayé de prédire le comportement du nouveau virus corona avec le modèle SEIR.
J'ai essayé d'analyser la carte du Nouvel An par moi-même en utilisant python
J'ai essayé de prédire l'année prochaine avec l'IA
J'ai essayé de programmer la bulle de tri par langue
J'ai essayé Web Scraping pour analyser les paroles.
J'ai essayé d'apprendre le fonctionnement logique avec TF Learn
J'ai essayé d'optimiser le séchage du linge
J'ai essayé d'obtenir une image en grattant
J'ai essayé de sauvegarder les données avec discorde
J'ai essayé de laisser VAE apprendre les animations
J'ai essayé de corriger la forme trapézoïdale de l'image
Qiita Job J'ai essayé d'analyser le travail
LeetCode j'ai essayé de résumer les plus simples
J'ai essayé de classer les boules de dragon par adaline
J'ai essayé de mettre en œuvre le problème du voyageur de commerce
J'ai essayé de vectoriser les paroles de Hinatazaka 46!
J'ai essayé de prédire la détérioration de la batterie lithium-ion en utilisant le SDK Qore
J'ai essayé de prédire les chevaux qui seront dans le top 3 avec LightGBM
J'ai essayé de récupérer les données de l'ordinateur portable en le démarrant sur Ubuntu
J'ai essayé de passer le test G et la qualification E en m'entraînant à partir de 50
J'ai essayé de prédire le nombre de personnes infectées par le virus corona au Japon par la méthode du dernier article en Chine
J'ai essayé de représenter graphiquement les packages installés en Python
J'ai essayé de prédire la victoire ou la défaite de la Premier League en utilisant le SDK Qore
J'ai essayé de détecter l'iris à partir de l'image de la caméra
J'ai essayé d'implémenter et d'apprendre DCGAN avec PyTorch
J'ai essayé de résumer la forme de base de GPLVM
[Première science des données ⑤] J'ai essayé d'aider mon ami à trouver la première propriété par analyse de données
J'ai essayé de toucher un fichier CSV avec Python
J'ai essayé de prédire les courses de chevaux en faisant tout, de la collecte de données à l'apprentissage en profondeur
J'ai essayé de résoudre Soma Cube avec python
J'ai essayé de déboguer.