2) Meteo et machine learning

Bon, cette fois c’est parti ! Pour commencer et s’échauffer pénardo sans se claquer un tendon ou une rustine, on va d’abord réduire notre jeu de données (conséquent, j’ai planté mon pc plusieurs fois) en une seule station, et voir ce que ça donne ensuite. Va-t-on pouvoir prévoir des trucs ? Est-ce que déféquer du marbre brut à apprendre python aura été utile ? Est-ce que ça vaut le coup de perdre du temps à lire mon article plutôt que courir nu dans un champ de blé en jouant de la lyre et en riant tel un farfadet facétieux ? Nous allons tenter ensemble de répondre à ces questions existentielles hô combien cruciales.

Précédemment on avait dit qu’on commencerait par une station météo fixe « à la maison » avant de voir pour la mettre sur un bateau. Dans tout ce bordel contenu par les 3 fichiers csv de météo France, il va donc falloir dénicher les données d’une station proche de chez moi, ayant aussi des données exploitables…Car ce jeu de données est parfois un gros gruyère. Des stations n’indiquent pas la pression atmosphérique, d’autres n’indiquent des infos que une fois par jour…Moi j’ai besoin d’une station météo qui me donne pour 2016,2017 et 2018 la pression, la direction du vent, la température et le pourcentage d’humidité sans trop de trous, car plus il manque de l’info, plus on va perdre de l’efficacité sur notre modèle prédictif ! Va falloir chercher un gouda plutôt qu’un gruyère…

I.Traiter les données avant usage.

Au départ on a environ 250 stations, mais seules 49 valent vraiment le détour à première vue, pour sélectionner ces 49 stations on va utiliser un peu la même trame que la fonction fon_changer précédente.

Bien, maintenant il va falloir rendre notre jeu de données présentable pour le soumettre aux différents modèles de machine learning de sklearn… Je vous cache pas que c’est le gros du boulot avec son lot de sueur, de sang, de larmes et de pointes de côté pour un novice informatico-geek prépubère…Mais merde pourquoi j’ai pas choisit des loisirs comme ping pong ou pelote basque…Enfin…En gros voilà comment on va procéder pour commencer:

  1. Se débarrasser du superflu.
  2. arranger nos données, les indexer selon le temps avec le package « datetime »pour faciliter les manips.
  3. gérer les données manquantes en interpolant.
  4. Modifier des variables pour les adapter à notre projet.

L’objectif final sera d’avoir un dataframe de 60 colonnes ou variables et de 1096 lignes ou échantillons. Pourquoi 1096 lignes ? parce que notre jeu de donnée dure trois ans, avec une année bissextile (2016) donc ça fait 366+365+365=1096 jours. Donc une ligne=un jour. Pourquoi 60 colonnes ? En fait on va garder seulement les données toutes les 2 heures, soit 12 fois 5 variables (pression,direction,température,humidité,force) et pis 12X5 bin ça fait 60. C’est ce dataframe qu’on va faire passer à la moulinette façon sklearn! En fait on va prendre le parti pris qu’une journée de données permet de prédire ce qui se passera dans les heures suivantes. Bon faut bien commencer quelque part de toute façon…

Voilà le programme pour traiter nos données et partir des fichiers météo France pour arriver aux données de Deauville en un dataframe de 1096 sur 60 :

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime


def changer(data_1):
    
     
     data_1=data_1.sort_values(by=['date','number_sta'],ascending=True) #met les données dans l'ordre temporel par station.

     data_1['date']=pd.to_datetime(data_1['date']) # change la colonne date en objet datetime.

     data_1=data_1.set_index('date') #on indexe notre dataframe sur le temps.
     
     data_1=data_1.drop(['precip','td','lon','height_sta','lat'],axis=1) #on se débarrasse des colonnes inutiles pour nous.

     data_1=data_1.fillna(data_1.rolling(window=1).mean()) #remplit les nan par la valeur moyenne de la journée.

     data_1=data_1.dropna(axis=0) # on vire les données de stations pour dégraisser.
     
     

     
     heure_1=data_1[(data_1.index.hour==0) & (data_1.index.minute==0)]#on conserve juste les données toutes les deux heures.
     heure_2=data_1[(data_1.index.hour==2) & (data_1.index.minute==0)]
     heure_3=data_1[(data_1.index.hour==4) & (data_1.index.minute==0)]
     heure_4=data_1[(data_1.index.hour==6) & (data_1.index.minute==0)]
     heure_5=data_1[(data_1.index.hour==8) & (data_1.index.minute==0)]
     heure_6=data_1[(data_1.index.hour==10) & (data_1.index.minute==0)]
     heure_7=data_1[(data_1.index.hour==12) & (data_1.index.minute==0)]
     heure_8=data_1[(data_1.index.hour==14) & (data_1.index.minute==0)]
     heure_9=data_1[(data_1.index.hour==16) & (data_1.index.minute==0)]
     heure_10=data_1[(data_1.index.hour==18) & (data_1.index.minute==0)]
     heure_11=data_1[(data_1.index.hour==20) & (data_1.index.minute==0)]
     heure_12=data_1[(data_1.index.hour==22) & (data_1.index.minute==0)]
    
     
     heures=[heure_1,heure_2,heure_3,heure_4,heure_5,heure_6,heure_7,heure_8,heure_9,heure_10,heure_11,heure_12]
     
     data_one=pd.concat(heures,axis=0) # on remet les données en un seul dataframe
     
     
     
     
     
     
     data_one['t']=data_one['t'].map(lambda x:int(x-273.15)) #convertit les Kelvin en degrés celsius.
     data_one['psl']=data_one['psl'].map(lambda x:int(x/100)) #convertit les pascals en hectopascals.
     data_one['hu']=data_one['hu'].map(lambda x:int(x)) #change en entier
     data_one['dd']=data_one['dd'].map(lambda x:int(x)) #pareil
     data_one['ff']=data_one['ff'].map(lambda x:int(x*3600/1852)) #change la vitesse du vent en noeuds.
     
     
     
     return data_one # renvoie les données "filtrées"
 


chunksize=100000 # taille du morceau de données filtré à la fois.

chunks=[] # liste qui va prendre les morceaux filtrés de 2016.


for chunk in pd.read_csv('C:/Users/Psychopathe/Documents/cours tech/machine learning/meteonet-master/NW_Ground_Stations/Meteo_NW_2016.csv',chunksize=chunksize):
        filtered=changer(chunk)
        chunks.append(filtered)
    
    
Deauville_2016=pd.concat(chunks,axis=0)
Deauville_2016=Deauville_2016[Deauville_2016['number_sta']==14578001] # on garde les valeurs de Deauville seulement.
Deauville_2016=Deauville_2016.drop(['number_sta'],axis=1) #on vire cette colonne qui ne nous sert plus
Deauville_2016=Deauville_2016.resample('2H').ffill() #on comble les heures manquantes avec les données de l'heure précédente.


chunks2=[]

for chunk2 in pd.read_csv('C:/Users/Psychopathe/Documents/cours tech/machine learning/meteonet-master/NW_Ground_Stations/Meteo_NW_2017.csv',chunksize=chunksize):
    filtered2=changer(chunk2)
    chunks2.append(filtered2)
    
Deauville_2017=pd.concat(chunks2,axis=0)
Deauville_2017=Deauville_2017[Deauville_2017['number_sta']==14578001]
Deauville_2017=Deauville_2017.drop(['number_sta'],axis=1)
Deauville_2017=Deauville_2017.resample('2H').ffill()


chunks3=[]

for chunk3 in pd.read_csv('C:/Users/Psychopathe/Documents/cours tech/machine learning/meteonet-master/NW_Ground_Stations/Meteo_NW_2018.csv',chunksize=chunksize):
    filtered3=changer(chunk3)
    chunks3.append(filtered3)
    
Deauville_2018=pd.concat(chunks3,axis=0)
Deauville_2018=Deauville_2018[Deauville_2018['number_sta']==14578001]
Deauville_2018=Deauville_2018.drop(['number_sta'],axis=1)
Deauville_2018=Deauville_2018.resample('2H').ffill()


Deauville=[Deauville_2016,Deauville_2017,Deauville_2018]
Deauville=pd.concat(Deauville,axis=0)



liste_heures=[Deauville[Deauville.index.hour==0+2*i] for i in range(12)] # permet de mettre les données de façon à avoir un jour égal une ligne.
Deauville=np.concatenate(liste_heures,axis=1)
Deauville=pd.DataFrame(Deauville)


Deauville.to_csv('Deauville_2H.csv',sep='\t') # crée le fichier avec nos données exploitables.



    
    
    
    
    
    
    
    

Maintenant, on a notre dataframe noté dans le fichier csv « Deauville_2H ». Ouéééé champagne !!!

II. SKLEARN

