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

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.

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

Recommended Posts

Prédiction de l'onde de péché avec keras
4/22 prédiction de l'onde de péché avec keras
Prédiction des ondes de Sin (retour) avec Pytorch
Prédiction de la moyenne Nikkei avec Pytorch 2
Prédiction de la moyenne Nikkei avec Pytorch
Prédiction des ondes sinusoïdales à l'aide de RNN dans la bibliothèque d'apprentissage en profondeur Keras
Prédiction de la moyenne Nikkei avec Pytorch ~ Makuma ~
Garantie de reproductibilité avec les keras (à partir du 22 septembre 2020)
Reconnaissance faciale des personnages d'anime avec Keras
Résumé de Tensorflow / Keras
Reconnaissance d'image avec keras
Créez le moteur de prédiction Keras AI en 1 heure avec GCP
Tutoriel CIFAR-10 avec Keras
Bilan du premier défi du machine learning avec Keras
LSTM multivarié avec Keras
J'ai essayé la reconnaissance de caractères manuscrits des caractères runiques avec CNN en utilisant Keras
Installation de Keras (utilisée par Anaconda)
Analyse de régression multiple avec Keras
Equation de mouvement avec sympy
Génération de phrases avec GRU (keras)
Réglage des paramètres Keras avec Keras Tuner
Traitement parallèle avec Parallel de scikit-learn
Créez facilement des CNN avec Keras
Souvenirs de combats avec Selenium
Implémentation d'un GAN efficace avec keras
[Keras] inférence par lots d'arcface
Reconnaissance d'image avec Keras + OpenCV
Prédiction de probabilité de données déséquilibrées
J'ai fait apprendre à RNN l'onde de péché et j'ai essayé de prédire: l'ajustement des paramètres hyper