[PYTHON] Verwendung der offenen Daten von Data City Sabae zur Vorhersage des Werts des Wasserstandsmessers durch maschinelles Lernen Teil 2

Einführung

Früher habe ich erklärt, wie man den Wasserstand aus der Niederschlagsmenge vorhersagt, aber danach, als ich verschiedene Untersuchungen durchführte, wurde es möglich, den Wasserstand eine Stunde später mit einer Genauigkeit von etwa 95% vorherzusagen, sodass ich ihn neu organisieren werde. Ich werde einen Artikel schreiben.

Versuchen Sie, den Wert des Wasserstandsmessers durch maschinelles Lernen unter Verwendung der offenen Daten von Data City Sabae vorherzusagen

Betriebsumgebung

Bauverfahren für die Umwelt

Die übliche Front-Miso finden Sie unter der folgenden URL.

Verfahren zum schnellen Erstellen einer Deep-Learning-Umgebung auf einem Mac mit TensorFlow und OpenCV

Daten herunterladen

Datenliste öffnen | Data City Sabae Portal Site

Wenn Sie auf der obigen Website die Gruppe "Katastrophenschutz" auswählen, wird die folgende Notation angezeigt. Klicken Sie auf die Schaltfläche "CSV" und laden Sie die CSV über den angezeigten Link herunter.

Darüber hinaus können frühere Wetterdaten von der Meteorologischen Agentur heruntergeladen werden, sodass wir stündliche Niederschlagsdaten in Fukui City herunterladen.

Meteorological Agency | Download früherer meteorologischer Daten

Bibliothek laden

Verwenden Sie das Jupyter-Notizbuch, um die folgenden Bibliotheken zu laden.

python

from ipywidgets import FloatProgress
from IPython.display import display

%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt

import pandas as pd
import numpy as np
import datetime

Wasserstandsdaten lesen

python

#Datei lesen
filename = "sparql.csv"
df_level = pd.read_csv(filename, header=None, skiprows=1)

#Spalte umbenennen
df_level.columns = ["url","datetime","level"]

#Konvertieren Sie Datum und Uhrzeit in Zeitstempel
df_level["datetime"] = df_level.datetime.map(lambda _: pd.to_datetime(_))

#Legen Sie Datum und Uhrzeit als Index fest
df_level.index = df_level.pop("datetime")

#Nach Datum und Uhrzeit sortieren(...Ich denke, es wird ohne es funktionieren, aber ich werde es verlassen)
df_level = df_level.sort_index()

#Grafikanzeige
df_level["level"].plot(figsize=(15,5))

Bei der Ausführung wird das folgende Diagramm angezeigt.

Niederschlagsdaten lesen

Lesen Sie die Daten und zeigen Sie sie in der Grafik an. Achten Sie dabei darauf, dass die CSV Daten enthält, die nicht gezählt werden, und dass der Zeichencode Shift JIS ist.

python

#Datei lesen
filename = "data.csv"
df = pd.read_csv(filename,encoding="SHIFT-JIS",skiprows=4)

#Spalte umbenennen
df_rain.columns = ["datetime", "rain", "Information ohne Phänomen","Qualitätsinformationen","Homogene Zahl"]

#Konvertieren Sie Datum und Uhrzeit in Zeitstempel
df_rain["datetime"] = df_rain.datetime.map(lambda _: pd.to_datetime(_))

#Legen Sie Datum und Uhrzeit als Index fest
df_rain.index = df_rain.pop("datetime")

#Grafikanzeige
df_level.level.plot(figsize=(15,5))
df_rain.rain.plot(figsize=(15,5))

Bei der Ausführung wird das folgende Diagramm angezeigt. Orange ist übrigens die Niederschlagsmenge.

Datenverarbeitung

Dieses Mal, da wir den Wasserstand eine Stunde später vorhersagen, möchte ich den maximalen Wasserstand eine Stunde später anhand der Änderung des Wasserstandes vor einer Stunde und der Niederschlagsmenge vorhersagen.

Dafür sind die Trainingsdaten wie folgt.

Da es sich bei den Wasserstandsdaten um Daten in Intervallen von 5 Minuten handelt, sollten alle 60 Minuten 12 Datenpunkte vorhanden sein. Es fehlen jedoch einige Daten, und einige von ihnen haben je nach Zeitpunkt 12 Punkte oder weniger. Nach Versuch und Irrtum beträgt die Punktzahl 10 Punkte.

