4. Algorithmes d’IA#
Marc Buffat dpt mécanique, université Lyon 1
%matplotlib inline
import sys
import numpy as np
import matplotlib.pyplot as plt
# police des titres
plt.rc('font', family='serif', size='18')
from IPython.display import display,Markdown
import sklearn as sk
#sys.path.insert(1,"/home/cours/DatabaseIA")
from datasetIA import *
4.1. Problèmatique du machine learning#
problème : prédire une loi \(\mathcal{F}\)
à partir de l’apprentissage à l’aide d’une base de données de test \(\textbf{X}_i, Y_i\)
\(\rightarrow\) Problème de minimisation
Trouver la meilleur approximation \(\mathbf{F}\) minimisant l’erreur \(J\) sur la base de données de test.
\(J\) est une fonction coût du type:
\(\mathbf{F}(\mathbf{X}_i)\) est fonction d’une combinaison linéaire des données $\(\mathbf{F}(\mathbf{X}_i) = \mathbf{F}\left(\sum_j \beta_j \mathbf{X}_{i,j}\right)\)$
pas de forme explicite pour \(\mathbf{F}\) qui dépend de très nombreux paramètres à déterminer par une méthode de minimisation (de type gradient)
Algorithme implicite nécessitant des données annotées (i.e. avec le résultat) pour l’apprentissage et les tests de validation (apprentissage supervisée)
4.1.1. Méthodes de minimisation#
minimisation 1D (problème simple): 1 seul paramètre \(\beta\) tq \(F(\beta)\) soit minimum
solution exacte si \(F(\alpha)\) est quadratique: $\(F(\alpha)=a\alpha^2+b\alpha+c \mbox{ minimum pour } \alpha_{opt} = -b/2a\)$
sinon méthode de Brent (interpolation quadratique + bi-section)
lien calcul de racine d’une fonction et minimisation
minimisation ND (problème beaucoup plus complexes en particulier pour N grand): N paramètres \(\mathbf{X}=\left[\beta_j\right]\)
on peut se ramèner à des problèmes de minimisation 1D en choissisant des directions de descentes \(\mathbf{p_k}\)
minimiser \(F(\mathbf{X})\) avec \(X\in \mathcal{R}^N\)
répéter
choix direction \(\mathbf{p}_k\) (p.e. \(-\nabla \mathbf{X}\))
minimisation suivant \(\mathbf{p}_k\) $\( \mbox{Trouvez \)\alpha\( minimisant } F(\mathbf{X}_k + \alpha \mathbf{p}_k) \)$
nouvelle valeur de la solution \(\mathbf{X}_{k+1}\) $\( \mathbf{X}_{k+1} = \mathbf{X}_k + \alpha_{opt} \mathbf{p}_k \)$
4.1.1.1. méthode de gradient local#
4.1.1.2. méthode de gradient stochastique (full batch)#
estimation numérique du gradient
4.1.1.3. Algorithme du simplex Nelder-Mead#
La méthode de Nelder-Mead est un algorithme d’optimisation non linéaire qui a été publiée par John Nelder et Roger Mead en 1965. C’est une méthode numérique heuristique qui cherche à minimiser une fonction continue dans un espace à plusieurs dimensions.
En algorithmique, une heuristique est une méthode de calcul qui fournit rapidement une solution réalisable, pas nécessairement optimale ou exacte, pour un problème d’optimisation difficile.
simplexe: un simplexe est l’enveloppe convexe d’un ensemble de (n+1) points dans \(\mathcal{R}^n\)
Partant initialement d’un tel simplexe, celui-ci subit des transformations simples au cours des itérations: il se déforme, se déplace et se réduit progressivement jusqu’à ce que ses sommets se rapprochent d’un point où la fonction est localement minimale.
principe en 2D
on part de 3 points qui forment un triangle, et on détermine le point où la fonction est maximum, et on calcul le symétrique / aux 2 autres (réflexion)
si la valeur en ce nouveau point est inférieur à toutes les autres, on construit un simplex avec ce point et on recommence en 1.
si la valeur est meilleure que la seconde mais moins bonne que la meilleur, on remplace la seconde et on recommence en 1.
si la valeur est supérieure à tous les points,le minimum est dans le simplexe initial , on contracte ce simplexe et on recommence en 1.
4.1.1.4. Algorithme de Powell#
La méthode minimise la fonction par une recherche de type line search bidirectionnelle. La méthode line search le long de chaque vecteur de recherche peut être effectuée par une dichotomie de type nombre d’or ou la méthode de Brent.
On choisit successivement les directions de descente unitaire suivant chaque coordonnées (paramètre) et on minimise en 1D dans cette direction. $\(\{x_{0}+\alpha_{1}s_{1},{x}_{0}+\sum_{i=1}^{2}\alpha_{i}{s}_{i},\dots ,{x}_{0}+\sum_{i=1}^{N}\alpha_{i}{s}_{i}\}\)\( et on choisit : \)\(x_1 = {x}_{0}+\sum_{i=1}^{N}\alpha_{i}{s}_{i}\)$
puis on itére.
La méthode est utile pour calculer le minimum local d’une fonction continue mais complexe, en particulier une fonction sans définition mathématique sous-jacente, car il n’est pas nécessaire de prendre des dérivées. L’algorithme de base est simple ; la complexité réside dans les recherches linéaires le long des vecteurs de recherche, qui peuvent être réalisées via la méthode de Brent.
4.1.1.5. Algorithme méta-heuristique (Recuit simulé)#
Une métaheuristique est un algorithme d’optimisation visant à résoudre des problèmes d’optimisation difficile pour lesquels on ne connaît pas de méthode classique plus efficace.
Les métaheuristiques sont généralement des algorithmes stochastiques itératifs, qui progressent vers un optimum global (c’est-à-dire l’extremum global d’une fonction), par échantillonnage d’une fonction objectif.
Le recuit simulé (méthode empirique (métaheuristique) d’optimisation, inspirée d’un processus utilisé en métallurgie. On alterne des cycles de refroidissement lent et de réchauffage (recuit) pour minimiser l’énergie du matériau. La configuration la plus stable est atteinte en maîtrisant le refroidissement et en le ralentissant par apport de chaleur.
algorithme:
on part de N points pris au hasard et d’une température T élévée
évolution à T constant
on calcule l’énergie \(E\) (erreur) en chacun des points.
on fait évoluer aléatoirement les points (position) ce qui fait varier leur énergie de \(\Delta E\)
si \(\Delta E <0\) on accepte la nouvelle position, sinon elle est acceptée avec une probabilité \(e^{-\Delta E/T}\)
on itère en 3. jusqu’à ce qu’il y ait peu d’évolution (équilibre thermodynamique à T)
on diminue la température T et on recommence en 2
4.1.2. Domaines d’applications du machine learning#
Traitement de données (expérimentales ou numériques)
Modélisation
Big Data
ATTENTION
ce n’est pas la solution pour tous les problèmes
méthodes classiques / semi-analytiques
à utiliser à bonne escient
4.2. Algorithmes de base#
4.2.1. Linear Regression#
Régression linéaire par moindres carrés
LinearRegression ajuste un modèle linéaire avec des coefficients \(\mathbf{w} = (w_1, …, w_p)\) pour minimiser la somme des carrés résiduelle entre les cibles observées dans l’ensemble de données et les cibles prédites par l’approximation linéaire (méthodes des moindres carrés)
scikit learn model: LinearRegression
from sklearn.linear_model import LinearRegression
N = 11
X,y = dataset1(N)
reg = LinearRegression().fit(X, y)
print("score = {:2d}%".format(int(100*reg.score(X, y))))
print("loi lineaire y = {:.2f} + {} X".format(reg.intercept_,reg.coef_))
score = 91%
loi lineaire y = 4.08 + [0.9950683 1.98990227] X
plot_data1(X,y,"dataset1 values y")
# prediction en x2=1
Xpred = np.array([[1,x] for x in np.linspace(1,4,21) ])
ypred = reg.predict(Xpred)
plot1(N,X,y,Xpred,ypred,titre="régression lineaire")
4.2.2. Logistic Regression#
La régression logistique, malgré son nom, est un modèle linéaire de classification plutôt que de régression. La régression logistique est également connue dans la littérature sous le nom de régression logit, de classification à entropie maximale (MaxEnt) ou de classifieur log-linéaire. Dans ce modèle, les probabilités décrivant les résultats possibles d’un seul essai sont modélisées à l’aide d’une fonction logistique
scikit learn model LogisticRegression
La régression logistique est un algorithme de classification simple et efficace, qui ne nécessite pas une grande puissance de calcul et est facile à mettre en œuvre. Ce modèle d’apprentissage est largement utilisé par les analystes de données et les scientifiques.
La régression logistique, malgré son nom, est un modèle linéaire de classification plutôt que de régression. La régression logistique est également connue dans la littérature sous le nom de « logit régression », de « classification à entropie maximale » (MaxEnt) ou de « classificateur log-linéaire ». Dans ce modèle, les probabilités décrivant les résultats possibles d’un seul essai sont modélisées à l’aide d’une fonction logistique.
La régression logistique est implémentée dans LogisticRegression. Cette implémentation peut s’adapter à une régression logistique binaire, One-vs-Rest ou multinomiale avec régularisation facultative (l1, l2, elasticnet, aucune)
4.2.3. Régression logistique#
La régression logistique est une méthode statistique de prédiction des classes binaires. Le résultat ou la variable cible est de nature dichotomique. Dichotomique signifie qu’il n’y a que deux classes possibles. Il calcule la probabilité d’occurrence d’un événement.
Il s’agit d’un cas particulier de régression linéaire où la variable cible est de nature catégorielle. Il utilise un journal des cotes comme variable dépendante. La régression logistique prédit la probabilité d’occurrence d’un événement binaire à l’aide d’une fonction logit.
Equation linéaire de régression
Fonction sigmoide $\( p = \frac{1}{1+e^{-z}} \)$
probalité y=1 $\( p = \frac{1}{1+e^{-(\beta_0 + \beta_1 X_1 + ... + \beta_n X_n)}}\)$
Limites
La régression logistique n’est pas adaptée à un grand nombre de caractéristiques. Cet algorithme ne peut pas résoudre le problème de non-linéarité ce qui nécessite la transformation des caractéristiques non linéaires. Ainsi, la régression logistique ne fonctionne pas bien avec des variables indépendantes qui ne sont pas corrélées à la variable cible et qui sont très similaires entre elles.
from sklearn.linear_model import LogisticRegression
N = 10
X,y,col = dataset2(N)
clf = LogisticRegression(random_state=0).fit(X, y)
print("score = {:2d}%".format(int(100*clf.score(X, y))))
score = 98%
# prediction
NN = 21
Xpred, ypred, colpred = predict2(NN,clf.predict)
plot2(X,col, Xpred,colpred, titre="Logistic régréssion")
4.2.4. Arbres de décisions (Decision Trees)#
Pour faire une prédiction, les arbres de décisions utilisent un ensemble de règles de décision « If Then Else » sur les features (données). Cette méthode permet de décomposer un ensemble de données en sous-ensembles de plus en plus petits. On peut ainsi assigner aux sous-ensemble finaux une classe (0 ou 1 pour une classification binaire). Le but du modèle va être de créer des sous-ensembles homogènes (contenant des exemples de même classe) pour minimiser l’erreur de ses prédictions.
classification
scikit learn model DecisionTreeClassifier
regression
scikit learn model DecisionTreeRegressor
Problème : résultat dépend de l’ordre des questions!
4.2.4.1. Decision tree: classification#
scikit learn DecisionTreeClassifier
from sklearn.tree import DecisionTreeClassifier
N = 10
X,y,col = dataset2(N)
clf = DecisionTreeClassifier()
clf = clf.fit(X, y)
print("score = {:2d}%".format(int(100*clf.score(X, y))))
score = 100%
# prediction
NN = 21
Xpred, ypred, colpred = predict2(NN, clf.predict)
plot2(X,col, Xpred,colpred,titre="decision tree")
4.2.4.2. Décision tree: régression#
scikit learn DecisionTreeRegressor
from sklearn.tree import DecisionTreeRegressor
N = 11
X,y = dataset1(N)
clf = DecisionTreeRegressor()
clf = clf.fit(X, y)
print("score = {:2d}%".format(int(100*clf.score(X, y))))
score = 100%
# prediction en x2=1
NN = 51
Xpred = np.array([[1,x] for x in np.linspace(1,4,21) ])
ypred = clf.predict(Xpred)
plot1(N,X,y, Xpred,ypred,titre="decision tree")
4.2.5. Forêts d’arbres décisionnels: (Random forest)#
Les modèles Random Forest sont composés de plusieurs Decision Trees (“forêt” d’arbres de décision). Le résultat retourné par un Random Forest est la classe majoritaire retournée par les Decision Trees qui le composent. Ces Decision Trees sont chacuns entraînés avec un échantillon des données d’entraînement pris au hasard et un sous-ensemble des features pris au hasard également.
4.2.5.1. Random forest classification#
scikit learn RandomForestClassifier
utilisation dataset3 avec 3 ensembles de valeurs (-1,0,+1)
influence des paramètres:
max_deph: profondeur de l’arbre 2, 3 ou None
from sklearn.ensemble import RandomForestClassifier
N=15
X,y,col = dataset3(N)
clf = RandomForestClassifier(max_depth=None, random_state=0)
cfl = clf.fit(X, y)
print("score = {:2d}%".format(int(100*clf.score(X, y))))
score = 100%
# prediction
NN = 21
Xpred,ypred,colpred = predict3(NN, clf.predict)
plot3(X,col, Xpred,colpred, titre="Random forest")
4.2.5.2. Random forest régression#
scikit learn RandomForestRegression
influence des paramètres:
max_deph: profondeur de l’arbre 2, 3 ou None
from sklearn.ensemble import RandomForestRegressor
N=11
X,y = dataset1(N)
clf = RandomForestRegressor(max_depth=None, random_state=0)
cfl = clf.fit(X, y)
print("score = {:2d}%".format(int(100*clf.score(X, y))))
score = 98%
NN = 51
Xpred = np.array([[1,x] for x in np.linspace(1,4,21) ])
ypred = clf.predict(Xpred)
plot1(N,X,y, Xpred,ypred,titre="random forest")
4.2.6. K plus proches voisins (KNN)#
L’algorithme des KNN (“K plus proches voisins” en français) attribue à un exemple la classe majoritaire parmi ses K plus proches voisins. K est un paramètre à optimiser par l’utilisateur, il est préférable de choisir un K impair pour de la classification binaire pour éviter les égalités. On utilise communément la distance euclidienne entre deux vecteurs de features pour calculer la proximité entre 2 exemples.
4.2.6.1. KNN classification#
scikit learn KNeighborsClassifier
paramètres:
n_neighbors = 2,3,..5
from sklearn.neighbors import KNeighborsClassifier
N = 20
X,y,col = dataset3(N)
neigh = KNeighborsClassifier(n_neighbors=5)
neigh = neigh.fit(X, y)
print("score = {:2d}%".format(int(100*neigh.score(X, y))))
score = 98%
# prediction
NN = 21
Xpred,ypred,colpred = predict3(NN, neigh.predict)
plot3(X,col, Xpred,colpred, titre="KNN")
4.2.6.2. KNN régression#
scikit learn KNeighborsRegressor
paramètres:
n_neighbors = 2,3,..5
from sklearn.neighbors import KNeighborsRegressor
N=11
X,y = dataset1(N)
neigh = KNeighborsRegressor(n_neighbors=5)
neigh = neigh.fit(X, y)
print("score = {:2d}%".format(int(100*neigh.score(X, y))))
score = 93%
NN = 51
Xpred = np.array([[1,x] for x in np.linspace(1,4,21) ])
ypred = neigh.predict(Xpred)
plot1(N,X,y, Xpred,ypred,titre="KNN")
4.2.7. Support vector machine SVM#
Les machines à vecteurs de support (SVM) sont un ensemble de méthodes d’apprentissage supervisé utilisées pour la classification, la régression et la détection des valeurs aberrantes. Ce sont des classes capables d’effectuer une classification binaire et multiclasse sur un ensemble de données.
Les séparateurs à vastes marges (SVM) sont des classificateurs qui reposent sur deux idées clés (Wikipedia).
La première idée clé est la notion de marge maximale. La marge est la distance entre la frontière de séparation et les échantillons les plus proches. Ces derniers sont appelés vecteurs supports. Dans les SVM, la frontière de séparation est choisie comme celle qui maximise la marge. Le problème est de trouver cette frontière séparatrice optimale, à partir d’un ensemble d’apprentissage. Ceci est fait en formulant le problème comme un problème d’optimisation quadratique, pour lequel il existe des algorithmes connus.
4.2.7.1. Support vector machines SVM#
scikit learn svm
from sklearn import svm
N = 20
X,y,col = dataset3(N)
clf = svm.SVC()
clf = clf.fit(X,y)
print("score = {:2d}%".format(int(100*clf.score(X, y))))
score = 99%
# prediction
NN = 21
Xpred, ypred, colpred = predict3(NN, clf.predict)
plot3(X,col, Xpred,colpred, titre="support vector machine SVC")
4.3. Réseaux de neurones en IA#
4.3.1. Apprentissage Deep Learning#
analogie (un peu fausse) avec le cerveau !
4.4. Neurone (informatique)#
f est la fonction d’activation
Question : quelle fonction f choisir pour retrouver le modèle linéaire ?
4.4.1. Fonctions d’activation couramment utilisées#
à gauche utilisation : à mettre en fin de réseau pour prédire une probabilité (entre 0 et 1)
à droite utilisation : entre chaque couche pour dé-linéariser (à coût de calcul faible)
4.4.2. Neurone formel#
le neurone formel est un modèle qui se caractérise par des signaux d’entrée \(\mathbf{x}=[x_1,...,x_p]\) et une fonction d’activation \(f\) pour calculer la sortie \(y\) :
La fonction d’activation opère une transformation d’une combinaison affine des signaux d’entrée, \(\alpha_0\), terme constant, étant appelé le biais du neurone. Cette combinaison affine est déterminée par un vecteur de poids \(\mathbf{\alpha}=[\alpha_1,..\alpha_2]\) associé à chaque neurone et dont les valeurs sont estimées dans la phase d’apprentissage. Ils constituent la mémoire ou connaissance répartie du réseau.
4.5. Couches de neurones / layers#
à gauche : profondeur = 1
à droite : profondeur = 2
4.5.1. formalisme: perceptron multicouche#
Le perceptron multicouche (PMC) est un réseau composé de couches successives. Une couche est un ensemble de neurones n’ayant pas de connexion entre eux. Une couche d’entrée lit les signaux entrant, un neurone par entrée \(x_j\) , une couche en sortie fournit la réponse du système \(Y\).
Les p entrées ou variables explicatives du modèle sont notées \(X_1,...,X_p\) tandis que la sortie est la variable Y à expliquer ou cible du modèle.
De façon usuelle et en régression (Y quantitative), la dernière couche est constituée d’un seul neurone muni de la fonction d’activation identité tandis que les autres neurones (couche cachée) sont munis de la fonction sigmoïde.
Ce modèle inclut des couches non linéaires « cachées ». Le nom « caché » ici signifie simplement pas directement connecté aux entrées ou sorties.
4.5.1.1. perceptron à une couche cachée#
Ainsi, en régression avec un perceptron à une couche cachée de q neurones et un neurone de sortie, cette fonction s’écrit:
Les poids des entrées sont les paramètres \(\mathbf{\alpha},\mathbf{\beta}\) à estimer lors de la procédure d’apprentissage. Un perceptron multicouche réalise donc une transformation des variables d’entrée \(\mathbf{X}\):
où \(\mathbf{\alpha}\) est le vecteur contenant chacun des paramètres \(\alpha_{jkl}\) de la jème entrée du kème neurone de la lème couche et \(\beta\) les paramètres de la couche de sortie.
résultat théorique
Un théorème dit d’approximation universelle montre que cette structure élémentaire à une seule couche cachée est suffisante pour prendre en compte les problèmes classiques de modélisation ou apprentissage statistique. En effet, toute fonction régulière peut être approchée uniformément avec une précision arbitraire et dans un domaine fini de l’espace de ses variables, par un réseau de neurones comportant une couche de neurones cachés en nombre fini possédant tous la même fonction d’activation et un neurone de sortie linéaire.
attention on ne dit pas comment !
4.5.2. Apprentissage#
Supposons que l’on dispose d’une base d’apprentissage de taille n d’observations \((x^1_i ,...,x^p_i ; y_i)\) des variables explicatives \(X_1,...,X_p\) et de la variable à prévoir \(Y\) . Considérons le cas le plus simple de la régression avec un réseau constitué d’un neurone de sortie linéaire et d’une couche à q neurones dont les paramètres sont optimisés par moindres carrés. Ceci se généralise à toute fonction perte dérivable et donc à la discrimination à m classes.
L’apprentissage est l’estimation des paramètres \(\alpha_{j=0,p;k=1,q}\) et \(\beta_{k=0,q}\) par minimisation de la fonction perte quadratique ou de celle d’une fonction d’entropie en classification
remarques
Différents algorithmes d’optimisation peuvent être utilisés, ils sont généralement basés sur une évaluation numérique du gradient par rétro-propagation:
Algorithme de minimisation SGD: Stochastic Gradient Descend,
on estime le «gradient» échantillon par échantillon, ou par mini-batches de quelques échantillons
une passe complète sur le jeu de données s’appelle « Epoch »
le nombre d’ »Epochs » est donc le nombre de passes effectuées sur le jeu d’entraînement lors de l’apprentissage avec une méthode SGD
4.5.3. Types de couches#
couche dense: modèle linéaire
couche de type convolution, maxpooling, dropout
couche de type récurrence
Réseaux convolutionnels : traiter la dimension spatiale
Hypothèse : des pixels voisins représentent des choses similaires
Convolution : connexion locale des pixels (voisinage) pour détecter des objets plus gros (lignes/courbes)
Réseaux récurrents : traiter la dimension temporelle
4.6. Réseaux de neurones convolutionnels#
Convolution sur une image
1 filtre 5x5
4.6.1. Type de couches de neurones convolutionnelles#
objectif: réduire la taille des données (image)
\(\Rightarrow\) sur une image, filtre 3x3
Convolution
MaxPooling (remplace plusieurs pixels par le max)
DropOut (élimine des pixels)
4.6.2. classification Neural network#
scikit learn model MLPClassifier
MLP = Multi-layer Perceptron
paramétres:
hidden_layer_sizes = (taille1, taille2)
C’est un Tuple, sa taille représente le nombre de couches et chaque élément représente le nombre de neurones. Si on veut un modèle avec 3 couches de 100 Neurones chacune, on doit mettre :
hidden_layer_sizes = (100,100,100).
Donc la valeur par défaut représente bien une seule couche cachée de 100 Neurones.
from sklearn.neural_network import MLPClassifier
N = 20
X,y,col = dataset3(N)
clf = MLPClassifier(hidden_layer_sizes=(N**2,N**2,N**2), max_iter=400, random_state=1, verbose = False)
clf = clf.fit(X,y)
print("score = {:2d}%".format(int(100*clf.score(X, y))))
score = 100%
# prediction
NN = 21
Xpred, ypred, colpred = predict3(NN, clf.predict)
plot3(X,col, Xpred,colpred,titre="Réseau de neuronnes")
4.6.3. regression Neural network#
scikit learn model MLPRegressor
MLP = Multi-layer Perceptron
paramétres:
hidden_layer_sizes = (nbre, taille) 1,2, .. 5
from sklearn.neural_network import MLPRegressor
N = 11
X,y = dataset1(N)
clf = MLPRegressor(hidden_layer_sizes=(N**2,N**2,N**2), max_iter=400, random_state=1, verbose = False)
clf = clf.fit(X,y)
print("score = {:2d}%".format(int(100*clf.score(X, y))))
score = 43%
NN = 51
Xpred = np.array([[1,x] for x in np.linspace(1,4,21) ])
ypred = clf.predict(Xpred)
plot1(N,X,y, Xpred,ypred,titre="Reseaux neuronnes")
4.7. Apprentissage avec des séries temporelles#
■ Classification
Identifier les épisodes pluvieux/non pluvieux
Identifier si une station météo est défaillante.
■ Régression
Prédire la température maximale de la journée
Prédire la quantité de pluie attendue
Corriger la température mesurée
■ Problème
définition des données \(X\) (features)
définition des objectifs \(y\) (target)
\(\Rightarrow\) machine learning: trouver le modèle \(f(X)\) minimisant \(L\)
# construction serie
Ts,ys = serie_temp(3)
plt.figure(figsize=(12,8))
plt.plot(Ts[:],ys)
plt.xlabel("jour")
plt.title("serie temporelle");
# 50 fenetres de 14 jours pour prediction au jour 300
n = 14
N = 50
t0 = 300
X,y,t = dataset4(Ts,ys,n,N,t0)
plot_data4(n,N,t0,t,X,y,Ts,ys)
apprentissage sur une fenetre de 14 jours entre le jour 237 et 300
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import r2_score
# choix de l'algorithme
clf = RandomForestRegressor()
#clf = KNeighborsRegressor()
#clf = LinearRegression()
clf.fit(X,y)
print("score = {:2d}%".format(int(100*clf.score(X, y))))
yp = clf.predict(X)
print("R2 = {:3.2f}%".format(r2_score(y,yp)))
score = 92%
R2 = 0.92%
# prediction sur n1 jours
n1 = 2*n
Xpred = np.zeros((n1,n))
ypred = np.zeros(n1)
for k in range(n1):
Xpred[k,:] = ys[t0+k-n:t0+k]
ypred = clf.predict(Xpred)
plot4(n1,t0,Ts,ys,ypred,"prediction")
4.8. Qualité de l’apprentissage#
Métriques de régression pour quantifier la qualité des prédictions
Pour un jeux de tests (# du jeu d’entraînement) de dimension n on évalue l’écart entre la prédiction \(\hat{y}_i\) et la valeur réelle \(y_i\).
Mean squared error MSE
coefficient de détermination: \(R^2\) score
Il représente la proportion de variance (de y) qui a été expliquée par les variables indépendantes du modèle. Il fournit une indication de la qualité de l’ajustement et, par conséquent, une mesure de la manière dont les échantillons invisibles sont susceptibles d’être prédits par le modèle, à travers la proportion de la variance expliquée.
Le meilleur score possible est 1.0
4.9. Conclusion#
Le choix du bon algorithme dépend:
des données
de la connaissance du problème
du choix des paramètres
4.10. Références#
« L’intelligence artificielle: introduction et applications en physique » par Colin Bernet
« Formation Deep Learning » de méteo-france
Cours « DATA MINING et DATA SCIENCE » de Ricco Rakotomalala, Lyon 2
4.11. FIN#
Questions ?
from platform import python_version
print("Python version:",python_version())
print("numpy version:",np.__version__)
print("skit learn version:",sk.__version__)
Python version: 3.10.12
numpy version: 1.26.4
skit learn version: 1.1.3