Sklearn est un package pour faire du machine learning, il contient donc tout un lot de modules pour ça.. Des modules se destinent à l’usage de modèles particuliers (arbres, régression, SVM…) et d’autres au prétraitement et à l’analyse des données, car beaucoup de modèles ont besoin d’un traitement statistique des variables avant, sinon c’est pas terrible niveau résultat, d’autres n’en n’ont pas besoin comme les forêts aléatoires par exemple, enfin comme j’ai lu dans les bouquins à voir. Sklearn permet aussi de résoudre des problèmes de classement, de régression, d’apprentissage non-supervisé et supervisé… Bon pour notre cas c’est de l’apprentissage supervisé pour un problème de régression.

  1. Les problèmes de régression

C’est simplement quand le résultat recherché est un nombre, une donnée « continue » comme un prix ou encore une dimension, une taille, etc…Les autres problèmes sont appelés des problèmes de classement, donc là on va chercher un résultat « discret » comme oui ou non, blanc ou noir, Tom ou Jerry, Riri, Fifi ou Loulou, Joe, averell, Jack ou William…Bref vous voyez le truc quoi.

2. L’apprentissage supervisé

On va séparer nos données en 2 jeux de données distincts; un jeu pour « l’entrainement » du modèle, et un autre pour vérifier si ça marche bien. En général le ratio entre données d’entrainement et données de test est de 70 % / 30 % environ;pour notre jeu de Deauville on prendra un ratio 80%/20%. Ne jamais utiliser des données d’entrainement pour évaluer un modèle, sinon on dit que les données sont « corrompues », et alors on va accoucher d’un modèle qui va tout péter à l’éval test car il aura déjà vu les données mais sur le terrain ça va ramer. Pour faire tout ça on va utiliser la fonction « train_test_split ».

En fait, l’apprentissage supervisé consiste à entrainer un modèle à fournir un résultat proche de ce qui est attendu, le modèle a les variables et le résultat qu’on attend de lui, et avec ça il se modifie via généralement une fonction de coût pour coller au mieux à tout ça.

3. Le prétraitement

Pour presque tout les modèles il est nécessaire de modifier les variables au préalable de façon statistique pour faciliter l’entrainement et l’efficacité des modèles. Pour cela on va majoritairement utiliser le module « preprocessing » de sklearn, ainsi que « make_pipeline » et la fonction « greadsearchcv ».

a) Preprocessing

Pour notre cas, déjà on va pas être emmerdé par des soucis d’encodage (changer des noms en nombres, car un processeur ne sait pas calculer avec des mots) car toutes nos variables sont des nombres. On va utiliser et comparer les résultats de 3 fonctions:

MinMaxScaler

Décale et recalibre les données pour que toutes les caractéristiques soient comprises entre 0 et 1.

RobustScaler

Un peu comme StandardScaler, mais utilise la médiane et les quartiles au lieu de la moyenne et la variance. Son avantage est de gommer les données aberrantes (outliers pour les frimeurs).

StandardScaler

Pour chaque caractéristique, rend la moyenne nulle et la variance égale à 1 (permet à toutes les caractéristiques d’avoir la même amplitude).

b) Les pipelines

Ce sont des structures qui associent un transformateur (l’une des fonctions précédente) et un estimateur (un modèle de machine learning). Ca permet d’économiser des lignes de codes, donc de rendre le code plus clair avec moins de chances de se planter, et aussi d’éviter de corrompre les données. La fonction « make_pipeline » permet de rédiger un pipeline.

c) gridsearcv

Permet de faire de la validation croisée. Cette fonction découpe nos données en sections de taille identiques (dans notre cas, j’ai découpé en 5 parties), puis teste les données selon toutes les configurations de découpage des données (un coup une section est une section test, un autre coup c’est une section entrainement…) et aussi les différents paramètres. Bon désolé c’est pas clair mais j’ai pas trouvé mieux pour expliquer, ou alors j’ai pas compris.

4. Les modèles qu’on va utiliser

Ce sont des modèles adaptés pour l’apprentissage supervisé et la régression. Notre jeu de données comprend pas mal de variables (60), mais bon il y a pire. En effet certains modèles déconnent quand on augmente le nombre de variables, enfin il paraît. Pour tout les modèles les tableaux de résultats concernent une prévision à 12 heures, et l’évolution des scores selon l’étendue de la prédiction se base sur la moyenne des différents scores par traitement.

Les plus proches voisins

Comme on l’a vu rapidement dans le précédent article, cette technique compare notre échantillon avec tout ceux stockés en mémoire. Il détecte le ou les échantillons dont les variables sont les plus similaires, regarde leur « target » ou donnée test correspondante puis attribue cette donnée ou la majorité de ces données si on prend plusieurs voisins pour l’attribuer à notre échantillon. Le plus simple, mais également le moins efficace. Voilà le petit programme pour étudier notre dataframe de Deauville (pour une prévision à 12 heures):

import pandas as pd
import numpy as np
from datetime import datetime
import matplotlib.pyplot as plt
import seaborn as sns

Deauville=pd.read_csv('C:/Users/Psychopathe/Documents/Python Scripts/meteo/station maison/mercredi28octobre/Deauville_2H.csv',sep='\t')

Deauville=Deauville.drop(['Unnamed: 0'],axis=1) # on vire la colonne inutile



variables=Deauville.iloc[:-1,:] # pour l'entrainement on garde tout sauf la dernière ligne.

résultat_dd=Deauville.iloc[1:,30] # pour la direction du vent, on vire la première ligne.
résultat_ff=Deauville.iloc[1:,31] # pour la force du vent, on vire aussi la première ligne.
résultat_hu=Deauville.iloc[1:,32] # pour l'humidité.
résultat_te=Deauville.iloc[1:,33] # pour la température.
résultat_pr=Deauville.iloc[1:,34] # pour la pression.



from sklearn.neighbors import KNeighborsRegressor # technique des plus proches voisins en regression.

from sklearn.model_selection import train_test_split # partage nos données en données test et entrainement (ratio réglé ici via test_size à 20%/80%)
from sklearn.model_selection import GridSearchCV # permet de trouver plus facilement les meilleurs paramètres de réglage du modèle.
from sklearn.model_selection import learning_curve # estime la limite de performance d'un modèle.

from sklearn.pipeline import make_pipeline # assemble un ou des transfomateurs de données et un estimateur, évite les fuites de données et réduit le code, donc évite les erreurs aussi.

from sklearn.preprocessing import MinMaxScaler # traitement de données, normalisation où nos variables deviennent comprises entre 0 et 1.
from sklearn.preprocessing import RobustScaler # traitement de données moins sujet aux outliers (échantillons aberrantes).
from sklearn.preprocessing import StandardScaler # traitement de donnée, rend la moyenne nulle et l'écart-type égal à un.

''' on sépare données entrainement et test pour toutes nos variables que l'on veut tester '''

X_train_direction,X_test_direction,y_train_direction,y_test_direction=train_test_split(variables,résultat_dd,test_size=0.2,random_state=0)
X_train_force,X_test_force,y_train_force,y_test_force=train_test_split(variables,résultat_ff,test_size=0.2,random_state=0)
X_train_humidite,X_test_humidite,y_train_humidite,y_test_humidite=train_test_split(variables,résultat_hu,test_size=0.2,random_state=0)
X_train_temperature,X_test_temperature,y_train_temperature,y_test_temperature=train_test_split(variables,résultat_te,test_size=0.2,random_state=0)
X_train_pression,X_test_pression,y_train_pression,y_test_pression=train_test_split(variables,résultat_pr,test_size=0.2,random_state=0)

traitement_1=make_pipeline(MinMaxScaler(),KNeighborsRegressor()) # création de l'objet pipeline1.
traitement_2=make_pipeline(RobustScaler(),KNeighborsRegressor()) # création du pipeline2.
traitement_3=make_pipeline(StandardScaler(),KNeighborsRegressor()) # création du pipeline3.

meilleurs_parametres=[]
score=[]

''' premier essai sans prétraitement, à poil , direction du vent   '''

param_grid={
    'n_neighbors':np.arange(1,20),
    'metric':['euclidean','manhattan']
    }

grid_1_direction=GridSearchCV(KNeighborsRegressor(),param_grid,cv=5)
grid_1_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_1_direction.best_params_)
model_1_direction=grid_1_direction.best_estimator_
score.append(model_1_direction.score(X_test_direction,y_test_direction))

''' à poil, force du vent '''

grid_1_force=GridSearchCV(KNeighborsRegressor(),param_grid,cv=5)
grid_1_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_1_force.best_params_)
model_1_force=grid_1_force.best_estimator_
score.append(model_1_force.score(X_test_force,y_test_force))

'''à poil, humidite  '''

grid_1_humidite=GridSearchCV(KNeighborsRegressor(),param_grid,cv=5)
grid_1_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_1_humidite.best_params_)
model_1_humidite=grid_1_humidite.best_estimator_
score.append(model_1_humidite.score(X_test_humidite,y_test_humidite))

