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

#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
#Array-Länge
length_of_sequences = 100　
#Neuron
in_out_neurons = 1
#Versteckte Ebene
hidden_neurons = 300

Zufälliger Koeffizient

Fester Startwert der Zufallszahl

random.seed(0)

Der Startwert ist die eingestellte Nummer. 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

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

Erstellen Sie einen Datenrahmen mit dem Spaltennamen (Spaltenname) t. Da ich hier Zellen für die Anzahl der Schritte erstellen möchte, kann ich 4000 Daten erhalten, indem ich die Anzahl der Schritte pro Zyklus mit der Anzahl der Zyklen multipliziere. Da die Zeile des Datenrahmens jedoch bei 0 beginnt, addiere am Ende +1. Durch Erhöhen wird die Anzahl der Zellen 4001 betragen, aber der Name der letzten Zeile wird genau 4000 sein. 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.


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

Sie können den Spaltennamen angeben, ohne ihn zuvor zu erstellen, indem Sie ihn als df [""] angeben. Geben Sie dann in diese Spalte den Wert von sin ein, der der Zeile der Anzahl der zuvor erstellten Schritte entspricht.

"Df.t.apply ()" bedeutet "Geben Sie jede Zelle der Spalte" t "in den Datenrahmen in () ein".
"Lamb x:" bedeutet "Definieren von x, 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_t"].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 Trainingsdaten

Erstellung von Trainingsdaten

def _load_data(data, n_prev = 100):  
    #Erstellen Sie eine leere Liste
    docX, docY = [], []
    #Von 0(len(data)-n_prev)Ist ein Array von nur ganzen Zahlen
    for i in range(len(data)-n_prev):#Für 3501 Daten
        #Vom i zum i im doc-Array+Setzen Sie die 100. Daten in Form einer Matrix
        docX.append(data.iloc[i:i+n_prev].as_matrix())#3501~3601
        docY.append(data.iloc[i+n_prev].as_matrix())
    #Definieren Sie die Matrix in ihrer Form neu, damit sie von numpy verarbeitet werden kann
    alsX = np.array(docX)
    alsY = np.array(docY)
    return alsX, alsY

Datenargument 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 Testdaten

Trainingsdaten und Testdaten trennen

def train_test_split(df, test_size=0.1, n_prev = 100):  
    ntrn = round(len(df) * (1 - test_size))#360 1 Stück
    ntrn = int(ntrn)
　　　　　　　　#Trainingsdaten sind 0 bis 3601
    X_train, y_train = _load_data(df.iloc[0:ntrn], n_prev)
    #Testdaten sind 3601 ~
　　　　　　　　X_test, y_test = _load_data(df.iloc[ntrn:], n_prev)
    return (X_train, y_train), (X_test, y_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.

(X_train, y_train), (X_test, y_test) = train_test_split(df[["sin_t"]], n_prev =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))
#Wenn Sie Keine sagen, können Sie die Stapelgröße anhand einer beliebigen Zahl festlegen, ohne einen Wert festzulegen.
#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(X_train, y_train, batch_size=60, nb_epoch=3, validation_split=0.05)
b

X_train und y_train sind die zuvor erstellten Daten. batch_size = 60 ist die Anzahl der Proben pro Satz und nb_epoch = 3 ist die Häufigkeit, mit der die Trainingsdaten verbraucht werden. Trainings- und Validierungsdaten sind ebenfalls für die Anpassung erforderlich, und Validierungssplit = 0,05 wird als 0,05 (5%) aller Daten für die Validierung behandelt.

Ergebnisse anzeigen

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

[PYTHON] Vorhersage der Sinuswelle mit Keras