Essayez de prédire les fleurs de cerisier avec XG Boost

Essayez de prédire les fleurs de cerisier avec XG Boost Utilisez les données de mars de l'année dernière à février de cette année Python Débutant Apprentissage automatique

1. Objet

Il y avait une prévision AI Sakura, et il y avait un article disant que xgboost était utilisé, alors j'ai essayé de prédire les fleurs de cerisier avec xgboost. https://www.businessinsider.jp/post-186528

2. Conclusion

C'était un résultat subtil. Il s'est avéré que la prédiction AI Sakura ci-dessus est excellente. 無題.png Les facteurs qui ont un effet important sur la période de floraison sont la température moyenne annuelle, les heures d'ensoleillement en juillet, les précipitations en août et la température la plus basse en octobre. Je connais la température annuelle moyenne, mais j'ai été surpris par les heures d'ensoleillement en juillet, les précipitations en août et la température la plus basse en octobre.

3. Source des données

https://www.data.jma.go.jp/gmd/risk/obsdl/index.php Les données ci-dessus de l'Agence météorologique ont été traitées et utilisées.

4. Explication du code

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from xgboost import XGBRegressor, plot_importance
from sklearn.model_selection import GridSearchCV, KFold
from tqdm import tqdm_notebook
path="./"
train = pd.read_csv(path+"kikou5train.csv")
x_test = pd.read_csv(path+"kikou5test.csv")

y_train = train.kaika.copy()
x_train = train.drop("kaika", axis=1)
train_id = x_train.Id
x_train.head()
date	avtmp3	maxtmp3	mintmp3	ame3	nisho3	joki3	kumo3	avtmp4	maxtmp4	...	kumo13	avtmp14	maxtmp14	mintmp14	ame14	nisho14	joki14	kumo14	kaika	TotalInc
Id																					
1	1961	8.2	21.9	-0.4	106.6	181.1	6.7	6.3	14.9	26.0	...	3.8	5.9	24.5	-2.6	13.5	195.0	4.5	4.1	NaN	193.6
2	1962	8.2	18.8	-0.8	65.5	189.8	6.3	4.7	14.1	24.5	...	2.0	4.8	15.3	-4.1	21.3	199.9	4.1	4.9	NaN	182.3

Joindre

df = pd.concat([x_train, x_test])
df.head()

Ingénierie de la quantité de caractéristiques Température moyenne annuelle ajoutée

df["TotalInc"] = df.avtmp3 + df.avtmp4 + df.avtmp5 + df.avtmp6 + df.avtmp7 + df.avtmp8 + df.avtmp9 + df.avtmp10 + df.avtmp11 + df.avtmp12 + df.avtmp13 + df.avtmp14 #De température moyenne
df.head()
date	avtmp3	maxtmp3	mintmp3	ame3	nisho3	joki3	kumo3	avtmp4	maxtmp4	...	kumo13	avtmp14	maxtmp14	mintmp14	ame14	nisho14	joki14	kumo14	kaika	TotalInc
0	1980	8.2	21.2	1.3	173.5	157.5	6	6.2	13.6	24	...	2.9	5.3	17.2	-3.5	38	157.3	4.6	5.5	NaN	183.4
1 rows × 87 columns
x_train = df[df.Id.isin(train_id)].set_index("Id")
x_test = df[~df.Id.isin(train_id)].set_index("Id")

Recherche optimale par hyperparamètres

random_state = 0
params = {
          "learning_rate": [0.01, 0.05, 0.1],
          "min_child_weight": [0.1],
          "gamma": [0],
          "reg_alpha": [0],
          "reg_lambda": [1],
          "max_depth": [3, 5, 7],
          "max_delta_step": [0],
          "random_state": [random_state],
          "n_estimators": [50, 100, 200],
          }
reg = XGBRegressor()
cv = KFold(n_splits=3, shuffle=True, random_state=random_state)
reg_gs = GridSearchCV(reg, params, cv=cv)
reg_gs.fit(x_train, y_train)
GridSearchCV(cv=KFold(n_splits=3, random_state=0, shuffle=True),
             estimator=XGBRegressor(base_score=None, booster=None,
                                    colsample_bylevel=None,
                                    colsample_bynode=None,
                                    colsample_bytree=None, gamma=None,
                                    gpu_id=None, importance_type='gain',
                                    interaction_constraints=None,
                                    learning_rate=None, max_delta_step=None,
                                    max_depth=None, min_child_weight=None,
                                    missing=nan, monoto...
                                    num_parallel_tree=None, random_state=None,
                                    reg_alpha=None, reg_lambda=None,
                                    scale_pos_weight=None, subsample=None,
                                    tree_method=None, validate_parameters=None,
                                    verbosity=None),
             param_grid={'gamma': [0], 'learning_rate': [0.01, 0.05, 0.1],
                         'max_delta_step': [0], 'max_depth': [3, 5, 7],
                         'min_child_weight': [0.1],
                         'n_estimators': [50, 100, 200], 'random_state': [0],
                         'reg_alpha': [0], 'reg_lambda': [1]})
display(reg_gs.best_params_)
display(reg_gs.best_score_)
ax = plot_importance(reg_gs.best_estimator_, importance_type="gain")
fig = ax.figure
fig.set_size_inches(250, 250)
ax.figure.set_size_inches(18,18)
{'gamma': 0,
 'learning_rate': 0.1,
 'max_delta_step': 0,
 'max_depth': 5,
 'min_child_weight': 0.1,
 'n_estimators': 50,
 'random_state': 0,
 'reg_alpha': 0,
 'reg_lambda': 1}