''' à poil, temperature '''
grid_1_temperature=GridSearchCV(KNeighborsRegressor(),param_grid,cv=5)
grid_1_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_1_temperature.best_params_)
model_1_temperature=grid_1_temperature.best_estimator_
score.append(model_1_temperature.score(X_test_temperature,y_test_temperature))

''' à poil, pression'''

grid_1_pression=GridSearchCV(KNeighborsRegressor(),param_grid,cv=5)
grid_1_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_1_pression.best_params_)
model_1_pression=grid_1_pression.best_estimator_
score.append(model_1_pression.score(X_test_pression,y_test_pression))


''' avec le pipeline1, direction'''

param_grid2={
    'kneighborsregressor__n_neighbors':np.arange(1,20),
    'kneighborsregressor__metric':['manhattan','euclidean']
    }

grid_2_direction=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_2_direction.best_params_)
model_2_direction=grid_2_direction.best_estimator_
score.append(model_2_direction.score(X_test_direction,y_test_direction))

''' avec le pipeline1, force '''

grid_2_force=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_2_force.best_params_)
model_2_force=grid_2_force.best_estimator_
score.append(model_2_force.score(X_test_force,y_test_force))

''' avec le pipeline1, humidite  '''

grid_2_humidite=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_2_humidite.best_params_)
model_2_humidite=grid_2_humidite.best_estimator_
score.append(model_2_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline1, temperature'''

grid_2_temperature=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_2_temperature.best_params_)
model_2_temperature=grid_2_temperature.best_estimator_
score.append(model_2_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline1, pression'''

grid_2_pression=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_2_pression.best_params_)
model_2_pression=grid_2_pression.best_estimator_
score.append(model_2_pression.score(X_test_pression,y_test_pression))



'''avec le pipeline2, direction'''

grid_3_direction=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_3_direction.best_params_)
model_3_direction=grid_3_direction.best_estimator_
score.append(model_3_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline2, force'''

grid_3_force=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_3_force.best_params_)
model_3_force=grid_3_force.best_estimator_
score.append(model_3_force.score(X_test_force,y_test_force))

'''avec le pipeline2, humidite'''

grid_3_humidite=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_3_humidite.best_params_)
model_3_humidite=grid_3_humidite.best_estimator_
score.append(model_3_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline2,temperature'''

grid_3_temperature=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_3_temperature.best_params_)
model_3_temperature=grid_3_temperature.best_estimator_
score.append(model_3_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline2,pression'''

grid_3_pression=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_3_pression.best_params_)
model_3_pression=grid_3_pression.best_estimator_
score.append(model_3_pression.score(X_test_pression,y_test_pression))

'''avec le pipeline3,direction'''

grid_4_direction=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_4_direction.best_params_)
model_4_direction=grid_4_direction.best_estimator_
score.append(model_4_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline3,force'''

grid_4_force=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_4_force.best_params_)
model_4_force=grid_4_force.best_estimator_
score.append(model_4_force.score(X_test_force,y_test_force))

'''avec le pipeline3,humidite'''

grid_4_humidite=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_4_humidite.best_params_)
model_4_humidite=grid_4_humidite.best_estimator_
score.append(model_4_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline3,temperature'''

grid_4_temperature=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_4_temperature.best_params_)
model_4_temperature=grid_4_temperature.best_estimator_
score.append(model_4_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline3, pression'''

grid_4_pression=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_4_pression.best_params_)
model_4_pression=grid_4_pression.best_estimator_
score.append(model_4_pression.score(X_test_pression,y_test_pression))


tableau_data=pd.DataFrame([score])
tableau_data.to_csv('score_12H.csv',sep='\t')
print(score)
print(meilleurs_parametres)


N_direction,train_score_direction,val_score_direction=learning_curve(KNeighborsRegressor(),X_train_direction,y_train_direction,train_sizes=np.linspace(0.1,1,10),cv=5)
N_force,train_score_force,val_score_force=learning_curve(KNeighborsRegressor(),X_train_force,y_train_force,train_sizes=np.linspace(0.1,1,10),cv=5)
N_pression,train_score_pression,val_score_pression=learning_curve(KNeighborsRegressor(),X_train_pression,y_train_pression,train_sizes=np.linspace(0.1,1,10),cv=5)
N_humidite,train_score_humidite,val_score_humidite=learning_curve(KNeighborsRegressor(),X_train_humidite,y_train_humidite,train_sizes=np.linspace(0.1,1,10),cv=5)
N_temperature,train_score_temperature,val_score_temperature=learning_curve(KNeighborsRegressor(),X_train_temperature,y_train_temperature,train_sizes=np.linspace(0.1,1,10),cv=5)

plt.figure(figsize=[12,12])
plt.subplot(5,1,1)
plt.title("direction")
plt.plot(N_direction,train_score_direction.mean(axis=1),label='train')
plt.plot(N_direction,val_score_direction.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,2)
plt.title("force")
plt.plot(N_force,train_score_force.mean(axis=1),label='train')
plt.plot(N_force,val_score_force.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,3)
plt.title('pression')
plt.plot(N_pression,train_score_pression.mean(axis=1),label='train')
plt.plot(N_pression,val_score_pression.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,4)
plt.title('humidite')
plt.plot(N_humidite,train_score_humidite.mean(axis=1),label='train')
plt.plot(N_humidite,val_score_humidite.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,5)
plt.title('temperature')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='train')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()

Et voilà comment évoluent les moyennes des scores selon l’étendue de notre prévision (2 heures après, 4 heures après…on change à chaque fois l’indexation des colonnes pour les résultats attendus, de 5 en 5) :

En abscisse nous avons les heures des prédictions et en ordonnée les pourcentages de réussite sur les prédictions (par exemple 0.22 correspond à 22%). A première vue on distingue une certaine linéarité pour la force, l’humidité, la pression. Le reste c’est assez irrégulier mais pour la température ça peut s’expliquer car la variation est relativement faible pour chaque score. C’est assez rassurant on voit un lien entre les variables et le résultat attendu à priori, en tout cas pour celles où c’est à peu prêt linéaire.

Et maintenant la courbe d’apprentissage :

Un peu étrange….Les courbes ne se rejoignent pas, peut être parce que l’algo des k voisins « n’apprend pas » mais compare juste les données…A voir.

quand on regarde les paramètres ils changent beaucoup d’une variable à l’autre; les scores varient autour de 20% pour la direction,15% pour la force, 20% pour l’humidité, 80% pour la température et 60% pour la pression. Pas terrible…Aussi efficace qu’une prédiction de Paco Rabanne pour le moment. Voilà les scores en détail:

directionforcehumiditétempératurepression
sans traitement
25%17%17%59%48%
pipeline1
(MinMaxScaler)
19%13%23%84%63%
pipeline2
(RobustScaler)
18%9%25%82%67%
pipeline3
(StandardScaler)
18%8%25%84%67%

La régression linéaire

Pour bien comprendre comment ça marche allez sur youtube et regardez les vidéos consacrées à la régression linéaire sur la chaîne machine learnia, comme celle sur la descente de gradient. Voilà le programme :

import pandas as pd
import numpy as np
from datetime import datetime
import matplotlib.pyplot as plt
import seaborn as sns

Deauville=pd.read_csv('C:/Users/Psychopathe/Documents/Python Scripts/meteo/station maison/samedi24octobre/Deauville_le_retour.csv',sep='\t')

Deauville=Deauville.drop(['Unnamed: 0'],axis=1) # on vire la colonne inutile



variables=Deauville.iloc[:-1,:] # pour l'entrainement on garde tout sauf la dernière ligne.

résultat_dd=Deauville.iloc[1:,30] # pour la direction du vent, on vire la première ligne.
résultat_ff=Deauville.iloc[1:,31] # pour la force du vent, on vire aussi la première ligne.
résultat_hu=Deauville.iloc[1:,32] # pour l'humidité.
résultat_te=Deauville.iloc[1:,33] # pour la température.
résultat_pr=Deauville.iloc[1:,34] # pour la pression.



from sklearn.linear_model import LinearRegression# technique  regression simple.

from sklearn.model_selection import train_test_split # partage nos données en données test et entrainement (ratio réglé ici via test_size à 20%/80%)
from sklearn.model_selection import GridSearchCV # permet de trouver plus facilement les meilleurs paramètres de réglage du modèle.
from sklearn.model_selection import learning_curve # estime la limite de performance d'un modèle.

from sklearn.pipeline import make_pipeline # assemble un ou des transfomateurs de données et un estimateur, évite les fuites de données et réduit le code, donc évite les erreurs aussi.

from sklearn.preprocessing import MinMaxScaler # traitement de données, normalisation où nos variables deviennent comprises entre 0 et 1.
from sklearn.preprocessing import RobustScaler # traitement de données moins sujet aux outliers (échantillons aberrantes).
from sklearn.preprocessing import StandardScaler # traitement de donnée, rend la moyenne nulle et l'écart-type égal à un.

