Einführung

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

Parameterdefinition

random.seed(0)
#Zufälliger Koeffizient
random_factor = 0.05
#Anzahl der Schritte pro Zyklus
steps_per_cycle = 80
#Anzahl der zu generierenden Zyklen
number_of_cycles = 50
#Eingabelänge
length_of_sequences = 100
#Maßgröße des Eingabewerts / Ausgabewerts
in_out_neurons = 1
#Anzahl der Neuronen mit versteckten Elementen
hidden_neurons = 300

Zufällige Einstellung

Fester Startwert der Zufallszahl

random.seed(0)

Der Startwert ist die Nummer des Satzes. Wenn es 0 ist, wird die 0. Zufallszahl erzeugt, und wenn es 100 ist, wird die 100. Zufallszahl erzeugt.

Erklärung der Pandas

Erstellen Sie eine Box (Zelle), um jeden Wert von sin von 0 bis 4000 zu speichern

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

Erstellen Sie einen Datenrahmen mit dem Spaltennamen (Spaltenname) "x". Da wir hier Zellen für die Anzahl der Schritte erstellen möchten, können wir 4000 Daten erstellen, indem wir die Anzahl der Schritte pro Zyklus mit der Anzahl der Zyklen multiplizieren. Da die Zeile des Datenrahmens bei 0 beginnt, beträgt die Anzahl der Zellen 4001, indem am Ende +1 hinzugefügt wird. Der letzte Zeilenname lautet jedoch 4000. np.arange () ist eine Funktion, die Ganzzahlen von 0 bis zur Anzahl der Inhalte von () im Numpy-Format generiert.

Geben Sie als Nächstes die Daten entsprechend der Anzahl der Sin-Schritte in das Feld (die Zelle) des erstellten Datenrahmens ein.

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 ist der Wert des Kreises geteilt durch step_per_cycle. Die Pandas-Spalte kann als df [""] angegeben werden, ohne sie zuvor zu erstellen. Geben Sie in die Spalte den Wert von sin ein, der der Zeile der Anzahl der zuvor erstellten Schritte entspricht.

"Df.x.apply ()" bedeutet "Geben Sie jede Zelle der Spalte" x "in den Datenrahmen in () ein".
"Lamb t:" bedeutet "Definition von t, von dem aus Sie eingeben möchten:".

Mit anderen Worten, wenn diese beiden kombiniert werden, bedeutet dies "jede Zelle der Spalte" t "in x eingeben". Diese Werte und andere Geräusche sind in θ von sinθ enthalten. random.uniform (A, B) erzeugt Zufallszahlen von A nach B einschließlich des Dezimalpunkts. Durch Multiplizieren mit random_factor können Sie dessen Einfluss, dh die Größe des Rauschens, anpassen.

Geben Sie den erstellten Datenrahmen in ein Diagramm aus

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

df.head () ist eine Funktion, um den Zellenwert nur für den Wert in () abzurufen. Hier werden "die Anzahl der Schritte pro Zyklus" x 2 und Sinuswellendaten für 2 Sinuszyklen erfasst. Stellen Sie den Wert mit .plot () grafisch dar. Plt.show () ist jedoch erforderlich, um das Diagramm auf dem Display anzuzeigen.

Erklärung der korrekten Antwortdaten

Richtige Antwortdaten erstellen

def Input_Ans_Extract(data, input_num = 100): 
    #Erstellen Sie eine leere Liste
    InputList, AnsList = [], []
    #Von 0(len(data)- input_num)Ist ein Array von nur ganzen Zahlen
    for i in range(len(data) - input_num):#Für 3501 Daten
        #Vom i zum i im doc-Array+Setzen Sie die 100. Daten in Form einer Matrix
        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)
    #Definieren Sie die Matrix in ihrer Form neu, damit sie von numpy verarbeitet werden kann
    InputList_np = np.array(InputList)
    AnsList_np = np.array(AnsList)
    return InputList_np, AnsList_np

Geben Sie alle Matrixdaten im Numpy-Format in die vorbereitete leere Liste ein. Hier wird as_matrix () verwendet, um das Datenformat in eine Numpy-Matrix zu konvertieren.

Erläuterung der Trainingsdaten und Testdaten

Trainingsdaten und Testdaten trennen

def Data_Split(df, test_size=0.1, input_num = 100):    
    train_size = round(len(df) * (1 - test_size))#360 1 Stück
    train_size = int(train_size)#Trainingsdaten sind 0-3601
    Input_train, Ans_train = Input_Ans_Extract(df.iloc[0:train_size], input_num)
    #Testdaten sind 3601 ~
    Input_test, Ans_test = Input_Ans_Extract(df.iloc[train_size:], input_num)
    return (Input_train, Ans_train), (Input_test, Ans_test)

round () ist eine Funktion, die den Wert in () nach dem Dezimalpunkt rundet. Ermitteln Sie die Anzahl der df-Zeilen mit len (). "Test_size = 0.1" bedeutet, 10% der Testdaten beiseite zu legen, "1 --test_size" bedeutet also 90%. Da 90% von 4001 Stück sind, werden die Trainingsdaten auf 3601 Stück gerundet. Andererseits bedeuten die Testdaten von 3601 bis zum Ende.

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

Modell hinzufügen

model = Sequential()  #Magie
model.add(LSTM(hidden_neurons, batch_input_shape=(None, length_of_sequences, in_out_neurons), return_sequences=False))
#Durch Festlegen von Keine können Sie die Stapelgröße anhand einer beliebigen Zahl bestimmen, ohne einen Wert anzugeben.
#Liste von 100 mit einem Eingang
#in_out_Neuronen ist die Anzahl der Ausgänge
  
#Ein Ausgang für die Anzahl der Eingabewerte
model.add(Dense(in_out_neurons)) 
#Aktivierungsfunktion linear
model.add(Activation("linear"))
#kompilieren
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 = (Stapelgröße = Anzahl der Sätze von Eingabedaten, Anzahl der Daten, die in die Zwischenschicht eingegeben werden sollen, Anzahl der Dimensionen, die in die Zwischenschicht eingegeben werden sollen) mean_squared_error ist die umgekehrte Fehlernummerierungsmethode. rmsprop ist eine Art Gradientenmethode. X_train und y_train sind die zuvor erstellten Daten. batch_size = 60 ist die Anzahl der Proben pro Satz, dh 60 Datensätze pro Training. nb_epoch = 3 gibt an, wie oft die Trainingsdaten aufgebraucht sind. Trainings- und Validierungsdaten sind ebenfalls für die Anpassung erforderlich, und validation_split = 0,05 wird als 0,05 (5%) aller Daten für die Validierung behandelt.

#Teil gespeichert

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



#Teil lesen

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

predicted = model.predict(Input_test)


#Ergebnisse anzeigen

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

#Ganzer Code

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)

Zufälliger Koeffizient

random_factor = 0.05

Anzahl der Schritte pro Zyklus

steps_per_cycle = 80

Anzahl der zu generierenden Zyklen

number_of_cycles = 50

Eingabelänge

length_of_sequences = 100

Maßgröße des Eingabewerts / Ausgabewerts

in_out_neurons = 1

Anzahl der Neuronen mit versteckten Elementen

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)