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

random.seed(0)
#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 d'entrée
length_of_sequences = 100
#Taille dimensionnelle de la valeur d'entrée / valeur de sortie
in_out_neurons = 1
#Nombre de neurones à éléments cachés
hidden_neurons = 300

Réglage d'ensemble aléatoire

Valeur de départ fixe d'un nombre aléatoire

random.seed(0)

La valeur de départ est le numéro de l'ensemble. S'il vaut 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

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

Créez un bloc de données avec un nom de colonne (nom de colonne) de "x". Puisque nous voulons créer des cellules pour le nombre d'étapes ici, nous pouvons créer 4000 données en multipliant le nombre d'étapes par cycle par le nombre de cycles. Puisque la ligne de la trame de données commence à 0, le nombre de cellules sera 4001 en ajoutant +1 à la fin, mais le nom de la dernière ligne sera 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éé.

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

pi_t est la valeur du cercle divisée par steps_per_cycle. La colonne pandas peut être spécifiée comme df [""] sans la créer à l'avance. Dans la colonne, entrez la valeur de sin correspondant à la ligne du nombre d'étapes créées précédemment.

"Df.x.apply ()" signifie "entrez chaque cellule de la colonne" x "dans le bloc de données entre ()".
"Lamb t:" signifie "définir t à partir duquel 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(x)"]].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 de réponse correcte

Créer des données de réponse correctes

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

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 d'entraînement et des données de test

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

def Data_Split(df, test_size=0.1, input_num = 100):    
    train_size = round(len(df) * (1 - test_size))#360 1 pièce
    train_size = int(train_size)#Les données d'entraînement sont 0-3601
    Input_train, Ans_train = Input_Ans_Extract(df.iloc[0:train_size], input_num)
    #Les données de test sont 3601 ~
    Input_test, Ans_test = Input_Ans_Extract(df.iloc[train_size:], input_num)
    return (Input_train, Ans_train), (Input_test, Ans_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.

(Input_train, Ans_train), (Input_test, Ans_test) = Data_Split(df[["sin(x)"]], input_num = 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 définissant Aucun, vous pouvez déterminer la taille du lot par n'importe quel nombre sans spécifier 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(Input_train, Ans_train, batch_size=60, nb_epoch=3, validation_split=0.05) 
predicted = model.predict(Input_test)

batch_input_shape = (taille du lot = nombre d'ensembles de données d'entrée, nombre de données à entrer dans la couche intermédiaire, nombre de dimensions à entrer dans la couche intermédiaire) mean_squared_error est la méthode de numérotation d'erreur inverse. rmsprop est un type de méthode de gradient. X_train et y_train sont les données créées précédemment. batch_size = 60 est le nombre d'échantillons par ensemble, ce qui signifie 60 ensembles de données par entraînement. nb_epoch = 3 représente le nombre de fois où les données d'apprentissage sont utilisées. Les données d'entraînement 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.

#Partie enregistrée

json_string = model.to_json() open('model.json', 'w').write(json_string) model.save_weights('weights.hdf5')



#Partie lecture

from keras.models import model_from_json modelname = input ("model file =" model.json "") paramname = input ("learning file =" weights.hdf5 "") json_string = open(modelname).read() model = model_from_json(json_string) model.load_weights(paramname)

predicted = model.predict(Input_test)


#Voir les résultats

dataf = pd.DataFrame(predicted[:200]) dataf.columns = ["predict"] dataf.plot() dataf["answer"] = Ans_test[:200] dataf.plot() plt.show()

#Code entier

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 % matplotlib inline import matplotlib.pyplot as plt

random.seed(0)

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 d'entrée

length_of_sequences = 100

Taille dimensionnelle de la valeur d'entrée / valeur de sortie

in_out_neurons = 1

Nombre de neurones à éléments cachés

hidden_neurons = 300

np_ary = np.arange(steps_per_cycle * number_of_cycles + 1); df = pd.DataFrame(np_ary, columns=["x"]) pi_t = 2 * math.pi / steps_per_cycle df["sin(x)"] = df.x.apply(lambda t: math.sin(t * pi_t + random.uniform(-1.0, +1.0) * random_factor)) df[["sin(x)"]].head(steps_per_cycle * 2).plot()

def Input_Ans_Extract(data, input_num = 100): InputList, AnsList = [], [] for i in range(len(data) - input_num): InputData = data.iloc[i:i+input_num].as_matrix() AnsData = data.iloc[i+input_num].as_matrix() InputList.append(InputData) AnsList.append(AnsData) InputList_np = np.array(InputList) AnsList_np = np.array(AnsList) return InputList_np, AnsList_np

def Data_Split(df, test_size=0.1, input_num = 100): train_size = round(len(df) * (1 - test_size)) train_size = int(train_size) Input_train, Ans_train = Input_Ans_Extract(df.iloc[0:train_size], input_num) Input_test, Ans_test = Input_Ans_Extract(df.iloc[train_size:], input_num) return (Input_train, Ans_train), (Input_test, Ans_test)

(Input_train, Ans_train), (Input_test, Ans_test) = Data_Split(df[["sin(x)"]], input_num = length_of_sequences)

model = Sequential()
model.add(LSTM(hidden_neurons, batch_input_shape=(None, length_of_sequences, in_out_neurons), return_sequences=False))
model.add(Dense(in_out_neurons))
model.add(Activation("linear"))
model.compile(loss="mean_squared_error", optimizer="rmsprop") model.fit(Input_train, Ans_train, batch_size=60, nb_epoch=3, validation_split=0.05)