''' on sépare données entrainement et test pour toutes nos variables que l'on veut tester '''

X_train_direction,X_test_direction,y_train_direction,y_test_direction=train_test_split(variables,résultat_dd,test_size=0.2,random_state=0)
X_train_force,X_test_force,y_train_force,y_test_force=train_test_split(variables,résultat_ff,test_size=0.2,random_state=0)
X_train_humidite,X_test_humidite,y_train_humidite,y_test_humidite=train_test_split(variables,résultat_hu,test_size=0.2,random_state=0)
X_train_temperature,X_test_temperature,y_train_temperature,y_test_temperature=train_test_split(variables,résultat_te,test_size=0.2,random_state=0)
X_train_pression,X_test_pression,y_train_pression,y_test_pression=train_test_split(variables,résultat_pr,test_size=0.2,random_state=0)

traitement_1=make_pipeline(MinMaxScaler(),LinearRegression()) # création de l'objet pipeline1.
traitement_2=make_pipeline(RobustScaler(),LinearRegression()) # création du pipeline2.
traitement_3=make_pipeline(StandardScaler(),LinearRegression()) # création du pipeline3.

meilleurs_parametres=[]
score=[]

''' premier essai sans prétraitement, à poil , direction du vent   '''

param_grid={
    
    }

grid_1_direction=GridSearchCV(LinearRegression(),param_grid,cv=5)
grid_1_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_1_direction.best_params_)
model_1_direction=grid_1_direction.best_estimator_
score.append(model_1_direction.score(X_test_direction,y_test_direction))

''' à poil, force du vent '''

grid_1_force=GridSearchCV(LinearRegression(),param_grid,cv=5)
grid_1_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_1_force.best_params_)
model_1_force=grid_1_force.best_estimator_
score.append(model_1_force.score(X_test_force,y_test_force))

'''à poil, humidite  '''

grid_1_humidite=GridSearchCV(LinearRegression(),param_grid,cv=5)
grid_1_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_1_humidite.best_params_)
model_1_humidite=grid_1_humidite.best_estimator_
score.append(model_1_humidite.score(X_test_humidite,y_test_humidite))

''' à poil, temperature '''
grid_1_temperature=GridSearchCV(LinearRegression(),param_grid,cv=5)
grid_1_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_1_temperature.best_params_)
model_1_temperature=grid_1_temperature.best_estimator_
score.append(model_1_temperature.score(X_test_temperature,y_test_temperature))

''' à poil, pression'''

grid_1_pression=GridSearchCV(LinearRegression(),param_grid,cv=5)
grid_1_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_1_pression.best_params_)
model_1_pression=grid_1_pression.best_estimator_
score.append(model_1_pression.score(X_test_pression,y_test_pression))



''' avec le pipeline1, direction'''

param_grid2={
    
    }

grid_2_direction=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_2_direction.best_params_)
model_2_direction=grid_2_direction.best_estimator_
score.append(model_2_direction.score(X_test_direction,y_test_direction))

''' avec le pipeline1, force '''

grid_2_force=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_2_force.best_params_)
model_2_force=grid_2_force.best_estimator_
score.append(model_2_force.score(X_test_force,y_test_force))

''' avec le pipeline1, humidite  '''

grid_2_humidite=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_2_humidite.best_params_)
model_2_humidite=grid_2_humidite.best_estimator_
score.append(model_2_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline1, temperature'''

grid_2_temperature=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_2_temperature.best_params_)
model_2_temperature=grid_2_temperature.best_estimator_
score.append(model_2_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline1, pression'''

grid_2_pression=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_2_pression.best_params_)
model_2_pression=grid_2_pression.best_estimator_
score.append(model_2_pression.score(X_test_pression,y_test_pression))


'''avec le pipeline2, direction'''

grid_3_direction=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_3_direction.best_params_)
model_3_direction=grid_3_direction.best_estimator_
score.append(model_3_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline2, force'''

grid_3_force=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_3_force.best_params_)
model_3_force=grid_3_force.best_estimator_
score.append(model_3_force.score(X_test_force,y_test_force))

'''avec le pipeline2, humidite'''

grid_3_humidite=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_3_humidite.best_params_)
model_3_humidite=grid_3_humidite.best_estimator_
score.append(model_3_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline2,temperature'''

grid_3_temperature=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_3_temperature.best_params_)
model_3_temperature=grid_3_temperature.best_estimator_
score.append(model_3_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline2,pression'''

grid_3_pression=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_3_pression.best_params_)
model_3_pression=grid_3_pression.best_estimator_
score.append(model_3_pression.score(X_test_pression,y_test_pression))

'''avec le pipeline3,direction'''

grid_4_direction=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_4_direction.best_params_)
model_4_direction=grid_4_direction.best_estimator_
score.append(model_4_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline3,force'''

grid_4_force=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_4_force.best_params_)
model_4_force=grid_4_force.best_estimator_
score.append(model_4_force.score(X_test_force,y_test_force))

'''avec le pipeline3,humidite'''

grid_4_humidite=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_4_humidite.best_params_)
model_4_humidite=grid_4_humidite.best_estimator_
score.append(model_4_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline3,temperature'''

grid_4_temperature=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_4_temperature.best_params_)
model_4_temperature=grid_4_temperature.best_estimator_
score.append(model_4_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline3, pression'''

grid_4_pression=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_4_pression.best_params_)
model_4_pression=grid_4_pression.best_estimator_
score.append(model_4_pression.score(X_test_pression,y_test_pression))


tableau_data=pd.DataFrame([score])
tableau_data.to_csv('score_12H.csv',sep='\t')
print(score)
print(meilleurs_parametres)


N_direction,train_score_direction,val_score_direction=learning_curve(LinearRegression(),X_train_direction,y_train_direction,train_sizes=np.linspace(0.1,1,10),cv=5)
N_force,train_score_force,val_score_force=learning_curve(LinearRegression(),X_train_force,y_train_force,train_sizes=np.linspace(0.1,1,10),cv=5)
N_pression,train_score_pression,val_score_pression=learning_curve(LinearRegression(),X_train_pression,y_train_pression,train_sizes=np.linspace(0.1,1,10),cv=5)
N_humidite,train_score_humidite,val_score_humidite=learning_curve(LinearRegression(),X_train_humidite,y_train_humidite,train_sizes=np.linspace(0.1,1,10),cv=5)
N_temperature,train_score_temperature,val_score_temperature=learning_curve(LinearRegression(),X_train_temperature,y_train_temperature,train_sizes=np.linspace(0.1,1,10),cv=5)

plt.figure(figsize=[12,12])
plt.subplot(5,1,1)
plt.title("direction")
plt.plot(N_direction,train_score_direction.mean(axis=1),label='train')
plt.plot(N_direction,val_score_direction.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,2)
plt.title("force")
plt.plot(N_force,train_score_force.mean(axis=1),label='train')
plt.plot(N_force,val_score_force.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,3)
plt.title('pression')
plt.plot(N_pression,train_score_pression.mean(axis=1),label='train')
plt.plot(N_pression,val_score_pression.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,4)
plt.title('humidite')
plt.plot(N_humidite,train_score_humidite.mean(axis=1),label='train')
plt.plot(N_humidite,val_score_humidite.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,5)
plt.title('temperature')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='train')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()

Comme vous pouvez le constater, les grilles des paramètres sont vides car il n’y a pas (à ma connaissance) de paramètres à ajuster pour la régression linéaire simple.

Et maintenant les résultats selon l’étendue de la prévision:

A première vue le constat est à peu prêt identique par rapport aux proches voisins, par contre la température semble plus linéaire.

Et maintenant voilà les courbes d’apprentissage pour la régression:

Pour les 4 premières variables on remarque une montée rapide de la validation jusqu’à environ 130 échantillons, ensuite ça devient bien plus lent. Pour la température c’est l’inverse jusqu’à 130 échantillons ça descend progressivement, ensuite ça met plus de temps à baisser.

Quand on observe nos résultats, ils ne varient quasiment pas entre nos données non traitées et nos données traitées, à chaque fois on a ça:

variablesdirectionforcehumiditétemperaturepression
scores en %20%19%18%86%85%

Bon ça reste aussi prédictif qu’un retard SNCF pour le moment.

La régression Ridge

Ce type de régression fonctionne comme celle d’avant sauf que le système va chercher à minimiser les poids au maximum. C’est une méthode particulièrement intéressante pour éviter le surapprentissage des modèles. Pour le programme c’est presque comme la régression sauf que là on peut jouer avec le paramètre alpha, présent cette fois dans les paramètres de grille:

import pandas as pd
import numpy as np
from datetime import datetime
import matplotlib.pyplot as plt
import seaborn as sns