Da die Niederschlagsdaten auf der Website der Meteorologischen Agentur als "1 Stunde vorher" beschrieben werden, gelten sie außerdem als Daten 1 Stunde vor dem im Index festgelegten Datum und der Uhrzeit.

Basierend darauf ist das Datenverarbeitungsverfahren wie folgt.

python

#Niederschlagsindex abrufen
ixs = df_rain.index

#Erstellen eines Arrays zur Datenerfassung
df = []
y = []

for i in range(len(ixs)-2):
    
    #Datum und Uhrzeit aus dem Index abrufen
    dt1 = ixs[i]
    dt2 = ixs[i + 1]
    dt3 = ixs[i + 2]
    
    #Abrufen von Wasserstandsdaten aus Datums- und Zeitdaten
    d1 = df_level[dt1:dt2].level.tolist()
    d2 = df_level[dt2:dt3].level.tolist()

    if len(d1) > 10 and len(d2) > 10:
        #Holen Sie sich den maximalen Wasserstand nach 1 Stunde
        y.append(max(d2))

        #Sortieren Sie die Wasserstandsdaten vor einer Stunde in absteigender Reihenfolge
        d1.sort()
        d1.reverse()
        #Holen Sie sich 10 Datenpunkte
        d1 = d1[:10]
        #Niederschlagsdaten abrufen
        d1.append(df_rain.ix[i].rain)
        #Holen Sie sich ein Array von Eingabedaten
        df.append(d1)
        
#In Datenrahmen konvertieren
df = pd.DataFrame(df)
df["y"] = y

#Überprüfen Sie die Anzahl der Daten
print(df.shape)

Als ich es ausführte, wurde (6863, 12) angezeigt und ich konnte 6863 Datenzeilen abrufen.

Maschinelles Lernen

Wir werden die erste Hälfte 90% der Daten durch maschinelles Lernen lernen und das Lernergebnis in der zweiten Hälfte 10% überprüfen.

python

#Teilen Sie Daten in Eingabe und Ausgabe
y = df.pop("y").as_matrix().astype("int").flatten()
X = df.as_matrix().astype("float")

#Geteilt, um 90% für das Lernen und 10% für die Überprüfung zu verwenden
num = int(len(X) * 0.9)
print(len(X), num, len(X)-num)

X_train = X[:num]
X_test = X[num:]
y_train = y[:num]
y_test = y[num:]

#Legen Sie eine zufällige Gesamtstruktur als Lernmodell fest
from sklearn.ensemble import RandomForestRegressor
model = RandomForestRegressor(random_state=42)

#Lernen und Verifizieren
model.fit(X_train, y_train)
result = model.predict(X_test)

#Ergebnis
print(model.score(X_test,y_test))

Als ich es ausführte, war die Vorhersagegenauigkeit "0,952915078747".

Ich bin mir über die Zahlen nicht sicher, also werde ich eine Grafik zeichnen.

python

pp = pd.DataFrame({'act': np.array(y_test), "pred": np.array(result), "rain": X_test[:,-1]})
pp.rain = pp.rain * 5
plt.figure(figsize=(15,5))
plt.ylim(0,250)
plt.plot(pp)

Blau ist der tatsächliche Wasserstand, Orange ist der vorhergesagte Wasserstand und die blaue Linie ist fast unsichtbar, weil sie sich zu stark überlappt (^ - ^).

Beeindruckend!

Prognose

Lassen Sie uns nun die Niederschlagsmenge vom Wasserstand zu einem bestimmten Zeitpunkt ändern und den Wasserstand eine Stunde später vorhersagen.

python

import random

#Wählen Sie den Index nach dem Zufallsprinzip aus
i = random.randint(0,len(df))
d = df.ix[i].as_matrix().tolist()
print(d)

#Holen Sie sich das Test-Array
df_test = []

#Erstellen Sie Testdaten, indem Sie die Niederschlagsmenge von 0 auf 20 ändern
for i in range(21):
    temp = d[:10]
    temp.append(i)
    df_test.append(temp)
    
#Prognose
test = model.predict(np.array(df_test).astype("float"))