0.36250088820449333

Prévoir

y_pred3 = reg_gs.predict(x_test)

Évaluez l'erreur à partir de l'étiquette correcte

y_true = pd.read_csv(path+"kikou5test.csv")
preds = pd.DataFrame({"pred3": y_pred3})
df_out = pd.concat([y_true, preds], axis=1)
df_out.head()
Id	date	avtmp3	maxtmp3	mintmp3	ame3	nisho3	joki3	kumo3	avtmp4	...	avtmp14	maxtmp14	mintmp14	ame14	nisho14	joki14	kumo14	kaika	pred3	loss3
0	100	1966	9.6	21.6	1.2	99.9	150.4	7.0	6.6	13.6	...	4.9	19.1	-4.0	43.8	162.6	5.1	5.0	30	29.816103	0.033818

RMSE

df_out["loss3"] = (df_out.kaika - df_out.pred3)**2
df_out.iloc[:, -3:].mean()
kaika    24.909091
pred3    26.849123
loss3    23.966188
dtype: float64
from sklearn.metrics import mean_squared_error, mean_absolute_error
#RMSE
rmse_kaika = np.sqrt(mean_squared_error(df_out.kaika, df_out.pred3))
rmse_kaika
4.895527368155607

La précision de prédiction des fleurs de cerisier est inférieure à 5 jours. C'était étonnamment prévisible, mais c'était subtil.

Recommended Posts

Essayez de prédire les fleurs de cerisier avec XG Boost
Essayez de prédire le taux de change (FX) avec un apprentissage automatique non approfondi
Essayez d'exploiter Facebook avec Python
Essayez de profiler avec ONNX Runtime
Essayez de produire de l'audio avec M5 STACK
Essayez de reproduire un film couleur avec Python
Essayez de vous connecter à qiita avec Python
Essayez de convertir en données ordonnées avec les pandas
Essayez rapidement de visualiser votre ensemble de données avec des pandas
Premier YDK à essayer avec Cisco IOS-XE
Essayez de générer une image avec aliénation
Prédire FX avec LSTM à l'aide de Keras + Tensorflow Partie 2 (Calculer avec GPU)
J'ai essayé de prédire l'année prochaine avec l'IA
Essayez de créer votre propre AWS-SDK avec bash
J'ai essayé d'utiliser lightGBM, xg boost avec Boruta
Essayez d'agréger les données de musique doujin avec des pandas
Essayez de résoudre le diagramme homme-machine avec Python
Essayez d'extraire le document Azure document DB avec pydocumentdb
Essayez de dessiner une courbe de vie avec python
Essayez de communiquer avec EV3 et PC! (MQTT)
Comment essayer l'algorithme des amis d'amis avec pyfof
Essayez de générer automatiquement des documents Python avec Sphinx
J'ai essayé de prédire la survie du Titanic avec PyCaret
Essayez de créer un groupe de dièdre avec Python
Essayez de rendre le client FTP le plus rapide avec Pythonista
Essayez de prédire FX avec LSTM en utilisant Keras + Tensorflow Partie 3 (essayez d'atteindre tous les paramètres)
Essayez de détecter les poissons avec python + OpenCV2.4 (inachevé)
Essayez de résoudre le livre des défis de programmation avec python3
Comment utiliser xgboost: classification multi-classes avec des données d'iris
Faisons un outil de veille de commande avec python
Essayez de créer un Checkbutton dynamiquement avec Tkinter en Python
Essayez de résoudre le problème d'affectation du médecin de formation avec Python
Essayez le fonctionnement de la base de données avec Python et visualisez avec d3
Essayez de créer une API RESTful avec MVC à l'aide de Flask 1.0.2
Développement basé sur les schémas avec Responder: essayez d'afficher l'interface utilisateur Swagger
[Neo4J] ④ Essayez de gérer la structure du graphe avec Cypher
Un échantillon pour essayer rapidement les machines de factorisation avec fastFM
Essayez de falsifier les demandes de l'iPhone avec Burp Suite
Essayez de gratter avec Python.
Convertir 202003 en 2020-03 avec les pandas
Essayez d'implémenter yolact
Essayez SNN avec BindsNET
Essayez la régression avec TensorFlow
J'ai essayé de prédire et de soumettre les survivants du Titanic avec Kaggle
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
Essayez de jouer avec l'uprobe qui prend directement en charge Systemtap
[Evangelion] Essayez de générer automatiquement des lignes de type Asuka avec Deep Learning
Essayez d'afficher diverses informations utiles pour le débogage avec python
Quand j'essaye de pousser avec heroku, ça ne marche pas
[AWS] Essayez d'ajouter la bibliothèque Python à la couche avec SAM + Lambda (Python)
Essayez de lier iTunes et Hue of Collection Case avec MQTT
Essayez d'ouvrir une sous-fenêtre avec PyQt5 et Python
Essayez d'extraire la table de données d'Azure SQL Server avec pyodbc
Essayez d'automatiser le fonctionnement des périphériques réseau avec Python
Essayez de traiter les données Titanic avec la bibliothèque de prétraitement DataLiner (Append)
Essayez d'acquérir des données lors de la redirection de port vers RDS avec anaconda.