[PYTHON] Essayez de prédire la valeur de la jauge de niveau d'eau par apprentissage automatique en utilisant les données ouvertes de Data City Sabae
introduction
Lorsque je cherchais du bon matériel comme exemple d'utilisation de données ouvertes, j'ai trouvé que les données sur le niveau d'eau étaient publiées sur le site de Data City Sabae, alors j'ai essayé l'apprentissage automatique en utilisant cela. C'était.
http://data.city.sabae.lg.jp/top_page/
Télécharger les données
Sur la page "Données ouvertes" du site ci-dessus, le groupe "Prévention des catastrophes" a la notation suivante.
Données de niveau d'eau(Ville de Sabae, préfecture de Fukui)
Station de pompage de drainage de Rontegawa[CSV]
Ce sont les données de la jauge de niveau d'eau dans la ville de Sabae. Unité de niveau d'eau:données cm:1000 caisses
Par défaut, on dit qu'il y a 1000 données, mais je vais les utiliser car je pourrais obtenir un peu plus de données.
En outre, les données météorologiques passées peuvent être téléchargées à partir de l'Agence météorologique, alors téléchargez les données de précipitations de la ville voisine de Fukui.
http://www.data.jma.go.jp/gmd/risk/obsdl/index.php
Charger la bibliothèque
Utilisez le bloc-notes Jupyter pour charger les bibliothèques suivantes.
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
Lecture des données de niveau d'eau
python
filename = "sparql.csv"
df = pd.read_csv(filename, header=None)
Affichons-le dans un graphique.
python
tmp = []
for i in range(len(df)):
pos = len(df) - 1 - i
tmp.append(df.ix[pos][2])
pd.DataFrame({'level': np.array(tmp)}).plot(figsize=(15,5))
Les données sur le niveau d'eau sont acquises toutes les 5 minutes, et les données sont traitées pour faire correspondre la série chronologique avec les données de l'Agence météorologique.
python
#Obtenir les dates de début et de fin des données
dt1 = datetime.datetime.strptime(df[1][len(df)-1],"%Y-%m-%dT%H:%M:%S+09:00")
dt1 = datetime.datetime(dt1.year,dt1.month,dt1.day,0,0)
dt2 = datetime.datetime.strptime(df[1][0],"%Y-%m-%dT%H:%M:%S+09:00")
print("dt1:",dt1)
print("dt2:",dt2)
#Obtenez des jours de données
dt = (dt2-dt1).days + 1
#Préparer un tableau pour stocker des données horaires
level = [0] * dt * 24
dt_al = [0] * dt * 24
#Paramètres de la barre de progression
fp = FloatProgress(min=0, max=len(df))
display(fp)
for i in range(len(df)):
wk = datetime.datetime.strptime(df[1][len(df)-i-1],"%Y-%m-%dT%H:%M:%S+09:00")
pos = (wk - dt1).days * 24 + wk.hour
dt_al[pos] = datetime.datetime(wk.year,wk.month,wk.day,wk.hour,0)
if wk.minute == 0:
level[pos] = df[2][len(df)-1-i]
fp.value = i
Lecture des données de précipitations
Lisez les données en faisant attention au fait que le CSV contient des données qui ne sont pas comptées et que le code de caractère est shift JIS. Essayez également d'afficher les données lues sous forme de graphique.
python
filename = "data.csv"
df = pd.read_csv(filename,encoding="SHIFT-JIS",skiprows=4)
df.plot(figsize=(15,5))
Stockez les données de niveau d'eau et de précipitations dans le même tableau de format
Stockez les données dans un tableau pour faciliter la gestion, puis affichez le graphique.
python
#Préparation du tableau
rain = [0]*len(level)
for i in range(len(df)):
wk = datetime.datetime.strptime(df.ix[i][0],"%Y/%m/%d %H:%M:%S")
if (wk < dt2) and (wk - dt1).days >= 0:
pos = (wk - dt1).days * 24 + wk.hour
rain[pos] = df.ix[i][1]
#Vérifiez les données sur le graphique
pp = pd.DataFrame({'level': np.array(level), 'rain': np.array(rain)*15})
pp.plot(figsize=(15,5))
Il semble y avoir beaucoup de données manquantes ... (sueur)
Examen des données d'entraînement
En regardant le graphique, il semble que le niveau d'eau a tendance à augmenter après la pluie, alors entrons les informations sur la quantité de précipitations d'il y a 48 heures à cette époque et utilisons le niveau d'eau comme données de sortie de l'enseignant.
python
#Obtenez 48 heures de précipitations dans un tableau bidimensionnel
row = len(level)
tmp = np.zeros((row,48))
fp = FloatProgress(min=0, max=row)
display(fp)
for i in range(row):
for j in range(len(tmp[0])):
pos = row - 1 - i - j
tmp[row-1-i][j] = rain[pos]
fp.value = i
Rognage des données manquantes
Si les données de niveau d'eau n'ont pas été obtenues, elles ne sont pas nécessaires et seront supprimées.
python
#Vérifiez le nombre de données manquantes
num = 0
for i in range(len(level)):
if level[i] == 0:
num += 1
#Préparation au stockage des données
X = np.empty((0,48))
y = []
for i in range(len(level)):
if level[i] > 0:
X = np.append(X, np.array([tmp[i]]), axis=0)
y.append(level[i])
#Vérifiez les données sur le graphique
pp = pd.DataFrame({'level': np.array(y), 'rain': X[:,0]*20})
pp.plot(figsize=(15,5))
Si vous regardez le graphique, vous pouvez voir qu'il est devenu assez beau.
Apprentissage automatique
Apprenez des données nettoyées et vérifiez le score du résultat prévu.
python
#Charger le module de validation croisée
from sklearn import cross_validation
#Ensemble d'entraînement avec données étiquetées(X_train, y_train)Et ensemble de test(X_test, y_test)Divisée en
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y, test_size=.2, random_state=42)
#Normalisation
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
#Paramètres du modèle (forêt aléatoire)
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=200, max_depth=50, random_state=42)
#Apprentissage et prédiction
model.fit(X_train, y_train)
result = model.predict(X_test)
result.shape
#But
print(model.score(X_test,y_test))
Le résultat est ...
python
0.185628742515
... non!
Vérification des résultats
Le score est faible, mais vérifions le résultat avec un graphique.
python
pp = pd.DataFrame({'act': np.array(y_test), "pred": np.array(result)})
pp.plot(figsize=(15,5))
... Hmm, subtile.
Avec un peu d'ingéniosité, les données sont divisées en séries chronologiques pour l'apprentissage et la prédiction, comme indiqué ci-dessous.
python
num = int(len(X) * 0.8)
print(len(X), num, len(X)-num)
X_train = X[:num]
X_test = X[num:]
y_train = y[:num]
y_test = y[num:]
... quelle! Une petite sensation agréable (^ - ^)
Ensuite, en réfléchissant à ce qui peut être fait à partir de ce résultat, il peut être utilisé pour détecter une élévation soudaine du niveau d'eau et donner un avertissement d'évacuation en prédisant en continu le niveau d'eau à partir de la quantité de précipitations.
Dans cet esprit, j'espère que davantage de gouvernements locaux publieront de telles données.
Que devrais-je faire ensuite?
Postscript
J'ai pu améliorer la précision par une méthode d'apprentissage différente de cet article et prédire le niveau d'eau une heure plus tard, alors j'ai essayé de l'écrire à nouveau. Si vous êtes intéressé, veuillez également consulter l'URL suivante.
Recommended Posts