Deauville=pd.read_csv('C:/Users/Psychopathe/Documents/Python Scripts/meteo/station maison/samedi24octobre/Deauville_le_retour.csv',sep='\t')

Deauville=Deauville.drop(['Unnamed: 0'],axis=1) # on vire la colonne inutile



variables=Deauville.iloc[:-1,:] # pour l'entrainement on garde tout sauf la dernière ligne.

résultat_dd=Deauville.iloc[1:,30] # pour la direction du vent, on vire la première ligne.
résultat_ff=Deauville.iloc[1:,31] # pour la force du vent, on vire aussi la première ligne.
résultat_hu=Deauville.iloc[1:,32] # pour l'humidité.
résultat_te=Deauville.iloc[1:,33] # pour la température.
résultat_pr=Deauville.iloc[1:,34] # pour la pression.



from sklearn.linear_model import Ridge# technique  regression ridge.

from sklearn.model_selection import train_test_split # partage nos données en données test et entrainement (ratio réglé ici via test_size à 20%/80%)
from sklearn.model_selection import GridSearchCV # permet de trouver plus facilement les meilleurs paramètres de réglage du modèle.
from sklearn.model_selection import learning_curve # estime la limite de performance d'un modèle.

from sklearn.pipeline import make_pipeline # assemble un ou des transfomateurs de données et un estimateur, évite les fuites de données et réduit le code, donc évite les erreurs aussi.

from sklearn.preprocessing import MinMaxScaler # traitement de données, normalisation où nos variables deviennent comprises entre 0 et 1.
from sklearn.preprocessing import RobustScaler # traitement de données moins sujet aux outliers (échantillons aberrantes).
from sklearn.preprocessing import StandardScaler # traitement de donnée, rend la moyenne nulle et l'écart-type égal à un.

''' on sépare données entrainement et test pour toutes nos variables que l'on veut tester '''

X_train_direction,X_test_direction,y_train_direction,y_test_direction=train_test_split(variables,résultat_dd,test_size=0.2,random_state=0)
X_train_force,X_test_force,y_train_force,y_test_force=train_test_split(variables,résultat_ff,test_size=0.2,random_state=0)
X_train_humidite,X_test_humidite,y_train_humidite,y_test_humidite=train_test_split(variables,résultat_hu,test_size=0.2,random_state=0)
X_train_temperature,X_test_temperature,y_train_temperature,y_test_temperature=train_test_split(variables,résultat_te,test_size=0.2,random_state=0)
X_train_pression,X_test_pression,y_train_pression,y_test_pression=train_test_split(variables,résultat_pr,test_size=0.2,random_state=0)

traitement_1=make_pipeline(MinMaxScaler(),Ridge()) # création de l'objet pipeline1.
traitement_2=make_pipeline(RobustScaler(),Ridge()) # création du pipeline2.
traitement_3=make_pipeline(StandardScaler(),Ridge()) # création du pipeline3.

meilleurs_parametres=[]
score=[]

''' premier essai sans prétraitement, à poil , direction du vent   '''

param_grid={
    'alpha':[10,1,0.1,0.01,0.001]
    }

grid_1_direction=GridSearchCV(Ridge(),param_grid,cv=5)
grid_1_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_1_direction.best_params_)
model_1_direction=grid_1_direction.best_estimator_
score.append(model_1_direction.score(X_test_direction,y_test_direction))

''' à poil, force du vent '''

grid_1_force=GridSearchCV(Ridge(),param_grid,cv=5)
grid_1_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_1_force.best_params_)
model_1_force=grid_1_force.best_estimator_
score.append(model_1_force.score(X_test_force,y_test_force))

'''à poil, humidite  '''

grid_1_humidite=GridSearchCV(Ridge(),param_grid,cv=5)
grid_1_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_1_humidite.best_params_)
model_1_humidite=grid_1_humidite.best_estimator_
score.append(model_1_humidite.score(X_test_humidite,y_test_humidite))

''' à poil, temperature '''
grid_1_temperature=GridSearchCV(Ridge(),param_grid,cv=5)
grid_1_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_1_temperature.best_params_)
model_1_temperature=grid_1_temperature.best_estimator_
score.append(model_1_temperature.score(X_test_temperature,y_test_temperature))

''' à poil, pression'''

grid_1_pression=GridSearchCV(Ridge(),param_grid,cv=5)
grid_1_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_1_pression.best_params_)
model_1_pression=grid_1_pression.best_estimator_
score.append(model_1_pression.score(X_test_pression,y_test_pression))



''' avec le pipeline1, direction'''

param_grid2={
    'ridge__alpha':[10,1,0.1,0.01,0.001]
    }

grid_2_direction=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_2_direction.best_params_)
model_2_direction=grid_2_direction.best_estimator_
score.append(model_2_direction.score(X_test_direction,y_test_direction))

''' avec le pipeline1, force '''

grid_2_force=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_2_force.best_params_)
model_2_force=grid_2_force.best_estimator_
score.append(model_2_force.score(X_test_force,y_test_force))

''' avec le pipeline1, humidite  '''

grid_2_humidite=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_2_humidite.best_params_)
model_2_humidite=grid_2_humidite.best_estimator_
score.append(model_2_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline1, temperature'''

grid_2_temperature=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_2_temperature.best_params_)
model_2_temperature=grid_2_temperature.best_estimator_
score.append(model_2_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline1, pression'''

grid_2_pression=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_2_pression.best_params_)
model_2_pression=grid_2_pression.best_estimator_
score.append(model_2_pression.score(X_test_pression,y_test_pression))


'''avec le pipeline2, direction'''

grid_3_direction=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_3_direction.best_params_)
model_3_direction=grid_3_direction.best_estimator_
score.append(model_3_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline2, force'''

grid_3_force=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_3_force.best_params_)
model_3_force=grid_3_force.best_estimator_
score.append(model_3_force.score(X_test_force,y_test_force))

'''avec le pipeline2, humidite'''

grid_3_humidite=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_3_humidite.best_params_)
model_3_humidite=grid_3_humidite.best_estimator_
score.append(model_3_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline2,temperature'''

grid_3_temperature=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_3_temperature.best_params_)
model_3_temperature=grid_3_temperature.best_estimator_
score.append(model_3_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline2,pression'''

grid_3_pression=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_3_pression.best_params_)
model_3_pression=grid_3_pression.best_estimator_
score.append(model_3_pression.score(X_test_pression,y_test_pression))

'''avec le pipeline3,direction'''

grid_4_direction=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_4_direction.best_params_)
model_4_direction=grid_4_direction.best_estimator_
score.append(model_4_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline3,force'''

grid_4_force=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_4_force.best_params_)
model_4_force=grid_4_force.best_estimator_
score.append(model_4_force.score(X_test_force,y_test_force))

'''avec le pipeline3,humidite'''

grid_4_humidite=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_4_humidite.best_params_)
model_4_humidite=grid_4_humidite.best_estimator_
score.append(model_4_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline3,temperature'''

grid_4_temperature=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_4_temperature.best_params_)
model_4_temperature=grid_4_temperature.best_estimator_
score.append(model_4_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline3, pression'''

grid_4_pression=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_4_pression.best_params_)
model_4_pression=grid_4_pression.best_estimator_
score.append(model_4_pression.score(X_test_pression,y_test_pression))


tableau_data=pd.DataFrame([score])
tableau_data.to_csv('scoreridge_12H.csv',sep='\t')
print(score)
print(meilleurs_parametres)