#Grafikanzeige
plt.plot(test)

Die verwendeten Daten waren die folgenden Werte.

python

[150.0, 149.0, 149.0, 148.0, 147.0, 147.0, 147.0, 146.0, 146.0, 146.0, 8.0, 147.0]

Das Diagramm des Vorhersageergebnisses ist wie folgt.

Die X-Achse ist der Niederschlag und die Y-Achse ist der Wasserstand. In diesem Diagramm steigt der Wasserstand zwar proportional zum Niederschlag allmählich an, steigt jedoch nach 10 mm stark an und fällt bei 13 mm ab. ..

Ich habe ein paar andere Tests versucht, aber alle hatten eine leicht verzerrte Grafik. Selbst wenn die Vorhersagegenauigkeit von Zeitreihendaten hoch ist, ist dies nicht sinnvoll ... (-_-;)

Erwägung

Ich dachte, dass der Wasserstand mit zunehmender Niederschlagsmenge ansteigen würde, aber die Vorhersage aus den Testdaten war ein wenig anders als erwartet und stieg nicht gleichmäßig an. Dies liegt wahrscheinlich daran, dass es nicht möglich ist, richtig vorherzusagen, was nicht in den Trainingsdaten enthalten ist.

Okay, lassen Sie uns die nächste Methode in diesem Sinne betrachten!

Nutzung des neuronalen Netzes

Versuchen wir nun einen kürzlich populären Algorithmus. Der Prozess bis zur Datenverarbeitung ist der gleiche, und der Teil des maschinellen Lernens wird wie folgt geändert.

Das neuronale Netzwerk ist übrigens auch als mehrschichtiges Perzeptron bekannt. Da das neuronale Netzwerk hauptsächlich numerische Werte von -1 bis 1 verarbeitet, normalisiert es außerdem die Trainingsdaten.

python

#Teilen Sie Daten in Eingabe und Ausgabe
y = df.pop("y").as_matrix().astype("int").flatten()
X = df.as_matrix().astype("float")

#Geteilt, um 90% für das Lernen und 10% für die Überprüfung zu verwenden
num = int(len(X) * 0.9)
print(len(X), num, len(X)-num)

X_train = X[:num]
X_test = X[num:]
y_train = y[:num]
y_test = y[num:]

#Datennormalisierung
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(X_train)

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

#Legen Sie ein neuronales Netzwerk als Trainingsmodell fest
from sklearn.neural_network import MLPRegressor
model = MLPRegressor(random_state=42)

#Lernen und Verifizieren
model.fit(X_train, y_train)
result = model.predict(X_test)

#Ergebnis
print(model.score(X_test,y_test))

Bei der Ausführung beträgt die Vorhersagegenauigkeit "0,947163962045", was etwas schlechter ist als die zufällige Gesamtstruktur (-_-;)

Aber vorerst werde ich es bis zum Ende versuchen.

python

import random

#Wählen Sie den Index nach dem Zufallsprinzip aus
i = random.randint(0,len(df))
d = df.ix[i].as_matrix().tolist()
print(d)

df_test = []

#Erstellen Sie Testdaten, indem Sie die Niederschlagsmenge von 0 auf 20 ändern
for i in range(21):
    temp = d[:10]
    temp.append(i)
    df_test.append(temp)
    
#Normalisierung der Eingabedaten
d = scaler.transform(np.array(df_test).astype("float"))

#Prognose
test = model.predict(d)

plt.plot(test)

Ich werde es versuchen.

[54.0, 54.0, 54.0, 53.0, 53.0, 53.0, 53.0, 53.0, 53.0, 53.0, 0.0, 53.0]

Kita --------! !!

Neuronales Netz ist unglaublich! !!

Vielen Dank

Vielen Dank an alle, die an Open Data in Sabae City beteiligt sind, für ihre wertvollen Daten. Wir freuen uns darauf, in Zukunft mit Ihnen zusammenzuarbeiten.

Nachtrag

Wir haben ein Dokument veröffentlicht, das die Daten von Jupyter Notebook zusammenfasst, das den oben genannten Inhalt ausgeführt hat. Lesen Sie daher auch dieses Dokument.

Vorhersage des Wasserstandes unter Verwendung offener Daten in Sabae City, Version Fukui Prefecture-2017