[PYTHON] Spielen wir mit Amedas Daten - Teil 3

Dies ist eine Fortsetzung des vorherigen Artikels (https://qiita.com/tubarin/items/cd70989f3e1f387a90a8).

Aus den Amedas-Daten konnte ich vorerst so etwas wie eine Regressionsanalyse mit meinem eigenen neuronalen Netz durchführen. Dieses Mal werde ich das gleiche mit Keras versuchen. Dieser Artikel ist wie ein Memo der Ergebnisse des Studiums von Keras.

Das erste, was ich tat, war Keras zu installieren. Die Versionen passten nicht und ich hatte einen Fehler, aber es funktionierte. Schließlich funktioniert es mit den folgenden Versionen.

python:3.6.19 tensorflow:1.14.0 keras:2.2.0

Dann untersuchte ich verschiedene Verwendungen und erstellte einen Code mit Keras. Ich habe ein Objekt namens Sequential verwendet. Die offizielle Website von hier erläutert die detaillierten Spezifikationen, scheint jedoch nützlich zu sein.

Und ich habe auf den folgenden Artikel verwiesen, um zu erfahren, wie man es benutzt. Beispiel für extrem einfaches Deep Learning von Keras

Gemäß diesem Artikel können Sie ein neuronales Netzwerk mit dem folgenden einfachen Code erstellen. (Für x (1 Schicht) -> 32 Schichten -> y (1 Schicht))

from keras.models import Sequential
from keras.layers import Activation, Dense

#Machen Sie ein Modell zum Lernen
model = Sequential()
#Vollständig verbundene Schicht(1 Schicht->32 Schichten)
model.add(Dense(input_dim=1, output_dim=32, bias=True))
#Aktivierungsfunktion(Sigmoidfunktion)
model.add(Activation("sigmoid"))

#Vollständig verbundene Schicht(32 Schichten->1 Schicht)
model.add(Dense(output_dim=1))
#Kompilieren Sie das Modell
model.compile(loss="mean_squared_error", optimizer="sgd", metrics=["accuracy"])
#Führen Sie das Lernen durch
model.fit(x, y, nb_epoch=1000, batch_size=32)

Ist das alles! ?? Wunderbar. Wenn Sie das Modell des neuronalen Netzes ein wenig definieren und es dann kompilieren, scheint es, dass die Initialisierung verschiedener Parameter und des Lernprogramms ohne Erlaubnis definiert wird. Und es schien zu lernen, indem man Trainingsdaten (Eingabe und richtige Antwort) in die Anpassungsmethode einfügte.

Schauen wir uns also die für Amedas Datenanalyse an. Ich werde vorerst den ganzen Code einfügen, es ist nutzlos lang ...

import pandas as pd
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

from keras.models import Sequential
from keras.layers import Activation, Dense


# deta making???
csv_input = pd.read_csv(filepath_or_buffer="data_out.csv",
                        encoding="ms932",
                        sep=",")

#Anzahl der Eingabeelemente (Anzahl der Zeilen)*Die Anzahl der Spalten) wird zurückgegeben.
print(csv_input.size)

#Gibt das DataFrame-Objekt zurück, das nur für die angegebene Spalte extrahiert wurde.
x = np.array(csv_input[["hour"]])
y = np.array(csv_input[["wind"]])

# num of records
N = len(x)

#Normalisierung
x_max = np.max(x,axis=0)
x_min = np.min(x,axis=0)
y_max = np.max(y,axis=0)
y_min = np.min(y,axis=0)
x = (x - np.min(x,axis=0))/(np.max(x,axis=0) - np.min(x,axis=0))
y = (y - np.min(y,axis=0))/(np.max(y,axis=0) - np.min(y,axis=0))

#Machen Sie ein Modell zum Lernen
model = Sequential()
#Vollständig verbundene Schicht(1 Schicht->XXX Schicht)
model.add(Dense(input_dim=1, output_dim=32, bias=True))
#Aktivierungsfunktion(Sigmoidfunktion)
model.add(Activation("sigmoid"))

#Vollständig verbundene Schicht(XXX Schicht->1 Schicht)
model.add(Dense(output_dim=1))
#Kompilieren Sie das Modell
model.compile(loss="mean_squared_error", optimizer="sgd", metrics=["accuracy"])
#Führen Sie das Lernen durch
model.fit(x, y, nb_epoch=1000, batch_size=32)

#True Value Plot
plt.plot(x,y,marker='x',label="true")
#Berechnen Sie die Keras-Ergebnisse mit Inferenz,Anzeige
y_predict = model.predict(x)
#Keras Berechnungsergebnisplot
plt.plot(x,y_predict,marker='x',label="predict")
#Legendenanzeige
plt.legend()

Wenn man sich die Ergebnisse auf der Konsole ansieht, sind die Fortschritte gut.

(Unterlassung)
23/23 [==============================] - 0s 0us/step - loss: 0.0563 - acc: 0.0435
Epoch 994/1000
23/23 [==============================] - 0s 435us/step - loss: 0.0563 - acc: 0.0435
Epoch 995/1000
23/23 [==============================] - 0s 0us/step - loss: 0.0563 - acc: 0.0435
Epoch 996/1000
23/23 [==============================] - 0s 0us/step - loss: 0.0563 - acc: 0.0435
Epoch 997/1000
23/23 [==============================] - 0s 0us/step - loss: 0.0563 - acc: 0.0435
Epoch 998/1000
23/23 [==============================] - 0s 0us/step - loss: 0.0563 - acc: 0.0435
Epoch 999/1000
23/23 [==============================] - 0s 0us/step - loss: 0.0563 - acc: 0.0435
Epoch 1000/1000
23/23 [==============================] - 0s 435us/step - loss: 0.0563 - acc: 0.0435

Es scheint, dass es gut funktioniert, aber wenn Sie sich das resultierende Diagramm ansehen, ???

Hmmm, ich habe mich wie zuvor auf eine bloße Näherungskurve festgelegt. Ich habe verschiedene Dinge ausprobiert, wie zum Beispiel mit der Anzahl der mittleren Schichten zu spielen, aber es gab keine große Veränderung. Bei Betrachtung der vorherigen Ergebnisse schien es, dass wir etwas mehr fangen könnten, wenn wir die Anfangswerte der Koeffizienten im neuronalen Netzwerk gut einstellen könnten. Daher habe ich eine Klasse zum Festlegen des Anfangswertes des neuronalen Netzwerks entworfen. Der Koeffizientenberechnungsteil verwendet den vorherigen (weitere Kommentare usw.) Es ist so, als würde ein Schritt mit zwei Knoten in der mittleren Ebene funktionieren.

# init infomation for keras layers or models
class InitInfo:
    
    # constractor
    #  x:input y:output
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
    # calc coefficient of keras models(1st layer)
    # input  s:changing point in [0,1]
    #        sign:[1]raise,[0]down
    # return b:coefficient of bias
    #        w:coefficient of x
    # notice - it can make like step function using this return values(s,sign)
    def calc_b_w(self,s,sign):
    
        N = 1000 #Zwischenlagerung
        # s = -b/w
        if sign > 0:
            b = -N
        else:
            b = N
        if s != 0:
            w = -b/s
        else:
            w = 1
        return b,w
    
    # calc coefficient of keras models(1st and 2nd layer)
    def calc_w_h(self):
    
        K = len(self.x)
        # coefficient of 1st layer(x,w)
        w_array = np.zeros([K*2,2])
        # coefficient of 2nd layer
        h_array = np.zeros([K*2,1])
        
        w_idx = 0
        for k in range(K):
            # x[k] , y[k]
            # make one step function
            # startX : calc raise point in [0,1]
            if k > 0:
                startX = self.x[k] +  (self.x[k-1] - self.x[k])/2
            else:
                startX = 0
    
            # endX : calc down point in [0,1]
            if k < K-1:
                endX = self.x[k] + (self.x[k+1] - self.x[k])/2
            else:
                endX = 1
    
            # calc b,w
            if k > 0:
                b,w = self.calc_b_w(startX,1)
            else:
                # init???
                b = 100
                w = 1
    
            # stepfunction 1stHalf
            #            __________
            # 0 ________|
            #        
            w_array[w_idx,0] = w
            w_array[w_idx,1] = b
            h_array[w_idx,0] = self.y[k]
            w_idx += 1
            
            # stepfunction 2ndHalf
            #        
            # 0 __________
            #             |________
            b,w = self.calc_b_w(endX,1)
            w_array[w_idx,0] = w
            w_array[w_idx,1] = b
            h_array[w_idx,0] = self.y[k]*-1
            
            # shape of 1st + 2nd is under wave
            #            _
            # 0 ________| |________
            #
            
            w_idx += 1
        
        # record param
        self.w = w_array
        self.h = h_array
        self.w_init = w_array[:,0]
        self.b_init = w_array[:,1]
        self.paramN = len(h_array)
        return
    
    # for bias coefficients　setting
    def initB(self, shape, name=None):
        #L = np.prod(shape)
        #value = np.random.randn(L).reshape(shape)*5
        value = self.b_init
        value = value.reshape(shape)
        return K.variable(value, name=name)

    # for w coefficients (x) setting
    def initW(self, shape, name=None):
        #L = np.prod(shape)
        #value = np.random.random(shape)
        #value = np.random.randn(L).reshape(shape)*5
        value = self.w_init
        value = value.reshape(shape)
        return K.variable(value, name=name)
    
    # for h coefficients setting
    def initH(self, shape, name=None):
        #L = np.prod(shape)
        #value = np.random.randn(L).reshape(shape)*1
        value = self.h
        value = value.reshape(shape)
        return K.variable(value, name=name)

initB(self, shape, name=None): initW(self, shape, name=None): initH(self, shape, name=None): Die drei Methoden von sollen in der Funktion zum Einstellen des Koeffizienten des dichten Objekts verwendet werden. Einige Kommentare werden abgegeben, wenn die Zufallszahlen vollständig eingefügt sind (zu Forschungs- und Debugging-Zwecken).

Wenn Sie den Mitgliedern dieses InitInfo-Objekts die Anzahl der Knoten in der mittleren Ebene entnehmen, scheint sich der Lernteil usw. zu verschieben, wenn er in den folgenden Code geändert wird.

# create InitInfo object
objInitInfo = InitInfo(x,y)
# calc init value of w and h(and bias)
objInitInfo.calc_w_h()

#Machen Sie ein Modell zum Lernen
model = Sequential()
#Vollständig verbundene Schicht(1 Schicht->XXX Schicht)
model.add(Dense(input_dim=1, output_dim=objInitInfo.paramN,
                bias=True,
                kernel_initializer=objInitInfo.initW,
                bias_initializer=objInitInfo.initB))
#Aktivierungsfunktion(Sigmoidfunktion)
model.add(Activation("sigmoid"))

#Vollständig verbundene Schicht(XXX Schicht->1 Schicht)
model.add(Dense(output_dim=1, kernel_initializer=objInitInfo.initH))
#Kompilieren Sie das Modell
model.compile(loss="mean_squared_error", optimizer="sgd", metrics=["accuracy"])
#Führen Sie das Lernen durch
model.fit(x, y, nb_epoch=1000, batch_size=32)

Für den Namen der anfänglichen Werteinstellungsoption usw. habe ich auf offizielle Website von Keras verwiesen. Ich werde den gesamten Code einfügen, der dies unten verwendet.

sample_KerasNewral.py

import pandas as pd
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import backend as K


# init infomation for keras layers or models
class InitInfo:
    
    # constractor
    #  x:input y:output
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
    # calc coefficient of keras models(1st layer)
    # input  s:changing point in [0,1]
    #        sign:[1]raise,[0]down
    # return b:coefficient of bias
    #        w:coefficient of x
    # notice - it can make like step function using this return values(s,sign)
    def calc_b_w(self,s,sign):
    
        N = 1000 #Zwischenlagerung
        # s = -b/w
        if sign > 0:
            b = -N
        else:
            b = N
        if s != 0:
            w = -b/s
        else:
            w = 1
        return b,w
    
    # calc coefficient of keras models(1st and 2nd layer)
    def calc_w_h(self):
    
        K = len(self.x)
        # coefficient of 1st layer(x,w)
        w_array = np.zeros([K*2,2])
        # coefficient of 2nd layer
        h_array = np.zeros([K*2,1])
        
        w_idx = 0
        for k in range(K):
            # x[k] , y[k]
            # make one step function
            # startX : calc raise point in [0,1]
            if k > 0:
                startX = self.x[k] +  (self.x[k-1] - self.x[k])/2
            else:
                startX = 0
    
            # endX : calc down point in [0,1]
            if k < K-1:
                endX = self.x[k] + (self.x[k+1] - self.x[k])/2
            else:
                endX = 1
    
            # calc b,w
            if k > 0:
                b,w = self.calc_b_w(startX,1)
            else:
                # init???
                b = 100
                w = 1
    
            # stepfunction 1stHalf
            #            __________
            # 0 ________|
            #        
            w_array[w_idx,0] = w
            w_array[w_idx,1] = b
            h_array[w_idx,0] = self.y[k]
            w_idx += 1
            
            # stepfunction 2ndHalf
            #        
            # 0 __________
            #             |________
            b,w = self.calc_b_w(endX,1)
            w_array[w_idx,0] = w
            w_array[w_idx,1] = b
            h_array[w_idx,0] = self.y[k]*-1
            
            # shape of 1st + 2nd is under wave
            #            _
            # 0 ________| |________
            #
            
            w_idx += 1
        
        # record param
        self.w = w_array
        self.h = h_array
        self.w_init = w_array[:,0]
        self.b_init = w_array[:,1]
        self.paramN = len(h_array)
        return
    
    # for bias coefficients　setting
    def initB(self, shape, name=None):
        #L = np.prod(shape)
        #value = np.random.randn(L).reshape(shape)*5
        value = self.b_init
        value = value.reshape(shape)
        return K.variable(value, name=name)

    # for w coefficients (x) setting
    def initW(self, shape, name=None):
        #L = np.prod(shape)
        #value = np.random.random(shape)
        #value = np.random.randn(L).reshape(shape)*5
        value = self.w_init
        value = value.reshape(shape)
        return K.variable(value, name=name)
    
    # for h coefficients setting
    def initH(self, shape, name=None):
        #L = np.prod(shape)
        #value = np.random.randn(L).reshape(shape)*1
        value = self.h
        value = value.reshape(shape)
        return K.variable(value, name=name)

 
# deta making???
csv_input = pd.read_csv(filepath_or_buffer="data_out.csv",
                        encoding="ms932",
                        sep=",")

#Anzahl der Eingabeelemente (Anzahl der Zeilen)*Die Anzahl der Spalten) wird zurückgegeben.
print(csv_input.size)

#Gibt das DataFrame-Objekt zurück, das nur für die angegebene Spalte extrahiert wurde.
x = np.array(csv_input[["hour"]])
y = np.array(csv_input[["wind"]])

# num of records
N = len(x)

#Normalisierung
x_max = np.max(x,axis=0)
x_min = np.min(x,axis=0)
y_max = np.max(y,axis=0)
y_min = np.min(y,axis=0)
x = (x - np.min(x,axis=0))/(np.max(x,axis=0) - np.min(x,axis=0))
y = (y - np.min(y,axis=0))/(np.max(y,axis=0) - np.min(y,axis=0))

# create InitInfo object
objInitInfo = InitInfo(x,y)
# calc init value of w and h(and bias)
objInitInfo.calc_w_h()

#Machen Sie ein Modell zum Lernen
model = Sequential()
#Vollständig verbundene Schicht(1 Schicht->XXX Schicht)
model.add(Dense(input_dim=1, output_dim=objInitInfo.paramN,
                bias=True,
                kernel_initializer=objInitInfo.initW,
                bias_initializer=objInitInfo.initB))
#Aktivierungsfunktion(Sigmoidfunktion)
model.add(Activation("sigmoid"))

#Vollständig verbundene Schicht(XXX Schicht->1 Schicht)
model.add(Dense(output_dim=1, kernel_initializer=objInitInfo.initH))
#Kompilieren Sie das Modell
model.compile(loss="mean_squared_error", optimizer="sgd", metrics=["accuracy"])
#Führen Sie das Lernen durch
model.fit(x, y, nb_epoch=1000, batch_size=32)

#True Value Plot
plt.plot(x,y,marker='x',label="true")
#Berechnen Sie die Keras-Ergebnisse mit Inferenz,Anzeige
y_predict = model.predict(x)
#Keras Berechnungsergebnisplot
plt.plot(x,y_predict,marker='x',label="predict")
#Legendenanzeige
plt.legend()

Betrachten Sie das Ergebnisdiagramm?

Sie passten fast zusammen! Wie beim letzten Mal denke ich, dass es überlernt ist, aber ich wollte das tun, also scheint es, als hätte es funktioniert.

Wenn der Anfangswert von h völlig zufällig ist (Normalverteilung) ???

Wenn N = 1000 war, war die Konvergenz nicht so gut. Wenn ich sie also ein wenig erhöhte, wurde sie wie oben beschrieben. Es fühlt sich ziemlich gut an. Wenn andererseits w und b auf vollständig zufällige Zahlen eingestellt sind, ???

Es sieht aus wie eine grobe Kurve. Da der Anfangswert eine Zufallszahl ist, ändert er sich wahrscheinlich bei jeder Ausführung geringfügig.

Selbst wenn Sie Keras verwenden, können Sie den Anfangswert auf diese Weise ganz frei auswählen, und es scheint, dass sich das Verhalten entsprechend ändert. Es ist ein interessanter Inhalt.

Dieses Mal schrieb ich es als Memo des Studienergebnisses über die Verwendung von Keras. Es gibt immer noch verschiedene unterhaltsame Funktionen wie Rückrufe, also werde ich sie weiter betrachten und als nächstes das Klassifizierungssystem betrachten.