introduction

import pandas as pd
import numpy as np
import math
import random
from keras.models import Sequential  
from keras.layers.core import Dense, Activation  
from keras.layers.recurrent import LSTM
import matplotlib.pyplot as plt

Définition des paramètres

#Coefficient aléatoire
random_factor = 0.05
#Nombre d'étapes par cycle
steps_per_cycle = 80
#Nombre de cycles à générer
number_of_cycles = 50
#Longueur du tableau
length_of_sequences = 100　
#Neurone
in_out_neurons = 1
#Couche cachée
hidden_neurons = 300

Coefficient aléatoire

Valeur de départ fixe du nombre aléatoire

random.seed(0)

La valeur de départ est le nombre défini. S'il est 0, le 0e nombre aléatoire est généré, et s'il est 100, le 100e nombre aléatoire est généré.

Explication des pandas

Créez une boîte (cellule) pour stocker chaque valeur de sin de 0 à 4000

df = pd.DataFrame(np.arange(steps_per_cycle * number_of_cycles +1), columns=["t"])

Créez un bloc de données avec le nom de la colonne (nom de la colonne) t. Puisque je veux créer des cellules pour le nombre d'étapes ici, je peux obtenir 4000 données en multipliant le nombre d'étapes par cycle par le nombre de cycles, mais comme la ligne de la trame de données commence à 0, ajoutez +1 à la fin. En l'augmentant, le nombre de cellules sera de 4001, mais le nom de la dernière ligne sera exactement de 4000. np.arange () est une fonction qui génère des entiers de 0 au nombre de contenus de () au format numpy.

Ensuite, entrez les données en fonction du nombre d'étapes de péché dans la case (cellule) du bloc de données créé.


df["sin_t"] = df.t.apply(lambda x: math.sin(x * (2 * math.pi / steps_per_cycle)+ random.uniform(-1.0, +1.0) * random_factor))

Vous pouvez spécifier le nom de la colonne sans le créer à l'avance en le donnant comme df [""]. Ensuite, dans cette colonne, entrez la valeur de sin correspondant à la ligne du nombre d'étapes créées précédemment.

"Df.t.apply ()" signifie "entrez chaque cellule de la colonne" t "dans le bloc de données entre ()".
"Lamb x:" signifie "définir x à partir de laquelle vous voulez entrer:". En d'autres termes, lorsque ces deux sont combinés, cela signifie "entrez chaque cellule de la colonne" t "dans x". Ces valeurs et autres bruits sont inclus dans θ de sinθ. random.uniform (A, B) génère des nombres aléatoires de A à B, y compris la virgule décimale. En multipliant par random_factor, vous pouvez ajuster son influence, c'est-à-dire la magnitude du bruit.

Exportez le bloc de données créé dans un graphique

df["sin_t"].head(steps_per_cycle * 2).plot()
plt.show()

df.head () est une fonction permettant d'obtenir la valeur de la cellule uniquement pour la valeur entre (). Ici, "le nombre d'étapes par cycle" x 2 et les données d'onde sinusoïdale pour 2 cycles de péché sont acquises. Représentez graphiquement la valeur avec .plot (). Cependant, plt.show () est nécessaire pour afficher le graphique à l'écran.

Explication des données d'entraînement

Création de données d'entraînement

def _load_data(data, n_prev = 100):  
    #Créer une liste vide
    docX, docY = [], []
    #À partir de 0(len(data)-n_prev)Est un tableau de seulement entiers
    for i in range(len(data)-n_prev):#Pour 3501 données
        #Du i au i dans le tableau doc+Mettez les 100e données sous forme de matrice
        docX.append(data.iloc[i:i+n_prev].as_matrix())#3501~3601
        docY.append(data.iloc[i+n_prev].as_matrix())
    #Redéfinissez la matrice sous sa forme pour qu'elle puisse être manipulée par numpy
    alsX = np.array(docX)
    alsY = np.array(docY)
    return alsX, alsY

argument de données Entrez chaque donnée de matrice au format numpy dans la liste vide préparée. Ici, as_matrix () est utilisé pour convertir le format de données en une matrice numpy.

Explication des données de test

Séparez les données d'entraînement et les données de test

def train_test_split(df, test_size=0.1, n_prev = 100):  
    ntrn = round(len(df) * (1 - test_size))#360 1 pièce
    ntrn = int(ntrn)
　　　　　　　　#Les données d'entraînement sont comprises entre 0 et 3601
    X_train, y_train = _load_data(df.iloc[0:ntrn], n_prev)
    #Les données de test sont 3601 ~
　　　　　　　　X_test, y_test = _load_data(df.iloc[ntrn:], n_prev)
    return (X_train, y_train), (X_test, y_test)

round () est une fonction qui arrondit la valeur entre () après la virgule décimale. Obtenez le nombre de lignes df avec len (). "Test_size = 0.1" signifie mettre de côté 10% des données de test, donc "1 --test_size" signifie 90%. Depuis 90% de 4001 pièces, les données d'entraînement sont arrondies à 3601 pièces. D'autre part, les données de test signifient de 3601 à la fin.

(X_train, y_train), (X_test, y_test) = train_test_split(df[["sin_t"]], n_prev =length_of_sequences)

Ajouter un modèle

model = Sequential()  #la magie
model.add(LSTM(hidden_neurons, batch_input_shape=(None, length_of_sequences, in_out_neurons), return_sequences=False))
#En disant Aucun, vous pouvez décider de la taille du lot par n'importe quel nombre sans définir de valeur.
#Liste de 100 avec une entrée
#in_out_neurones est le nombre de sorties
  
#Une sortie pour le nombre de valeurs d'entrée
model.add(Dense(in_out_neurons)) 
#Fonction d'activation linéaire
model.add(Activation("linear"))
#compiler
model.compile(loss="mean_squared_error", optimizer="rmsprop")

model.fit(X_train, y_train, batch_size=60, nb_epoch=3, validation_split=0.05)
b

X_train et y_train sont les données créées précédemment. batch_size = 60 est le nombre d'échantillons par jeu et nb_epoch = 3 est le nombre de fois où les données d'apprentissage sont utilisées. Les données de formation et de validation sont également requises dans l'ajustement, et validation_split = 0,05 est traité comme 0,05 (5%) de toutes les données pour la validation.

Voir les résultats

dataf =  pd.DataFrame(predicted[:200])
dataf.columns = ["predict"]
dataf["input"] = y_test[:200]
#dataf.plot(figsize=(15, 5))
print(str(dataf))
dataf.plot()
plt.show()

Prédiction de l'onde de péché avec keras