rename classification chapter

Author: linogaliana

content/modelisation/2_classification.qmd

@@ -0,0 +1,336 @@
+---
+title: "Classification: premier modèle avec les SVM"
+weight: 30
+slug: SVM
+tags:
+  - scikit
+  - Machine Learning
+  - US elections
+  - classification
+  - SVM
+  - Modélisation
+  - Exercice
+categories:
+  - Modélisation
+  - Exercice
+description: |
+  La classification permet d'attribuer une classe d'appartenance (_label_
+  dans la terminologie du _machine learning_)
+  discrète à des données à partir de certaines variables explicatives
+  (_features_ dans la même terminologie).
+  Les algorithmes de classification sont nombreux. L'un des plus intuitifs et
+  les plus fréquemment rencontrés sont les _SVM_ (*Support Vector Machine*).
+  Ce chapitre illustre les enjeux de la classification à partir de
+  ce modèle sur les données de vote aux élections présidentielles US de 2020.
+image: featured_svm.png
+echo: false
+---
+
+
+{{< badges
+    printMessage="true"
+>}}
+
+# Introduction
+
+Ce chapitre vise à présenter de manière très succincte le principe de l'entraînement de modèles dans un cadre de classification. L'objectif est d'illustrer la démarche à partir d'un algorithme dont le principe est assez intuitif. Il s'agit d'illustrer quelques uns des concepts évoqués dans les chapitres précédents, notamment ceux relatifs à l'entraînement d'un modèle.  D'autres cours de votre scolarité vous permettront de découvrir d'autres algorithmes de classification et les limites de chaque technique. 
+
+
+## Données
+
+
+{{< include _import_data_ml.qmd >}}
+
+## La méthode des _SVM_ (_Support Vector Machines_)
+
+Les SVM (_Support Vector Machines_) font partie de la boîte à outil traditionnelle des _data scientists_. 
+Le principe de cette technique est relativement intuitif grâce à son interprétation géométrique. 
+Il s'agit de trouver une droite, avec des marges (les supports) qui discrimine au mieux le nuage de point de nos données. 
+Bien-sûr, dans la vraie vie, il est rare d'avoir des nuages de points bien ordonnés pour pouvoir les séparer par une droite. Mais une projection adéquate (un noyau ou _kernel_) peut arranger des données pour permettre de discriminer les données. 
+
+![](https://scikit-learn.org/stable/_images/sphx_glr_plot_iris_svc_001.png)
+
+
+::: {.tip collapse="true"}
+## Formalisation mathématique
+
+Les SVM sont l'une des méthodes de _machine learning_ les plus intuitives
+du fait de l'interprétation géométrique simple de la méthode. Il s'agit
+aussi d'un des algorithmes de _machine learning_ à la formalisation
+la moins complexe pour les praticiens ayant des notions en statistique
+traditionnelle. Cette note revient dessus. Néanmoins,
+celle-ci n'est pas nécessaire à la compréhension du chapitre.
+En _machine learning_, plus que les détails mathématiques, l'important
+est d'avoir des intuitions. 
+
+L'objectif des SVM est, rappelons-le, de trouver un hyperplan qui permette
+de séparer les différentes classes au mieux. Par exemple, dans un espace
+à deux dimensions, il s'agit de trouver une droite avec des marges
+qui permette de séparer au mieux l'espace en partie avec
+des _labels_ homogènes.
+
+On peut, sans perdre de généralité,
+supposer que le problème consiste à supposer l'existence d'une loi de probabilité $\mathbb{P}(x,y)$ ($\mathbb{P} \to \{-1,1\}$) qui est inconnue. Le problème de discrimination
+vise à construire un estimateur de la fonction de décision idéale qui minimise la probabilité d'erreur. Autrement dit 
+
+$$
+\theta = \arg\min_\Theta \mathbb{P}(h_\theta(X) \neq y |x)
+$$
+
+Les SVM les plus simples sont les SVM linéaires. Dans ce cas, on suppose qu'il existe un séparateur linéaire qui permet d'associer chaque classe à son signe:
+
+$$
+h_\theta(x) = \text{signe}(f_\theta(x)) ; \text{ avec } f_\theta(x) = \theta^T x + b
+$$
+avec $\theta \in \mathbb{R}^p$ et $w \in \mathbb{R}$. 
+
+![Les SVM dans le cas linéaire](https://upload.wikimedia.org/wikipedia/commons/7/72/SVM_margin.png){width="60%"}
+
+Lorsque des observations sont linéairement séparables,
+il existe une infinité de frontières de décision linéaire séparant les deux classes. Le _"meilleur"_ choix est de prendre la marge maximale permettant de séparer les données. La distance entre les deux marges est $\frac{2}{||\theta||}$. Donc maximiser cette distance entre deux hyperplans revient à minimiser $||\theta||^2$ sous la contrainte $y_i(\theta^Tx_i + b) \geq 1$. 
+
+Dans le cas non linéairement séparable, la *hinge loss* $\max\big(0,y_i(\theta^Tx_i + b)\big)$ permet de linéariser la fonction de perte, ce qui donne le programme d'optimisation suivant :
+
+$$
+\frac{1}{n} \sum_{i=1}^n \max\big(0,y_i(\theta^Tx_i + b)\big) + \lambda ||\theta||^2
+$$
+
+La généralisation au cas non linéaire implique d'introduire des noyaux transformant l'espace de coordonnées des observations.
+
+:::
+
+
+## Application
+
+Pour appliquer un modèle de classification, il nous faut
+trouver une variable dichotomique. Le choix naturel est
+de prendre la variable dichotomique qu'est la victoire ou 
+défaite d'un des partis. 
+
+Même si les Républicains ont perdu en 2020, ils l'ont emporté
+dans plus de comtés (moins peuplés). Nous allons considérer
+que la victoire des Républicains est notre _label_ 1 et la défaite _0_.
+
+```{python}
+#| echo: true
+# packages utiles
+from sklearn import svm
+import sklearn.metrics
+from sklearn.model_selection import train_test_split
+from sklearn.model_selection import cross_val_score
+import matplotlib.pyplot as plt
+```
+
+::: {.exercise}
+## Exercice 1 : Premier algorithme de classification
+
+1. Créer une variable *dummy* appelée `y` dont la valeur vaut 1 quand les républicains l'emportent. 
+2. En utilisant la fonction prête à l'emploi nommée `train_test_split` de la librairie `sklearn.model_selection`,
+créer des échantillons de test (20 % des observations) et d'estimation (80 %) avec comme *features* : `'Unemployment_rate_2019', 'Median_Household_Income_2019', 'Percent of adults with less than a high school diploma, 2015-19', "Percent of adults with a bachelor's degree or higher, 2015-19"` et comme *label* la variable `y`. 
+
+*Note: Il se peut que vous ayez le warning suivant :*
+
+> A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel()
+
+*Note : Pour éviter ce warning à chaque fois que vous estimez votre modèle, vous pouvez utiliser `DataFrame[['y']].values.ravel()` plutôt que `DataFrame[['y']]` lorsque vous constituez vos échantillons.*
+
+3. Entraîner un classifieur SVM avec comme paramètre de régularisation `C = 1`. Regarder les mesures de performance suivante : `accuracy`, `f1`, `recall` et `precision`.
+
+4. Vérifier la matrice de confusion : vous devriez voir que malgré des scores en apparence pas si mauvais, il y a un problème notable. 
+
+5. Refaire les questions précédentes avec des variables normalisées. Le résultat est-il différent ?
+
+6. Changer de variables *x*. Utiliser uniquement le résultat passé du vote démocrate (année 2016) et le revenu. Les variables en question sont `share_2016_republican` et `Median_Household_Income_2019`. Regarder les résultats, notamment la matrice de confusion. 
+
+7. [OPTIONNEL] Faire une 5-fold validation croisée pour déterminer le paramètre *C* idéal. 
+
+:::
+
+
+```{python}
+# 1. Création de la dummy y de victoire des républicains
+votes['y'] = (votes['votes_gop'] > votes['votes_dem']).astype(int)
+```
+
+
+```{python}
+#2. Création des échantillons d'entraînement et de validation
+xvars = ['Unemployment_rate_2019', 'Median_Household_Income_2019', 'Percent of adults with less than a high school diploma, 2015-19', "Percent of adults with a bachelor's degree or higher, 2015-19"]
+
+df = votes.loc[:, ["y"] + xvars]
+
+X_train, X_test, y_train, y_test = train_test_split(
+    df[xvars],
+    df[['y']].values.ravel(), test_size=0.2, random_state=123
+)
+#X_train.head()
+#y_test
+     
+```
+
+
+
+
+```{python}
+# 3. Entraînement du modèle et performances
+clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train)
+y_pred = clf.predict(X_test)
+
+sc_accuracy = sklearn.metrics.accuracy_score(y_pred, y_test)
+sc_f1 = sklearn.metrics.f1_score(y_pred, y_test)
+sc_recall = sklearn.metrics.recall_score(y_pred, y_test)
+sc_precision = sklearn.metrics.precision_score(y_pred, y_test)
+
+#print(sc_accuracy)
+#print(sc_f1)
+#print(sc_recall)
+#print(sc_precision)
+```
+
+A l'issue de la question 3,
+le classifieur avec `C = 1`
+devrait avoir les performances suivantes :
+
+```{python}
+#| output: asis
+out = pd.DataFrame.from_dict({"Accuracy": [sc_accuracy], "Recall": [sc_recall],
+                        "Precision": [sc_precision], "F1": [sc_f1]}, orient = "index", columns = ["Score"])
+print(out.to_markdown())
+```
+
+
+```{python}
+#| output: false
+
+# 4. Matrice de confusion
+predictions = clf.predict(X_test)
+cm = sklearn.metrics.confusion_matrix(y_test, predictions, labels=clf.classes_)
+disp = sklearn.metrics.ConfusionMatrixDisplay(
+            confusion_matrix=cm,
+            display_labels=clf.classes_
+       )
+disp.plot()
+
+#Réponse : Notre classifieur manque totalement les labels 0, qui sont minoritaires.
+#Une raison possible ? L'échelle des variables : le revenu a une
+#distribution qui peut écraser celle des autres variables,
+#dans un modèle linéaire. Il faut donc, a minima, 
+#standardiser les variables.
+
+plt.savefig("confusion_matrix.png")
+```
+
+La matrice de confusion associée
+prend cette forme:
+
+![](confusion_matrix.png)
+
+
+```{python}
+#| output: false
+
+# 5. Refaire les questions précédentes avec des variables normalisées.
+import sklearn.preprocessing as preprocessing
+
+X = df[xvars]
+y = df[['y']]
+scaler = preprocessing.StandardScaler().fit(X) #Ici on standardise
+X = scaler.transform(X) #Ici on standardise
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    y.values.ravel(), test_size=0.2, random_state=0
+)
+
+clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train)
+predictions = clf.predict(X_test)
+cm = sklearn.metrics.confusion_matrix(y_test, predictions, labels=clf.classes_)
+disp = sklearn.metrics.ConfusionMatrixDisplay(
+            confusion_matrix=cm,
+            display_labels=clf.classes_
+       )
+disp.plot()
+
+#Réponse : Non, standardiser les variables n'apporte pas de gain
+# Il faut donc aller plus loin : le problème ne vient pas de l'échelle mais du choix des variables. 
+# C'est pour cette raison que l'étape de sélection de variable est cruciale.
+
+plt.savefig("confusion_matrix2.png")
+```
+
+![](confusion_matrix2.png)
+
+
+A l'issue de la question 6,
+le nouveau classifieur avec devrait avoir les performances suivantes :
+
+```{python}
+#| output: asis
+
+out = pd.DataFrame.from_dict({"Accuracy": [sc_accuracy], "Recall": [sc_recall],
+                        "Precision": [sc_precision], "F1": [sc_f1]}, orient = "index", columns = ["Score"])
+print(out.to_markdown())
+```
+
+
+
+
+```{python}
+#| include: false
+
+# 6. Refaire les questions en changeant la variable X.
+votes['y'] = (votes['votes_gop'] > votes['votes_dem']).astype(int)
+df = votes[["y", "share_2016_republican", 'Median_Household_Income_2019']]
+tempdf = df.dropna(how = "any")
+
+X = votes[['share_2016_republican', 'Median_Household_Income_2019']]
+y = tempdf[['y']]
+scaler = preprocessing.StandardScaler().fit(X)
+X = scaler.transform(X)
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    y.values.ravel(), test_size=0.2, random_state=0
+)
+
+clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train)
+y_pred = clf.predict(X_test)
+
+sc_accuracy = sklearn.metrics.accuracy_score(y_pred, y_test)
+sc_f1 = sklearn.metrics.f1_score(y_pred, y_test)
+sc_recall = sklearn.metrics.recall_score(y_pred, y_test)
+sc_precision = sklearn.metrics.precision_score(y_pred, y_test)
+
+#print(sc_accuracy)
+#print(sc_f1)
+#print(sc_recall)
+#print(sc_precision)
+
+predictions = clf.predict(X_test)
+cm = sklearn.metrics.confusion_matrix(y_test, predictions, labels=clf.classes_)
+disp = sklearn.metrics.ConfusionMatrixDisplay(
+            confusion_matrix=cm,
+            display_labels=clf.classes_
+       )
+disp.plot()
+# On obtient un résultat beaucoup plus cohérent.
+
+plt.savefig("confusion_matrix3.png")
+```
+
+Et la matrice de confusion associée :
+
+![](confusion_matrix3.png)
+
+
+
+
+
+
+
+
+
+
+
+
+