"""
N_direction,train_score_direction,val_score_direction=learning_curve(Ridge(),X_train_direction,y_train_direction,train_sizes=np.linspace(0.1,1,10),cv=5)
N_force,train_score_force,val_score_force=learning_curve(Ridge(),X_train_force,y_train_force,train_sizes=np.linspace(0.1,1,10),cv=5)
N_pression,train_score_pression,val_score_pression=learning_curve(Ridge(),X_train_pression,y_train_pression,train_sizes=np.linspace(0.1,1,10),cv=5)
N_humidite,train_score_humidite,val_score_humidite=learning_curve(Ridge(),X_train_humidite,y_train_humidite,train_sizes=np.linspace(0.1,1,10),cv=5)
N_temperature,train_score_temperature,val_score_temperature=learning_curve(Ridge(),X_train_temperature,y_train_temperature,train_sizes=np.linspace(0.1,1,10),cv=5)

plt.figure(figsize=[12,12])
plt.subplot(5,1,1)
plt.title("direction")
plt.plot(N_direction,train_score_direction.mean(axis=1),label='train')
plt.plot(N_direction,val_score_direction.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,2)
plt.title("force")
plt.plot(N_force,train_score_force.mean(axis=1),label='train')
plt.plot(N_force,val_score_force.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,3)
plt.title('pression')
plt.plot(N_pression,train_score_pression.mean(axis=1),label='train')
plt.plot(N_pression,val_score_pression.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,4)
plt.title('humidite')
plt.plot(N_humidite,train_score_humidite.mean(axis=1),label='train')
plt.plot(N_humidite,val_score_humidite.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,5)
plt.title('temperature')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='train')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()

Et maintenant les courbes des scores selon les heures de prédiction:

On voit bien la linéarité pour nos variables, pour la direction ça reste un peu les montagnes russes par contre. Ensuite on va pouvoir voir les courbes d’apprentissage du modèle Ridge:

A première vue ça ressemble assez à la régression linéaire simple, avec peut-être une progression un peu moins tranchée aux alentour des 130 écahntillons. Les résultats des scores à 12 heures selon les traitements maintenant:

directionforcehumiditétempératurepression
sans traitement20%19%19%86%85%
MinMaxScaler25%17%21%86%85%
RobustScaler23%20%20%86%85%
StandardScaler22%20%20%86%85%

Pour les meilleurs paramètres on a alpha à 10 très souvent, un peu à 1 et une fois à 0.01.

La régression Lasso

Ce modèle va cette fois descendre à 0 les poids « inutiles ». Pratique pour identifier les variables qui sont vraiment utiles des variables inutiles pour nos prédictions…Programme:

import pandas as pd
import numpy as np
from datetime import datetime
import matplotlib.pyplot as plt
import seaborn as sns

Deauville=pd.read_csv('C:/Users/Psychopathe/Documents/Python Scripts/meteo/station maison/samedi24octobre/Deauville_le_retour.csv',sep='\t')

Deauville=Deauville.drop(['Unnamed: 0'],axis=1) # on vire la colonne inutile



variables=Deauville.iloc[:-1,:] # pour l'entrainement on garde tout sauf la dernière ligne.

résultat_dd=Deauville.iloc[1:,30] # pour la direction du vent, on vire la première ligne.
résultat_ff=Deauville.iloc[1:,31] # pour la force du vent, on vire aussi la première ligne.
résultat_hu=Deauville.iloc[1:,32] # pour l'humidité.
résultat_te=Deauville.iloc[1:,33] # pour la température.
résultat_pr=Deauville.iloc[1:,34] # pour la pression.



from sklearn.linear_model import Lasso# technique  regression lasso.

from sklearn.model_selection import train_test_split # partage nos données en données test et entrainement (ratio réglé ici via test_size à 20%/80%)
from sklearn.model_selection import GridSearchCV # permet de trouver plus facilement les meilleurs paramètres de réglage du modèle.
from sklearn.model_selection import learning_curve # estime la limite de performance d'un modèle.

from sklearn.pipeline import make_pipeline # assemble un ou des transfomateurs de données et un estimateur, évite les fuites de données et réduit le code, donc évite les erreurs aussi.

from sklearn.preprocessing import MinMaxScaler # traitement de données, normalisation où nos variables deviennent comprises entre 0 et 1.
from sklearn.preprocessing import RobustScaler # traitement de données moins sujet aux outliers (échantillons aberrantes).
from sklearn.preprocessing import StandardScaler # traitement de donnée, rend la moyenne nulle et l'écart-type égal à un.

''' on sépare données entrainement et test pour toutes nos variables que l'on veut tester '''

X_train_direction,X_test_direction,y_train_direction,y_test_direction=train_test_split(variables,résultat_dd,test_size=0.2,random_state=0)
X_train_force,X_test_force,y_train_force,y_test_force=train_test_split(variables,résultat_ff,test_size=0.2,random_state=0)
X_train_humidite,X_test_humidite,y_train_humidite,y_test_humidite=train_test_split(variables,résultat_hu,test_size=0.2,random_state=0)
X_train_temperature,X_test_temperature,y_train_temperature,y_test_temperature=train_test_split(variables,résultat_te,test_size=0.2,random_state=0)
X_train_pression,X_test_pression,y_train_pression,y_test_pression=train_test_split(variables,résultat_pr,test_size=0.2,random_state=0)

traitement_1=make_pipeline(MinMaxScaler(),Lasso()) # création de l'objet pipeline1.
traitement_2=make_pipeline(RobustScaler(),Lasso()) # création du pipeline2.
traitement_3=make_pipeline(StandardScaler(),Lasso()) # création du pipeline3.

meilleurs_parametres=[]
score=[]
v_u=[]

''' premier essai sans prétraitement, à poil , direction du vent   '''

param_grid={
    'alpha':[10,1,0.1,0.01,0.001],
    'max_iter':[100000]
    }

grid_1_direction=GridSearchCV(Lasso(),param_grid,cv=5)
grid_1_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_1_direction.best_params_)
model_1_direction=grid_1_direction.best_estimator_
score.append(model_1_direction.score(X_test_direction,y_test_direction))
v_u.append(np.sum(model_1_direction.coef_!=0))

''' à poil, force du vent '''

grid_1_force=GridSearchCV(Lasso(),param_grid,cv=5)
grid_1_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_1_force.best_params_)
model_1_force=grid_1_force.best_estimator_
score.append(model_1_force.score(X_test_force,y_test_force))
v_u.append(np.sum(model_1_force.coef_!=0))

'''à poil, humidite  '''

grid_1_humidite=GridSearchCV(Lasso(),param_grid,cv=5)
grid_1_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_1_humidite.best_params_)
model_1_humidite=grid_1_humidite.best_estimator_
score.append(model_1_humidite.score(X_test_humidite,y_test_humidite))
v_u.append(np.sum(model_1_humidite.coef_!=0))

''' à poil, temperature '''
grid_1_temperature=GridSearchCV(Lasso(),param_grid,cv=5)
grid_1_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_1_temperature.best_params_)
model_1_temperature=grid_1_temperature.best_estimator_
score.append(model_1_temperature.score(X_test_temperature,y_test_temperature))
v_u.append(np.sum(model_1_temperature.coef_!=0))

''' à poil, pression'''

grid_1_pression=GridSearchCV(Lasso(),param_grid,cv=5)
grid_1_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_1_pression.best_params_)
model_1_pression=grid_1_pression.best_estimator_
score.append(model_1_pression.score(X_test_pression,y_test_pression))
v_u.append(np.sum(model_1_pression.coef_!=0))

print(score)
print(meilleurs_parametres)
print(v_u)
print(model_1_direction.coef_)
print(model_1_force.coef_)
print(model_1_humidite.coef_)
print(model_1_temperature.coef_)
print(model_1_pression.coef_)


''' avec le pipeline1, direction'''

param_grid2={
    'lasso__alpha':[10,1,0.1,0.01,0.001],
    'lasso__max_iter':[100000]
    }

grid_2_direction=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_2_direction.best_params_)
model_2_direction=grid_2_direction.best_estimator_
score.append(model_2_direction.score(X_test_direction,y_test_direction))


''' avec le pipeline1, force '''

grid_2_force=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_2_force.best_params_)
model_2_force=grid_2_force.best_estimator_
score.append(model_2_force.score(X_test_force,y_test_force))

''' avec le pipeline1, humidite  '''

grid_2_humidite=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_2_humidite.best_params_)
model_2_humidite=grid_2_humidite.best_estimator_
score.append(model_2_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline1, temperature'''

grid_2_temperature=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_2_temperature.best_params_)
model_2_temperature=grid_2_temperature.best_estimator_
score.append(model_2_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline1, pression'''

grid_2_pression=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_2_pression.best_params_)
model_2_pression=grid_2_pression.best_estimator_
score.append(model_2_pression.score(X_test_pression,y_test_pression))


'''avec le pipeline2, direction'''

grid_3_direction=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_3_direction.best_params_)
model_3_direction=grid_3_direction.best_estimator_
score.append(model_3_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline2, force'''

grid_3_force=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_3_force.best_params_)
model_3_force=grid_3_force.best_estimator_
score.append(model_3_force.score(X_test_force,y_test_force))

'''avec le pipeline2, humidite'''

grid_3_humidite=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_3_humidite.best_params_)
model_3_humidite=grid_3_humidite.best_estimator_
score.append(model_3_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline2,temperature'''

grid_3_temperature=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_3_temperature.best_params_)
model_3_temperature=grid_3_temperature.best_estimator_
score.append(model_3_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline2,pression'''

grid_3_pression=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_3_pression.best_params_)
model_3_pression=grid_3_pression.best_estimator_
score.append(model_3_pression.score(X_test_pression,y_test_pression))

'''avec le pipeline3,direction'''

grid_4_direction=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_direction.fit(X_train_direction,y_train_direction)
meilleurs_parametres.append(grid_4_direction.best_params_)
model_4_direction=grid_4_direction.best_estimator_
score.append(model_4_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline3,force'''

grid_4_force=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_force.fit(X_train_force,y_train_force)
meilleurs_parametres.append(grid_4_force.best_params_)
model_4_force=grid_4_force.best_estimator_
score.append(model_4_force.score(X_test_force,y_test_force))


'''avec le pipeline3,humidite'''

grid_4_humidite=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_humidite.fit(X_train_humidite,y_train_humidite)
meilleurs_parametres.append(grid_4_humidite.best_params_)
model_4_humidite=grid_4_humidite.best_estimator_
score.append(model_4_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline3,temperature'''

grid_4_temperature=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_temperature.fit(X_train_temperature,y_train_temperature)
meilleurs_parametres.append(grid_4_temperature.best_params_)
model_4_temperature=grid_4_temperature.best_estimator_
score.append(model_4_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline3, pression'''

grid_4_pression=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_pression.fit(X_train_pression,y_train_pression)
meilleurs_parametres.append(grid_4_pression.best_params_)
model_4_pression=grid_4_pression.best_estimator_
score.append(model_4_pression.score(X_test_pression,y_test_pression))


tableau_data=pd.DataFrame([score])
tableau_data.to_csv('scorelasso_12H.csv',sep='\t')
print(score)
print(meilleurs_parametres)
print(v_u)

N_direction,train_score_direction,val_score_direction=learning_curve(Lasso(),X_train_direction,y_train_direction,train_sizes=np.linspace(0.1,1,10),cv=5)
N_force,train_score_force,val_score_force=learning_curve(Lasso(),X_train_force,y_train_force,train_sizes=np.linspace(0.1,1,10),cv=5)
N_pression,train_score_pression,val_score_pression=learning_curve(Lasso(),X_train_pression,y_train_pression,train_sizes=np.linspace(0.1,1,10),cv=5)
N_humidite,train_score_humidite,val_score_humidite=learning_curve(Lasso(),X_train_humidite,y_train_humidite,train_sizes=np.linspace(0.1,1,10),cv=5)
N_temperature,train_score_temperature,val_score_temperature=learning_curve(Lasso(),X_train_temperature,y_train_temperature,train_sizes=np.linspace(0.1,1,10),cv=5)

plt.figure(figsize=[12,12])
plt.subplot(5,1,1)
plt.title("direction")
plt.plot(N_direction,train_score_direction.mean(axis=1),label='train')
plt.plot(N_direction,val_score_direction.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,2)
plt.title("force")
plt.plot(N_force,train_score_force.mean(axis=1),label='train')
plt.plot(N_force,val_score_force.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,3)
plt.title('pression')
plt.plot(N_pression,train_score_pression.mean(axis=1),label='train')
plt.plot(N_pression,val_score_pression.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,4)
plt.title('humidite')
plt.plot(N_humidite,train_score_humidite.mean(axis=1),label='train')
plt.plot(N_humidite,val_score_humidite.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,5)
plt.title('temperature')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='train')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()

Les courbes scores sont presque pareilles, donc passons aux courbes d’apprentissage:

La courbe de validation se fait de façon encore plus progressive.

Voici les résultats trouvé pour une prédiction à 12 heures selon les divers traitements:

directionforcehumiditétempératurepression
sans traitement24%21%21%86%85%
MinMaxScaler25%18%24%86%85%
RobustScaler25%20%23%81%86%
StandardScaler24%20%22%86%85%

Et maintenant comme on a vu avant, avec le mode lasso on peut savoir quelles variables comptent pour nous, on a alors ça:

directionforcehumiditétempératurepression
nombre de variables utilisées pour la prédiction2541294050

J’ai fait le test pour des heures de prédiction plus proches et moins proches, ça varie mais ça reste aux alentours des mêmes valeurs grosso modo. La direction du vent utilise moins de variables. En exécutant le code on voit les variables « jetées » dans les arrays. Il faudra que je regarde tout ça plus en détail pour la suite.

Les forêts aléatoires

Pour avoir une bonne explication du bidule , allez sur wikipépé ou d’autres liens parce que je crois que je vais dire des conneries…Bon temps pis je me lance: on sélectionne un nombre d’arbres de décision pour notre forêt, pour chaque arbre on pioche au hasard des échantillon dans nos données. Du coup chaque arbre va être un peu différend des autres lors de leur construction à l’entrainement. Ensuite pour la prédiction on fait la moyenne (ou la majorité je ne sais plus) des résultats trouvés par nos arbres. Le prog ça donne ça:

from sklearn.ensemble import RandomForestRegressor # technique des forêts aléatoires pour les regressions.

from sklearn.model_selection import train_test_split # partage nos données en données test et entrainement (ratio réglé ici via test_size à 20%/80%)
from sklearn.model_selection import GridSearchCV # permet de trouver plus facilement les meilleurs paramètres de réglage du modèle.
from sklearn.model_selection import learning_curve # estime la limite de performance d'un modèle.

from sklearn.pipeline import make_pipeline # assemble un ou des transfomateurs de données et un estimateur, évite les fuites de données et réduit le code, donc évite les erreurs aussi.

from sklearn.preprocessing import MinMaxScaler # traitement de données, normalisation où nos variables deviennent comprises entre 0 et 1.
from sklearn.preprocessing import RobustScaler # traitement de données moins sujet aux outliers (échantillons aberrantes).
from sklearn.preprocessing import StandardScaler # traitement de donnée, rend la moyenne nulle et l'écart-type égal à un.


import numpy as np # permet de manipuler les array.
import pandas as pd # permet de manipuler les dataframes.

import matplotlib.pyplot as plt

deauville3=pd.read_csv('C:/Users/Psychopathe/Documents/Python Scripts/meteo/station maison/samedi24octobre/Deauville_le_retour.csv',sep='\t') # on importe les données.

deauville3=deauville3.drop(['Unnamed: 0'],axis=1) # on vire la colonne inutile pour pas pourrir l'entrainement du modèle.

Vars_training=deauville3.iloc[:-1,:] # les données d'entrainements sont reprises sauf la dernière ligne pour ajuster le nombre de lignes entre les données et les variables cibles.
direction_train=deauville3.iloc[1:,30] # données cibles. Ici c'est la direction du vent 6 heures après.
force_train=deauville3.iloc[1:,31] # données cibles. Ici c'est la force du vent 6 heures après.
humidite_train=deauville3.iloc[1:,32] # données cibles, ici pourcentage d'humidité 6 heures après.
temperature_train=deauville3.iloc[1:,33] # données cibles, ici la température 6 heures après.
pression_train=deauville3.iloc[1:,34] # données cibles, ici la pression atmosphérique 6 heures après.

''' on sépare données entrainement et test pour toutes nos variables que l'on veut tester '''

X_train_direction,X_test_direction,y_train_direction,y_test_direction=train_test_split(Vars_training,direction_train,test_size=0.2,random_state=0)
X_train_force,X_test_force,y_train_force,y_test_force=train_test_split(Vars_training,force_train,test_size=0.2,random_state=0)
X_train_humidite,X_test_humidite,y_train_humidite,y_test_humidite=train_test_split(Vars_training,humidite_train,test_size=0.2,random_state=0)
X_train_temperature,X_test_temperature,y_train_temperature,y_test_temperature=train_test_split(Vars_training,temperature_train,test_size=0.2,random_state=0)
X_train_pression,X_test_pression,y_train_pression,y_test_pression=train_test_split(Vars_training,pression_train,test_size=0.2,random_state=0)

traitement_1=make_pipeline(MinMaxScaler(),RandomForestRegressor()) # création de l'objet pipeline1.
traitement_2=make_pipeline(RobustScaler(),RandomForestRegressor()) # création du pipeline2.
traitement_3=make_pipeline(StandardScaler(),RandomForestRegressor()) # création du pipeline3.

''' premier essai sans prétraitement, à poil , direction du vent   '''

param_grid={
    'n_estimators':[5,10,50,100,150,200],
    
    
    }

grid_1_direction=GridSearchCV(RandomForestRegressor(),param_grid,cv=5)
grid_1_direction.fit(X_train_direction,y_train_direction)
print(grid_1_direction.best_params_)
model_1_direction=grid_1_direction.best_estimator_
print(model_1_direction.score(X_test_direction,y_test_direction))

''' à poil, force du vent '''

grid_1_force=GridSearchCV(RandomForestRegressor(),param_grid,cv=5)
grid_1_force.fit(X_train_force,y_train_force)
print(grid_1_force.best_params_)
model_1_force=grid_1_force.best_estimator_
print(model_1_force.score(X_test_force,y_test_force))

'''à poil, humidite  '''

grid_1_humidite=GridSearchCV(RandomForestRegressor(),param_grid,cv=5)
grid_1_humidite.fit(X_train_humidite,y_train_humidite)
print(grid_1_humidite.best_params_)
model_1_humidite=grid_1_humidite.best_estimator_
print(model_1_humidite.score(X_test_humidite,y_test_humidite))

''' à poil, temperature '''
grid_1_temperature=GridSearchCV(RandomForestRegressor(),param_grid,cv=5)
grid_1_temperature.fit(X_train_temperature,y_train_temperature)
print(grid_1_temperature.best_params_)
model_1_temperature=grid_1_temperature.best_estimator_
print(model_1_temperature.score(X_test_temperature,y_test_temperature))

''' à poil, pression'''

grid_1_pression=GridSearchCV(RandomForestRegressor(),param_grid,cv=5)
grid_1_pression.fit(X_train_pression,y_train_pression)
print(grid_1_pression.best_params_)
model_1_pression=grid_1_pression.best_estimator_
print(model_1_pression.score(X_test_pression,y_test_pression))


''' avec le pipeline1, direction'''

param_grid2={
    'randomforestregressor__n_estimators':[5,10,50,100,150,200]
    }

grid_2_direction=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_direction.fit(X_train_direction,y_train_direction)
print(grid_2_direction.best_params_)
model_2_direction=grid_2_direction.best_estimator_
print(model_2_direction.score(X_test_direction,y_test_direction))

''' avec le pipeline1, force '''

grid_2_force=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_force.fit(X_train_force,y_train_force)
print(grid_2_force.best_params_)
model_2_force=grid_2_force.best_estimator_
print(model_2_force.score(X_test_force,y_test_force))

''' avec le pipeline1, humidite  '''

grid_2_humidite=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_humidite.fit(X_train_humidite,y_train_humidite)
print(grid_2_humidite.best_params_)
model_2_humidite=grid_2_humidite.best_estimator_
print(model_2_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline1, temperature'''

grid_2_temperature=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_temperature.fit(X_train_temperature,y_train_temperature)
print(grid_2_temperature.best_params_)
model_2_temperature=grid_2_temperature.best_estimator_
print(model_2_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline1, pression'''

grid_2_pression=GridSearchCV(traitement_1,param_grid2,cv=5)
grid_2_pression.fit(X_train_pression,y_train_pression)
print(grid_2_pression.best_params_)
model_2_pression=grid_2_pression.best_estimator_
print(model_2_pression.score(X_test_pression,y_test_pression))

'''avec le pipeline2, direction'''

grid_3_direction=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_direction.fit(X_train_direction,y_train_direction)
print(grid_3_direction.best_params_)
model_3_direction=grid_3_direction.best_estimator_
print(model_3_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline2, force'''

grid_3_force=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_force.fit(X_train_force,y_train_force)
print(grid_3_force.best_params_)
model_3_force=grid_3_force.best_estimator_
print(model_3_force.score(X_test_force,y_test_force))

'''avec le pipeline2, humidite'''

grid_3_humidite=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_humidite.fit(X_train_humidite,y_train_humidite)
print(grid_3_humidite.best_params_)
model_3_humidite=grid_3_humidite.best_estimator_
print(model_3_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline2,temperature'''

grid_3_temperature=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_temperature.fit(X_train_temperature,y_train_temperature)
print(grid_3_temperature.best_params_)
model_3_temperature=grid_3_temperature.best_estimator_
print(model_3_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline2,pression'''

grid_3_pression=GridSearchCV(traitement_2,param_grid2,cv=5)
grid_3_pression.fit(X_train_pression,y_train_pression)
print(grid_3_pression.best_params_)
model_3_pression=grid_3_pression.best_estimator_
print(model_3_pression.score(X_test_pression,y_test_pression))

'''avec le pipeline3,direction'''

grid_4_direction=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_direction.fit(X_train_direction,y_train_direction)
print(grid_4_direction.best_params_)
model_4_direction=grid_4_direction.best_estimator_
print(model_4_direction.score(X_test_direction,y_test_direction))

'''avec le pipeline3,force'''

grid_4_force=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_force.fit(X_train_force,y_train_force)
print(grid_4_force.best_params_)
model_4_force=grid_4_force.best_estimator_
print(model_4_force.score(X_test_force,y_test_force))

'''avec le pipeline3,humidite'''

grid_4_humidite=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_humidite.fit(X_train_humidite,y_train_humidite)
print(grid_4_humidite.best_params_)
model_4_humidite=grid_4_humidite.best_estimator_
print(model_4_humidite.score(X_test_humidite,y_test_humidite))

'''avec le pipeline3,temperature'''

grid_4_temperature=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_temperature.fit(X_train_temperature,y_train_temperature)
print(grid_4_temperature.best_params_)
model_4_temperature=grid_4_temperature.best_estimator_
print(model_4_temperature.score(X_test_temperature,y_test_temperature))

'''avec le pipeline3, pression'''

grid_4_pression=GridSearchCV(traitement_3,param_grid2,cv=5)
grid_4_pression.fit(X_train_pression,y_train_pression)
print(grid_4_pression.best_params_)
model_4_pression=grid_4_pression.best_estimator_
print(model_4_pression.score(X_test_pression,y_test_pression))




N_direction,train_score_direction,val_score_direction=learning_curve(traitement_1,X_train_direction,y_train_direction,train_sizes=np.linspace(0.1,1,10),cv=5)
N_force,train_score_force,val_score_force=learning_curve(traitement_1,X_train_force,y_train_force,train_sizes=np.linspace(0.1,1,10),cv=5)
N_pression,train_score_pression,val_score_pression=learning_curve(traitement_1,X_train_pression,y_train_pression,train_sizes=np.linspace(0.1,1,10),cv=5)
N_humidite,train_score_humidite,val_score_humidite=learning_curve(traitement_1,X_train_humidite,y_train_humidite,train_sizes=np.linspace(0.1,1,10),cv=5)
N_temperature,train_score_temperature,val_score_temperature=learning_curve(traitement_1,X_train_temperature,y_train_temperature,train_sizes=np.linspace(0.1,1,10),cv=5)

plt.figure(figsize=[12,12])
plt.subplot(5,1,1)
plt.title("direction")
plt.plot(N_direction,train_score_direction.mean(axis=1),label='train')
plt.plot(N_direction,val_score_direction.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,2)
plt.title("force")
plt.plot(N_force,train_score_force.mean(axis=1),label='train')
plt.plot(N_force,val_score_force.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,3)
plt.title('pression')
plt.plot(N_pression,train_score_pression.mean(axis=1),label='train')
plt.plot(N_pression,val_score_pression.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,4)
plt.title('humidite')
plt.plot(N_humidite,train_score_humidite.mean(axis=1),label='train')
plt.plot(N_humidite,val_score_humidite.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()
plt.subplot(5,1,5)
plt.title('temperature')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='train')
plt.plot(N_temperature,train_score_temperature.mean(axis=1),label='validation')
plt.xlabel('train_sizes')
plt.legend()

la courbe d’apprentissage:

Ca rappelle un peu les voisins…Va falloir trouver une explication à ces courbes que je n’ai pas pour le moment. En général les paramètres les plus efficaces tournent à au moins 150 arbres. Si vous faites juste un potager avec 2 radis ça marchera pas trop.

Et maintenant les résultats selon le pré traitement, comme prévu ça ne varie pas beaucoup:

directionforcehumiditétempératurepression
sans traitement22%15%28%87%83%
MinMAxScaler23%15%29%87%84%
robustScaler24%14%31%89%83%
StandardScaler25%15%27%89%83%

BILAN

Au final, pour une précision à 12 heures il semblerait que notre jeu de données est un peu faiblard, particulièrement pour la direction du vent (au mieux un score de 25%), sa force (21% au mieux) et l’humidité (31%). La différence d’efficacité entre chaque modèle n’est pas vraiment tranchée pour le moment, tout comme les traitements différends. Ce qui est rassurant c’est de voir que toutes nos variables décroissent en score avec une prévision plus avancée, donc à priori si on rajoute des échantillons on va peut-être avoir une chance d’améliorer nos scores.

Donc pour la suite il va falloir:

  • Tester nos données en deep learning avec un réseau de neurones virtuels, pour commencer via un perceptron multicouches (MLP), le plus simple .
  • Tester nos données « densifiées » pour voir ce que ça donne via un dataframe de toujours 1096 lignes pour cette fois 120 colonnes (variables toutes les heures).
  • Evidemment, agrandir notre jeu, en prenant cette fois au moins 40 stations météo (ça fera donc un dataframe de 43840 échantillons pour 60 ou 120 colonnes ou autre à voir). On prendra si possible les stations plus gouda que gruyère, même si j’aime le gruyère dans les pâtes.
  • Creuser plus les fonctionnalités du mode Lasso pour bien voir quelles sont les variables utiles, ça va peut-être nous servir.
  • Eventuellement veiller à reconfigurer nos données ou leur mise en forme dans notre dataframe pour plus d’efficacité. En effet, nos variables sont de nature très différentes: on a des degrés, des degrés celsius, des vitesses, des pourcentages et des pressions.

Avec tout ça on devrait pas trop s’emmerder en somme.

Allez vas-y, soit pas timide ! Bin allez quoi, dis le que cet article est bouleversant et extraordinaire, que...Comment ça c'est de la merde ?

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.