partie 4

Cours sur la Classication Supervisée
Nachaoui Mourad
ENSA de Khouribga
25 mars 2024
Nachaoui Mourad (ENSA de Khouribga) Cours sur la Classication Supervisée 25 mars 2024 1 / 103
Les données sont générées dans toutes les interactions et transactions
que nous eectuons.
En ligne ou hors ligne : nous générons des données chaque jour, chaque
minute. À une banque, un point de vente, sur les réseaux sociaux,
passer un appel mobile : chaque interaction génère des données.
Les données se présentent sous deux formes : les données structurées
et les données non structurées.
Lorsque vous passez cet appel mobile à votre ami, l'opérateur télécom
obtient les données de l'appel telles que la durée de l'appel, le coût de
l'appel, l'heure de la journée, etc.
De même, lorsque vous eectuez une transaction en ligne via votre
portail bancaire, les données sont générées autour du montant de la
transaction, du destinataire, de la raison de la transaction, de la
date/heure, etc.
Tous ces points de données qui peuvent être représentées dans une
structure lignes-colonnes sont appelées données structurées. La plupart
de les données utilisées et analysées sont structurées. Ces données
sont stockées dans des bases de données et des serveurs utilisant
Oracle, SQL, AWS, MySQL, etc.
Données, types de données et sources de données
Les données peuvent être divisées entre structurées et non structurées. Les
données structurées sont plus faciles à travailler tandis que l'apprentissage
en profondeur est généralement est utilisé pour les données non structurées
Données Non Structurées
Les données non structurées sont celles qui ne peuvent pas être
représentées dans une structure ligne-colonne, du moins dans leur
format de base.
Les exemples de données non structurées incluent les données
textuelles (publications sur Facebook, tweets, avis, commentaires,
etc.), les images et photos (Instagram, photos de produits), les chiers
audio ( enregistrements, appels de centres d'appels) et les vidéos
(publicités, vidéos YouTube, etc.).
Toutes les données non structurées peuvent être sauvegardées et
analysées.
Comme vous pouvez l'imaginer, il est plus dicile d'analyser les
données non structurées que les données structurées.
Données Non Structurées
Un point important à noter est que même les données non structurées
doivent être converties en entiers an que les ordinateurs puissent les
comprendre et les traiter.
Par exemple, une image en couleur a des pixels et chaque pixel a des
valeurs RVB (rouge, vert, bleu) allant de 0 à 255. Cela signie que
chaque image peut être représentée sous forme de matrices contenant
des entiers, et ces données peuvent être ensuite fournies à l'ordinateur
pour une analyse ultérieure.
Qualité des Données
Un aspect vital souvent ignoré et peu discuté est la qualité des données. La
qualité des données détermine la qualité de l'analyse et des insights
générés. Souvenez-vous :
"des déchets en entrée, des déchets en sortie".
Qualité des Données
Nous devons nous assurer que les données disponibles respectent les
normes suivantes :
Complétude des données : Il s'agit du pourcentage d'attributs
disponibles. Dans le monde des aaires réel, nous constatons que de
nombreux attributs sont manquants, ou ont des valeurs NULL ou NA.
Il est conseillé de nous assurer que nous obtenons les données de
manière adéquate et d'en garantir la complétude. Pendant la phase de
préparation des données, nous traitons ces variables en les remplaçant
ou en les supprimant selon les besoins.
Validité des données : Cela consiste à s'assurer que tous les
indicateurs clés de performance (KPI) sont capturés lors de la phase
d'identication des données. Les contributions des experts en la
matière (SME) de l'entreprise jouent un rôle crucial dans cette
assurance. Ces KPI sont calculés et vériés par les SME. Par exemple,
lors du calcul du coût moyen d'un appel d'abonné mobile, le SME
pourrait suggérer d'ajouter/supprimer quelques coûts comme le coût
du spectre, le coût d'acquisition, etc.
Qualité des Données (Suite)
Précision des données : Cela consiste à s'assurer que tous les points
de données capturés sont corrects et qu'il n'y a aucune information
incohérente dans nos données. On observe que, en raison d'erreurs
humaines ou de problèmes logiciels, des informations erronées sont
parfois capturées. Par exemple, lors de la capture du nombre de clients
achetant dans un magasin de détail, les chires du week-end sont
généralement plus élevés que ceux des jours de semaine. Cela doit être
assuré pendant la phase exploratoire.
Consistance des données : Les données utilisées doivent être
cohérentes et ne doivent pas varier entre les systèmes et les interfaces.
Souvent, diérents systèmes sont utilisés pour représenter un KPI. Par
exemple, le nombre de clics sur une page de site web peut être
enregistré de diérentes manières. La cohérence dans ce KPI garantira
une analyse correcte et des insights cohérents.
Intégrité des données : Lorsque vous enregistrez les données dans

des bases de données et des tables, il arrive souvent que les relations
entre les diérentes entités et attributs ne soient pas cohérentes, voire
n'existent pas. L'intégrité des données du système garantit que nous
ne rencontrons pas de telles anomalies. Une structure de données
robuste est nécessaire pour un processus d'exploration de données
ecace, complet et correct.
Temporalité des données : La capture des données doit être
susamment représentative pour capturer les variations saisonnières,
les mouvements par rapport aux jours/heures et événements, etc. Il est
parfois impératif de capturer des données des dernières années pour
mesurer le mouvement des KPI. La temporalité des données capturées
doit être susamment représentative pour capturer de telles variations.
Les problèmes les plus courants rencontrés dans les données sont les
valeurs manquantes, les doublons, les valeurs indésirables, les valeurs
aberrantes, etc. Vous étudierez en détail comment résoudre ces
problèmes de manière logique et mathématique.
Diérences entre le Génie Logiciel et l'Apprentissage
Automatique
Le génie logiciel et l'apprentissage automatique (ML) résolvent tous

deux des problèmes commerciaux. Les deux interagissent avec des
bases de données, analysent et codent des modules, et génèrent des
sorties utilisées par l'entreprise.
La compréhension du domaine commercial est essentielle pour les deux
domaines, tout comme l'utilisabilité.
Sur ces paramètres, le génie logiciel et l'apprentissage automatique
sont similaires. Cependant, la diérence clé réside dans l'exécution et
l'approche utilisée pour résoudre le dé commercial.
Diérences d'Approche
Génie Logiciel : implique l'écriture de code précis qui peut être

exécuté par le processeur, c'est-à-dire l'ordinateur.
Apprentissage Automatique : collecte des données historiques et
comprend les tendances dans les données. Basé sur ces tendances,
l'algorithme de ML prédira la sortie souhaitée.
Exemple Simplié
En utilisant le génie logiciel, vous coderez les étapes exactes avec des
coordonnées précises et des instructions pour automatiser l'ouverture
d'une canette de cola.
En revanche, en utilisant l'apprentissage automatique, vous montrerez
le processus d'ouverture de la canette au système à de nombreuses
reprises. Le système apprendra le processus en observant diérentes
étapes ou en se "formant" lui-même.
Exemple Réel
Imaginons que vous travaillez pour une banque qui propose des cartes
de crédit. Vous êtes dans l'unité de détection de fraude et votre travail
est de classier une transaction comme frauduleuse ou authentique.
Utilisant le génie logiciel, vous pourriez implémenter des conditions
comme celles décrites dans la gure suivant, créant un arbre de
décision pour prendre une décision nale.

En utilisant l'apprentissage automatique, vous collecterez les données
historiques contenant à la fois des transactions frauduleuses et
authentiques. Vous exposerez ensuite ces transactions à l'algorithme
ML et le formerez pour qu'il découvre la relation entre les attributs de
la transaction et sa nature frauduleuse/authentique.
Flexibilité et Itérations de l'Apprentissage Automatique
Les règles générées par les algorithmes de ML dépendent des

tendances et des modèles et orent un niveau de exibilité plus élevé.
Le développement d'une solution de ML est souvent plus itératif que
le génie logiciel. De plus, il n'est pas aussi précis que le logiciel, mais il
ore une solution généralisée pour des problèmes complexes.
Conclusion de comparaison GL et ML
L'apprentissage automatique est une solution fantastique pour les

problèmes commerciaux complexes et souvent la seule solution pour
les problèmes vraiment compliqués que nous, les humains, sommes
incapables de comprendre.
Son élégance réside dans le fait que si les données d'entraînement
changent, il n'est pas nécessaire de recommencer le processus de
développement depuis le début. Le modèle peut être réentraîné et vous
êtes prêt à partir !
Projets d'Apprentissage Automatique (ML)
Un projet d'apprentissage automatique est similaire à tout autre

projet. Il a un objectif commercial à atteindre, des informations
d'entrée, des outils et des équipes, des niveaux de précision souhaités
et une date limite !
Cependant, l'exécution d'un projet d'apprentissage automatique est
assez diérente. La première étape du processus d'apprentissage
automatique est la même, à savoir dénir un objectif commercial et un
paramètre mesurable pour mesurer les critères de réussite.
Étapes d'un Projet ML
1 Découverte des données : exploration des diérentes sources de

données disponibles. Les ensembles de données peuvent être
disponibles dans SQL Server, des chiers Excel, des chiers texte ou
CSV, ou sur un serveur cloud.
2 Minage de données et calibrage : extraction des champs pertinents
de toutes les sources. Les données sont nettoyées et traitées
correctement et sont préparées pour la phase suivante. De nouvelles
variables dérivées sont créées et les variables qui n'ont pas beaucoup
d'informations sont éliminées.
3 Analyse exploratoire des données (EDA) : génération
d'informations générales à partir des données à l'aide d'outils
analytiques. Les tendances, les motifs et les anomalies sont les
résultats de cette étape, qui s'avèrent très utiles pour la modélisation
statistique.
Étapes d'un Projet ML
4 Modélisation ML : phase de développement réel du modèle. Nous

discuterons en détail de cette phase tout au long du cours.
5 Partage des résultats et déploiement du modèle : les résultats
sont partagés avec l'équipe commerciale et le modèle ML est déployé
dans l'environnement de production.
Dés Anticipés
Avant de commencer le projet, voici quelques questions que nous devrions

poser :
Disponibilité des données
Qualité des données
Préparation des données
Mesures de prédiction des modèles ML
Il est impératif de trouver les réponses à ces questions avant de démarrer le
projet, sinon nous risquons du stress pour nous-mêmes et de manquer les
délais ultérieurement.
Conclusion
Maintenant que vous savez ce qu'est l'apprentissage automatique et les

diérentes phases d'un projet d'apprentissage automatique, il sera utile de
visualiser un modèle ML et les diérentes étapes du processus.
Algorithmes d'Apprentissage Supervisé
Le but de l'algorithme d'apprentissage supervisé est d'atteindre une

fonction optimisée capable de prédire la sortie associée à de nouvelles
données invisibles. Ces nouvelles données invisibles ne font pas partie des
données d'entraînement. La fonction que nous voulons optimiser est
appelée fonction objectif.
Les algorithmes d'apprentissage supervisé sont utilisés pour résoudre deux
types de problèmes : la régression et la classication.
Régression vs Classication
Régression : utilisée pour prédire la valeur d'une variable continue.

Classication : utilisée pour prédire la valeur d'une variable
catégorique.
Exemples :
Régression : prédire le prix exact des maisons.
Classication : prédire si un client résiliera son abonnement, si une
transaction par carte de crédit est frauduleuse, etc.
Algorithmes d'Apprentissage Supervisé
1 Optimisation du risque empirique : En utilisant gradient-descent ou

n'importe qu'il algorithme d'optimisation
2 Régression Logistique : pour les problèmes de classication.
3 Arbre de Décision : pour les problèmes de régression et de
classication.
4 Forêt Aléatoire : pour les problèmes de régression et de classication.
5 Machine à Vecteurs de Support (SVM) : pour les problèmes de
régression et de classication.
Il existe de nombreux autres algorithmes comme k plus proches voisins,
Naive Bayes, LDA, etc. Les réseaux neuronaux peuvent également être
utilisés pour la classication et la régression. Nous étudierons tous ces
algorithmes en détail tout au long du cours, en développant également des
solutions en Python.
Comparaison et Sélection d'Algorithmes
En pratique commerciale, nous comparons les précisions de quatre ou cinq

algorithmes et sélectionnons le meilleur modèle ML à mettre en ÷uvre en
production.
Conclusion pour les algorithmes d'apprentissage supervisé
Nous avons examiné la dénition de l'algorithme d'apprentissage supervisé

et quelques exemples. Nous allons maintenant examiner les étapes d'un
problème d'apprentissage supervisé. Vous êtes invité à vous familiariser
avec ces étapes, car nous les suivrons à nouveau tout au long du cours.
Étapes d'un Algorithme d'Apprentissage Supervisé
Les étapes dans un projet ML ont été discutées précédemment. Ici, nous
examinerons spéciquement les étapes pour les algorithmes d'apprentissage
supervisé. Les principes de qualité des données, de complétude et de
robustesse s'appliquent à chacune des étapes d'un problème supervisé.
Étape 1 : Dénition de la Variable Cible
Nous avons la variable cible et les variables indépendantes.

La mauvaise dénition de la variable cible peut inverser les résultats.
Classication binaire ou multiclasse.
Étape 2 : Identication des Données d'Entraînement
Les données d'entraînement doivent respecter les meilleures pratiques

en matière de qualité des données.
Comprend à la fois les variables indépendantes et la variable cible.
Les données doivent être représentatives de toutes les périodes pour
assurer la complétude.
Étape 3 : Préparation des Données
Nettoyage des données : valeurs nulles, doublons, etc.

Identication de la variable cible et des variables indépendantes.
Création de nouvelles variables dérivées.
Étape 4 : Analyse Exploratoire
Génération d'aperçus initiaux à partir des données.

Compréhension des distributions, des relations, des corrélations, etc.
Création de nouvelles variables si nécessaire.
Étape 5 : Modélisation ML
Création d'un modèle à partir de diérents algorithmes d'apprentissage

supervisé.
Utilisation d'algorithmes basés sur le problème et l'expérience.
Génération de graphiques de précision pour diérents méthodes.
Ces étapes sont itératives et essentielles pour résoudre un problème
d'apprentissage supervisé. Elles assurent la qualité, la complétude et la
pertinence des données pour obtenir des résultats ables.
Étapes de Formation de l'Algorithme
Pendant la formation de l'algorithme, les étapes suivantes sont suivies :

1 La donnée entière peut être divisée selon un ratio de 60 :20 :20 pour
les ensembles de données de test, d'entraînement et de validation.

Parfois, on utilise un ratio de 80 :20 pour les données d'entraînement
et de test.
2 Si le nombre de données brutes (par exemple, images) est assez élevé
(1 million), certaines études suggèrent d'avoir des ensembles de

données d'entraînement, de test et de validation respectivement de
98%, 1%, et 1%.
3 Les trois ensembles de données doivent toujours être échantillonnés de
manière aléatoire à partir des données brutes originales sans biais de

sélection. C'est impératif car si les ensembles de données de test ou de
validation ne sont pas représentatifs des données d'entraînement, nous
ne mesurerons pas correctement l'ecacité.
Étapes de Formation de l'Algorithme (suite)
4 L'ensemble de données d'entraînement est utilisé pour entraîner
l'algorithme. Les variables indépendantes agissent comme facteur de
guidage et la variable cible est celle que nous essayons de prédire.
5 L'ensemble de données de test est utilisé pour comparer l'exactitude
des tests. Les données de test/validation ne sont pas exposées à
l'algorithme pendant la phase d'entraînement.
6 Il convient de noter que l'exactitude des tests est beaucoup plus
importante que l'exactitude de l'entraînement. Puisque l'algorithme
devrait être capable de généraliser mieux sur des données invisibles,
l'accent est mis sur l'exactitude des tests.
7 Pendant le processus de développement du modèle, nous itérons à
travers divers paramètres d'entrée de notre modèle, appelés
hyperparamètres. L'ajustement des hyperparamètres est réalisé pour
obtenir la meilleure solution et la plus stable.
8 L'ensemble de validation ne doit être exposé à l'algorithme qu'une
seule fois, après avoir nalisé le réseau/l'algorithme et terminé
l'ajustement.
Comparaison et Implémentation
Dans cette étape, nous comparons et contrastons les exactitudes

générées par les diérents algorithmes de l'étape 4.
Une solution nale est le résultat de cette étape, suivie d'une
discussion avec les experts du domaine (SME) et ensuite de
l'implémentation dans l'environnement de production.
Ces étapes de formation d'algorithme garantissent une évaluation précise
de la performance et une sélection de la meilleure solution pour
l'implémentation dans un environnement de production.
Prétraitement des Données
Les étapes de prétraitement telles que la normalisation sont eectuées

uniquement pour les données d'entraînement et non pour les ensembles de
données de validation, an d'éviter toute fuite de données.
Outils Techniques Requis
Les principales bibliothèques utilisées sont numpy, pandas, matplotlib,

seaborn, scikit-learn, etc. Nous vous conseillons d'installer ces bibliothèques
dans votre environnement Python.
Analyse de Régression - Exemple 1
1 Importez les bibliothèques nécessaires : numpy, pandas, matplotlib et
scikit-learn.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
2 Générez un ensemble de données d'exemple pour la régression.

X, Y = make_regression(n_features=1, noise=5,
n_samples=5000)
Dans le code précédent, n_features est le nombre de fonctionnalités

que nous souhaitons avoir dans l'ensemble de données. n_samples est
le nombre d'échantillons que nous voulons générer. Le bruit est l'écart
type du bruit gaussien appliqué à la sortie.
3 Tracez les données à l'aide de la bibliothèque matplotlib.
plt.xlabel('Caractéristique - X')
plt.ylabel('Cible - Y')
plt.scatter(X, Y, s=5)
4 Initialisez une instance de régression.

linear_model = LinearRegression()
5 Entraînez le modèle de régression linéaire avec les données.

linear_model.fit(X, Y)
6 Obtenez les coecients pour l'interception et la pente du modèle de

régression linéaire.
linear_model.coef_
linear_model.intercept_
7 Utilisez le modèle entraîné pour prédire les valeurs et tracez-les pour

comparer avec les valeurs réelles.
pred = linear_model.predict(X)
plt.scatter(X, Y, s=25, label='entraînement')
plt.scatter(X, pred, s=25, label='prédiction')
plt.legend()
plt.show()
import numpy as np
import pandas as pd
from sklearn.datasets import make_regression
X, Y = make_regression(n_features=1, noise=5, n_samples=5000)
plt.scatter(X, Y, s=5)
linear_model = LinearRegression()
linear_model.fit(X, Y)
pred = linear_model.predict(X)
plt.scatter(X, Y, s=25, label='entraînement')
plt.scatter(X, pred, s=25, label='prédiction')
plt.legend()
plt.show()
Conclusion
Nous avons créé une solution pour la régression linéaire à l'aide d'un
ensemble de données d'exemple. Cette approche vous familiarise avec les
concepts de base de la régression linéaire.
1 Nous allons créer une solution de régression linéaire simple en utilisant

un ensemble de données sur le logement.
2 Notre ensemble de données contient une variable indépendante
(surface en pieds carrés) et nous devons prédire les prix. C'est à
nouveau un exemple de régression linéaire simple, c'est-à-dire que nous
avons une seule variable d'entrée.
Étape 1 : Importez toutes les bibliothèques requises ici :
import pandas as pd
import numpy as np
import seaborn as sns
%matplotlib inline
import warnings
warnings.filterwarnings(action="ignore", module="scipy",
message="^internal gelsd")
Étape 2 : Chargez l'ensemble de données à l'aide de la fonction pandas :
house_df= pd.read_csv('House_data_LR.csv')
house_df.head()
Ramarque
Il est possible que les données soient présentes sous la forme .xls ou .txt
déposer. Parfois, les données doivent être chargées directement depuis la
base de données en établissant une connexion à la base de données.
Étape 3 : Vériez s'il existe une valeur nulle dans l'ensemble de données :
house_df.isnull().any()
Étape 4 : Il existe une variable qui n'a pas de sens. Nous laissons tomber
la variable Unamed :
house_df.drop('Unamed : 0', axis = 1, inplace = True)
Étape 5 : Après avoir supprimé la variable, jetons un ÷il aux premières
lignes dans l'ensemble de données :
maison_df.head()
Étape 6 : Nous allons maintenant préparer l'ensemble de données pour la
création du modèle en séparant la variable indépendante et la variable cible.
X = maison_df.iloc[:, :1].values
y = house_df.iloc[:, -1].values
Étape 7 : Les données sont divisées en train et test maintenant. Répartition
Train/Test : la création d'un ensemble de données d'entraînement et de
test implique le fractionnement l'ensemble de données en ensembles de
formation et de test respectivement, qui sont mutuellement exclusif. Après
quoi, vous vous entraînez avec le kit d'entraînement et testez avec le
ensemble de test. Cela fournira une évaluation plus précise des données
hors échantillon précision car l'ensemble de données de test ne fait pas
partie de l'ensemble de données qui a été utilisé pour entraîner les données.
C'est plus réaliste pour les problèmes du monde réel.
Cela signie que nous connaissons le résultat de chaque point de données
dans cette ensemble de données, ce qui le rend idéal pour tester ! Et comme
ces données n'ont pas été utilisées pour entraîner le modèle, le modèle n'a
aucune connaissance du résultat de ces points de données. Il s'agit donc
essentiellement d'un test hors échantillon. Testez ici les données sont de 25
% ou 0,25. L'état aléatoire, comme son nom l'indique, sert à initialiser le
système interne. générateur de nombres aléatoires, qui à son tour décide de
la répartition du train/ indices de tests. Le garder xe nous permet de
reproduire la même répartition train/test et donc en vérication de la sortie.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size = 0.25, random_state = 5)
Étape 8 : Ajustez maintenant les données à l'aide du modèle de régression
linéaire :
simple_lr= LinearRegression()
simple_lr.fit(X_train, y_train)
Étape 9 : Le modèle est maintenant formé. Utilisons-le pour prédire sur les
données de test
y_pred = simple_lr.predict(X_test)
Étape 10 : Nous allons d'abord tester le modèle sur les données
d'entraînement. Nous allons essayer de prédisez sur les données
d'entraînement et visualisez les résultats sur celles-ci.
plt.scatter(X_train, y_train, color = 'r')
plt.plot(X_train, simple_lr.predict(X_train), color = 'b')
plt.title('Sqft Living vs Price for Training')
plt.xlabel('Square feet')
plt.ylabel('House Price')
plt.show()
Étape 11 : Testons maintenant le modèle sur les données de test. C'est la
mesure correcte pour vérier la robustesse du modèle.
plt.scatter(X_test, y_test, color = 'r')
plt.plot(X_train, simple_lr.predict(X_train), color = 'b')
plt.title('Sqft Living vs Price for Test')
plt.xlabel('Square feet')
plt.ylabel('House Price')
Étape 12 : Voyons maintenant dans quelle mesure nos prédictions sont
bonnes ou mauvaises. Nous calculerons le MSE et le R2.
from sklearn.metrics import mean_squared_error
from math import sqrt
rmse = sqrt(mean_squared_error(y_test, y_pred))
from sklearn.metrics import r2_score
r2 = r2_score(y_test, y_pred)
adj_r2 = 1 - float(len(y)-1)/(len(y)-len(simple_lr.coef_)-1)*(1
rmse, r2, adj_r2, simple_lr.coef_, simple_lr.intercept_
Étape 13 : Nous allons maintenant faire une prédiction sur la valeur
invisible de x :
import numpy as np
x_unseen=np.array([1500]).reshape(1,1)
simple_lr.predict(x_unseen)
The prediction is 376666.84
Code Python pour la Régression Linéaire Simple
import pandas as pd
import numpy as np
%matplotlib inline
import warnings
house_df = pd.read_csv('House_data_LR.csv')
house_df.head()
house_df.isnull().any()
house_df.drop('Unnamed: 0', axis=1, inplace=True)
house_df.head()
X = house_df.iloc[:, :1].values
y = house_df.iloc[:, -1].values

X_train, X_test, y_train, y_test = train_test_split(X, y, test_

simple_lr = LinearRegression()
simple_lr.fit(X_train, y_train)
y_pred = simple_lr.predict(X_test)
plt.scatter(X_train, y_train, color='r')

plt.plot(X_train, simple_lr.predict(X_train), color='b')
plt.title('Surface en pieds carrés vs Prix pour l'Entraînement'
plt.xlabel('Pieds Carrés')
plt.ylabel('Prix de la Maison')
plt.show()
plt.scatter(X_test, y_test, color='r')
plt.plot(X_train, simple_lr.predict(X_train), color='b')
plt.title('Surface en pieds carrés vs Prix pour le Test')
plt.xlabel('Pieds Carrés')
plt.ylabel('Prix de la Maison')

adj_r2 = 1 - float(len(y)-1)/(len(y)-len(simple_lr.coef_)-1)*(1
rmse, r2, adj_r2, simple_lr.coef_, simple_lr.intercept_
import numpy as np
x_unseen = np.array([1500]).reshape(1,1)
simple_lr.predict(x_unseen)
Résultats et Métriques
Erreur quadratique moyenne (RMSE) : 37572.45

Coecient de détermination (R2) : 0.71
Coecient de détermination ajusté : 0.71
Coecient de pente : 280.62
Terme d'interception : 19843.44
La prédiction pour une valeur inconnue de x (surface en pieds carrés de
1500) est de 376666.84.
Conclusion
Nous avons réalisé une analyse de régression linéaire simple sur un

ensemble de données sur le logement, en prédisant les prix en fonction de la
surface en pieds carrés. Les résultats montrent une bonne corrélation entre
la surface et le prix, avec un RMSE de 37572.45 et un R2 de 0.71.
Exemple 3 : Régression linéaire multiple pour l'ensemble de données sur le
logement Nous travaillons sur l'ensemble de données sur les prix de
l'immobilier. La variable cible est la prévision des prix de l'immobilier, et il
existe certaines variables indépendantes.
Étape 1 : Importez d'abord toutes les bibliothèques requises.
import pandas as pd
import numpy as np
%matplotlib inline
import warnings
Étape 2 : Importez les données sous forme de chier .csv. Vériez ensuite
les premières lignes.
house_mlr = pd.read_csv('House_data.csv')
house_mlr.head()
Étape 3 : Explorons ensuite l'ensemble de données dont nous disposons.
Cela se fait à l'aide de la commande house_mlr.info().
Étape 4 : la commande house_mlr.describe() donnera les détails sur
toutes les variables numériques.
Un très bon moyen de visualiser les variables consiste à utiliser un tracé en
boîte et moustaches en utilisant le code suivant.
fig = plt.figure(1, figsize=(9, 6))
ax = fig.add_subplot(111)
ax.boxplot(house_mlr['sqft_living15'])
Étape 5 : Nous allons maintenant vérier les corrélations entre les
variables. Cela se fera à l'aide d'une matrice de corrélation qui est
développée à l'aide du code suivant :
house_mlr.drop(['id', 'date'], axis = 1, inplace = True)
fig, ax = plt.subplots(figsize = (12,12))
ax = sns.heatmap(house_mlr.corr(),annot = True)
L'analyse de la matrice de corrélation montre qu'il existe une certaine
corrélation entre quelques variables. Par exemple, entre sqft_above et
sqft_living, il existe une corrélation de 0,88. Et c'est tout à fait attendu.
Pour ce premier exemple simple, nous ne traitons pas les variables corrélées.
Étape 6 : Nous allons maintenant nettoyer un peu les données. Il y a
quelques valeurs nulles présentes dans l'ensemble de données. Nous
abandonnons maintenant ces valeurs nulles.
house_mlr.isnull().any()
house_mlr ['basement'] = (house_mlr ['sqft_basement'] > 0).
astype(int)
house_mlr ['renovated'] = (house_mlr ['yr_renovated'] > 0).
astype(int)
to_drop = ['sqft_basement', 'yr_renovated']
house_mlr.drop(to_drop, axis = 1, inplace = True)
house_mlr.head()
Étape 7 : Les variables catégorielles sont converties en variables
numériques à l'aide d'un codage à chaud.
categorical_variables = ['waterfront', 'view', 'condition',
'grade', 'floors','zipcode']
house_mlr = pd.get_dummies(house_mlr, columns = categorical_
variables, drop_first=True)
house_mlr.head()
Étape 8 : Nous allons maintenant diviser les données en entraînement et
test, puis ajuster le modèle. La taille du test représente 25 % des données.
X = house_mlr.iloc[:, 1:].values
y = house_mlr.iloc[:, 0].values
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size = 0.25, random_state = 5)
multiple_regression = LinearRegression()
multiple_regression.fit(X_train, y_train)
Étape 9 : Prédisez les résultats de l'ensemble de tests.
y_pred = multiple_regression.predict(X_test)
Étape 10 : Nous allons maintenant vérier l'exactitude de notre modèle.
adj_r2 = 1 - float(len(y)-1)/(len(y)-len(multiple_regression.
coef_)-1)*(1 - r2)
rmse, r2, adj_r2
Introduction au classication supervisé
Dans le cas d'un problème de classication, le modèle prédictif peut
prendre directement la forme d'une fonction f à valeurs dans 0, 1, ou
utiliser une fonction intermédiaire g à valeurs réelles, qui associe à une
observation un score d'autant plus élevé qu'elle est susceptible d'être
positive. Ce score peut par exemple être la probabilité que cette
observation appartienne à la classe positive. On obtient alors f en seuillant
g ; g est appelée fonction de décision.
Dénition 1
Dans le cadre d'un problème de classication binaire, on appelle fonction
de décision, ou fonction discriminante, une fonction g : X 7→ R telle que
f (x) = 0 si et seulement si g (x) ≤ 0 et f (x) = 1 si et seulement si
g (x) > 0.
Cette dénition se généralise dans le cas de la classication multi-classe :
on a alors C fonctions de décision gc : X 7→ R telles que
f (x) = arg max gc (x).
c=1,...,c
Le concept de fonction de décision permet de partitionner l'espace en
régions de décision :
Dénition : (Région de décision)
Dans le cas d'un problème de classication binaire, la fonction
discriminante partitionne l'espace des observations X en deux régions de
décision, R0 et R1 , telles que :
R0 = {x ∈ X |g (x) ≤ 0} et R1 = {x ∈ X |g (x) > 0}.
Dans le cas multi-classe, on a alors C régions de décision :
Rc = {x ∈ X |gc (x) = max gk (x)}.
k
Les régions de décision sont séparées par des frontières de décision :
Dénition (Frontière de décision)
Dans le cadre d'un problème de classication, on appelle frontière de
décision, ou discriminant, l'ensemble des points de X où une fonction de
décision s'annule. Dans le cas d'un problème binaire, il y a une seule
frontière de décision ; dans le cas d'un problème multi-classe à C classes, il
y en a C .
Algorithmes de classication
Les algorithmes de classication sont utilisés pour modéliser la probabilité

d'appartenance à une classe particulière. Ils sont essentiels en apprentissage
supervisé pour résoudre divers problèmes de classication, tels que la
prédiction binaire ou multiclasse. Voici quelques exemples de problèmes de
classication :
Classication binaire : réussite/échec, sain/malade,
frauduleux/authentique, oui/non, etc.
Classication multiclasse : bon/mauvais/neutre,
rouge/jaune/bleu/vert, chat/chien/cheval/voiture, etc.
Exemples d'utilisation
1 Détaillant en perte de clients réguliers : Identier les clients à

risque de partir pour cibler des ores spéciales et les déliser.
2 Usine cherchant à maintenir la qualité : Prédire la qualité des
produits en fonction des variables de production pour optimiser les
processus.
3 Fournisseur d'assurance : Évaluer le risque des clients pour décider
des politiques d'acceptation de police.
4 Banque détectant la fraude : Classier les transactions en
frauduleuses ou authentiques pour prévenir la fraude.
5 Opérateur télécoms : Cibler les clients intéressés par de nouveaux
produits en analysant leurs habitudes de consommation.
Algorithmes utilisables
Voici quelques-uns des algorithmes de classication couramment utilisés :

Minimisation du risque empirique (ERM)
Régression logistique
k plus proches voisins (k-NN)
Arbre de décision
Forêt aléatoire (Random Forest)
Bayes naïf (Naïve Bayes)
Machines à vecteurs de support (SVM)
Boosting de gradient (Gradient Boosting)
Réseaux de neurones (Neural Networks)
Minimisation du risque empirique (ERM)
Convexication du risque. Données : (Xi , Yi )i=1,...,n ∈ X × {−1, 1}
indépendantes et identiquement distribuées.
But : trouver f : X → {−1, 1} telle que :
R(f ) = E(1f (X )̸=Y ) = P(f (X ) ̸= Y )
soit le plus petit possible.
Remarque 1. R(f ) désigne le risque, ou encore la probabilité d'erreur de f .
Problème : {−1, 1} n'est pas un espace vectoriel, donc {f : X → {−1, 1}}
non plus, ce qui peut poser une diculté pour résoudre un problème de
minimisation.
Nouveau but : trouver f : X → R et considérer alors la fonction :
x 7→ sign(f (x)) comme prédicteur, où :
1 si a > 0


sign(a) = −1 si a < 0

0 si a = 0
Risque : Le risque devient alors :
R(f ) = P(sign(f (X )) ̸= Y ) = E(1sign(f (X ))̸=Y ) = E(1Yf (X )≤0 )
= E[Φ0−1 (Yf (X ))]
où : Φ0−1 est la perte 0 - 1.

Risque empirique :
1X
n
R̂(f ) = Φ0−1 (Yi f (Xi ))
n
i=1
On cherche à minimiser le risque empirique, mais on ne peut pas le faire

directement car Φ0−1 est ni continue, ni convexe.
Question : Quel lien y a-t-il entre la perte 0 - 1 et les pertes convexes ?
Exemple 1.
1 Perte quadratique : ici Φ(u) = (u − 1)2

Φ(Yf (X )) = (Y − f (X ))2 = (f (X ) − Y )2
On retrouve les moindres carrés.
RΦ (f ) := E[Φ(Yf (X ))] = E[(f (X ) − Y )2 ]
RΦ (f )est appelé le Φ-risque.
2 Perte logistique : ici Φ(u) = log(1 + e −u )
1

Φ(Yf (X )) = log(1+e −Yf (X )
) = − log = − log(σ(Yf (X )
1 + e −Yf (X )
où : σ(v ) = 1+e1 −v fonction sigmoïde.
Lien avec les probabilités : on considère le modèle déni par :
q(Y = 1|X = x) = σ(f (x)) et q(Y = −1|X = x) = σ(−f (x))
Alors le risque est égal à -la log-vraisemblance conditionnelle :
E[− log(q(Y |X ))]
Exemple 1.
3 Perte hinge : ici Φ(u) = max(1 − u, 0) Soit f (x) = w T x + b, on

appelle marge la quantité (ceci correspond à une interprétation
géométrique) :
1
||w ||
On cherchera donc à minimiser ||w ||. Un classieur adapté à ce
problème est appelé classieur "maximum margin".
Remarque 2. Pour ce dernier exemple, il y a deux formulations possibles :
1 La formulation SVM (=support vector machine) séparable :
1
tel que yi (w T xi + b) ≥ 1
min ||w ||2
2
2 La formulation SVM non séparable :
1 n
min ||w ||2 + c tel que yi (w T xi + b) ≥ 1 − ξi , ξi ≥ 0
X
ξi
2 i=1
Cette dernière peut se reformuler comme suit :

1 n
2
max(0, 1 − yi (w T xi + b))
X
min ||w || + c
2 i=1
Ou encore :
1 n
min ||w ||2 + c
X
Φ(yi f (xi )))
2 i=1
Exemple 2. Si on note :
1 n n n
L(w , ξ, α, β) = ||w ||2 + c αi (yi (w T xi + b) − 1 + ξi )
X X X
ξi − β i ξi −
2 i=1 i=1 i=1
Les variables w , ξ sont liées au problème primal ; les variables α, β sont

liées au problème dual.
Pour minimiser cette expression en w , en dérivant, on trouve :
0 = w − ni=1 αi yi xi
P
En minimisant en ξ on trouve : 0 = c − αi − βi
n
En minimisant en b, on trouve : 0 = αi yi
X
1
i=P
Et le problème dual s'écrit : maxα − 12 || n
i=1 αi yi xi ||
2 telle que :
 n
0 =
X
αi yi

i=1
0 ≤ αi ≤ c


Remarque 3. Les conditions de KKT s'écrivent :
(c − αi )ξi = 0, i = 1, . . . , n
αi (yi (w T xi + b) − 1 + ξi ) = 0, i = 1, . . . , n
On remarque alors que si yi (w T xi + b) − 1 > 0, cela signie qu'on est à
droite du hinge et, puisque ξi ≥ 0 implique ici ξi = 0, on a : αi = 0.
De même, si yi (w T xi + b) − 1 = 0, cela signie qu'on est sur le hinge, et
on a : 0 ≤ αi ≤ c .
Enn, si yi (w T xi + b) − 1 < 0, cela signie qu'on est à gauche du hinge, et
on a : αi = c , car ξi > 0.
Notons que ceci est un cas particulier du théorème du représentant (cours
sur les noyaux).
Il existe de nombreuses façons d'évaluer la performance prédictive d'un
modèle d'apprentissage supervisé. Cette section présente les principaux
critères utilisés.
Le nombre d'erreurs de classication est utilisé pour évaluer la qualité d'un
modèle prédictif. Il est préférable d'exprimer ce nombre d'erreurs sous
forme de fraction du nombre total d'exemples, par exemple un taux
d'erreur de 1% est plus parlant qu'un nombre absolu d'erreurs.
Un modèle qui prédit si une radiographie montre une tumeur
inquiétante : une fausse alerte est moins problématique que de ne pas
détecter la tumeur.
Les performances d'un modèle de classication (binaire ou multiclasse)
peuvent être résumées dans une matrice de confusion.
Dénition de la Matrice de Confusion
Matrice de Confusion : Une matrice M contenant autant de lignes que
de colonnes que de classes, où Mck est le nombre d'exemples de la classe c
pour laquelle l'étiquette k a été prédite.
Classe réelle/prédite 0 1
0 Vrais Négatifs (TN) Faux Négatifs (FN)
1 Faux Positifs (FP) Vrais Positifs (TP)
Vrais Positifs (TP) : Exemples positifs correctement classiés.
Faux Positifs (FP) : Exemples négatifs étiquetés positifs par le
modèle.
Vrais Négatifs (TN) : Exemples négatifs correctement classiés.
Faux Négatifs (FN) : Exemples positifs étiquetés négatifs par le
modèle.
Les faux positifs sont également appelés fausses alarmes ou erreurs de type
I, tandis que les faux négatifs sont des erreurs de type II.
Critères d'Évaluation à partir de la Matrice de Confusion
TP
Rappel (Recall) : Rappel =
TP + FN
Le rappel mesure la proportion d'exemples positifs correctement identiés.
TP
Précision (Precision) : Précision =
TP + FP
La précision mesure la proportion de prédictions positives correctes.
2 · Précision · Rappel
F-mesure (F-score) : F=
Précision + Rappel
La F-mesure est la moyenne harmonique de la précision et du rappel.
TN
Spécicité (Specicity) : Spécicité =
FP + TN
La spécicité mesure la proportion d'exemples négatifs correctement
identiés.
Évaluation de Méthodes de Classication Binaire
Courbe ROC (Receiver-Operator Characteristic) :
Dénition : courbe décrivant la sensibilité en fonction du
complémentaire de la spécicité lorsque le seuil de décision change.
Utilité : évaluer la qualité de la fonction de décision avant le seuillage.
Synthèse : l'aire sous la courbe ROC (AUROC) est souvent utilisée
pour quantier la performance du modèle.
Exemple : voir Figure pour une illustration de la courbe ROC.
Courbe Précision-Rappel (PR)
Courbe PR (Precision-Recall curve) :
Dénition : courbe décrivant l'évolution de la précision en fonction du
rappel lorsque le seuil de décision change.
Utilité : complément de la courbe ROC pour évaluer la qualité de la
fonction de décision.
Synthèse : l'aire sous la courbe PR (AUPR) est souvent utilisée pour
quantier la performance du modèle.
Exemple : voir Figure pour une illustration de la courbe PR.
Comprendre la fonction logistique
La fonction logistique est une membre des fonctions sigmoïdes (en forme
de S), et elle est représentée par la formule suivante :
1
f (θ) =
1 + e −θ
Ne laissez pas cette équation vous erayer. Ce qui importe réellement, c'est
l'aspect visuel de cette fonction. Heureusement, nous pouvons utiliser notre
ordinateur pour générer une série de valeurs pour θpar exemple, entre
-10 et 10.
Ensuite, nous pouvons insérer ces valeurs dans la formule et tracer les
valeurs de y résultantes par rapport aux valeurs de θ, comme nous l'avons
fait dans le code suivant :
import numpy as np
import pandas as pd
fig, ax = plt.subplots(1, 1, figsize=(16, 8))
theta = np.arange(-10, 10, 0.05)
y = 1 / (1 + np.exp(-1 * theta))
pd.DataFrame(
{
'theta': theta,
'y': y
}
).plot(
title='Logistic Function',
kind='scatter', x='theta', y='y',
ax=ax
)
fig.show()
1
0.8
0.6
y
0.4
0.2
0
−10 −5 0 5 10
θ
Deux caractéristiques clés à remarquer dans la fonction logistique sont les
suivantes :
1 y se situe uniquement entre 0 et 1. Elle tend vers 1 lorsque θ tend vers
l'inni, et tend vers 0 lorsque θ tend vers moins l'inni.

2 y prend la valeur de 0.5 lorsque θ est égal à 0.
Modèle de régression logistique
Pour un modèle linéaire avec deux caractéristiques, x1 et x2 , nous pouvons

avoir un intercepte et deux coecients. Appelons-les β0 , β1 , et β2 . Alors,
l'équation de régression linéaire sera la suivante :
y = β0 + β1 x1 + β2 x2
Séparément, nous pouvons également insérer le côté droit de l'équation

précédente dans la fonction logistique à la place de y . Cela donnera
l'équation suivante pour y :
1
y=
1 + e 0 1 x1 +β2 x2 )
−(β +β
Dans ce cas, la variation des valeurs de x fera évoluer y entre 0 et 1. Des

valeurs plus élevées pour les produits de x et de ses coecients
rapprocheront y de 1, et des valeurs plus basses la rapprocheront de 0.
Nous savons également que les probabilités prennent des valeurs entre 0 et
1. Ainsi, il est logique d'interpréter y comme la probabilité que y
appartienne à une certaine classe, étant donné la valeur de x . Si nous ne
voulons pas traiter avec des probabilités, nous pouvons simplement spécier
un seuil ; alors, notre échantillon appartient à la classe 1, sinon il appartient
à la classe 0.
C'était un bref aperçu de la façon dont la régression logistique fonctionne.
C'est un classieur, mais on l'appelle régression car c'est essentiellement un
régresseur renvoyant une valeur entre 0 et 1, que nous interprétons comme
des probabilités.
Pour entraîner le modèle de régression logistique, nous avons besoin d'une
fonction objective, ainsi que d'un solveur qui tente de trouver les
coecients optimaux pour minimiser cette fonction. Dans les sections
suivantes, nous aborderons tout cela plus en détail.
Fonction objectif
Pendant la phase d'entraînement, l'algorithme parcourt les données en

essayant de trouver les coecients qui minimisent une fonction objectif
(perte) prédénie. La fonction de perte que nous essayons de minimiser
dans le cas de la régression logistique est appelée perte logarithmique (log
loss). Elle mesure dans quelle mesure les probabilités prédites (p) dièrent
des étiquettes de classe réelles (y) en utilisant la formule suivante :
− log(p) si y == 1 sinon − log(1 − p)
Les mathématiciens utilisent une manière plutôt complexe pour exprimer

cette formule en raison de leur absence de conditions if-else. Donc, j'ai
choisi d'acher la forme Python ici pour sa clarté. Plaisanteries à part, la
formule mathématique se révélera belle une fois que vous connaîtrez ses
racines en théorie de l'information, mais ce n'est pas quelque chose que
nous examinerons maintenant.
Régularisation
De plus, l'implémentation des algorithmes de régression logistique de

scikit-learn utilise la régularisation par défaut. Par défaut, elle utilise la
régularisation L2 (comme dans le régresseur de ridge), mais elle peut
également utiliser L1 (comme dans lasso) ou une combinaison de L1 et L2
(comme dans elastic-net).
Solveurs
Enn, comment trouvons-nous les coecients optimaux pour minimiser

notre fonction de perte ? Une approche naïve serait d'essayer toutes les
combinaisons possibles des coecients jusqu'à ce que la perte minimale
soit trouvée. Néanmoins, étant donné que la recherche exhaustive n'est pas
réalisable compte tenu des combinaisons innies, les solveurs sont là pour
rechercher ecacement les meilleurs coecients. scikit-learn implémente
environ une demi-douzaine de solveurs.
Le choix du solveur, ainsi que de la méthode de régularisation utilisée, sont
les deux principales décisions à prendre lors de la conguration de
l'algorithme de régression logistique. Dans la section suivante, nous allons
voir comment et quand choisir chacun d'entre eux.
Conguration du classieur de régression logistique et
Solveurs
t_intercept : Habituellement, en plus du coecient pour chaque
caractéristique, il y a un intercepte constant dans votre équation.
Néanmoins, il y a des cas où vous pourriez ne pas avoir besoin d'un
intercepte. Par exemple, si vous savez avec certitude que la valeur de y
doit être de 0,5 lorsque toutes les valeurs de x sont de 0. Une autre
situation est lorsque vos données ont déjà une colonne constante
supplémentaire avec toutes les valeurs dénies à 1.
max_iter : Pour que le solveur trouve les coecients optimaux, il
parcourt les données d'entraînement plus d'une fois. Ces itérations
sont également appelées époques. Vous dénissez généralement une
limite sur le nombre d'itérations pour éviter le surajustement.
tol : Il s'agit d'une autre manière d'arrêter le solveur d'itérer trop. Si
vous le réglez sur une valeur élevée, cela signie que seules les
améliorations importantes entre une itération et la suivante sont
tolérées ; sinon, le solveur s'arrêtera.
penalty : Cela choisit les techniques de régularisation à utiliser. Il peut
s'agir de L1 , L2 , elastic-net, ou aucun pour aucune régularisation.
C ou alpha : Ce sont des paramètres pour dénir à quel point vous
voulez que la régularisation soit forte. Des valeurs plus petites pour C
spécient une régularisation plus forte, tandis que pour alpha, des
valeurs plus grandes sont nécessaires pour une régularisation plus forte.
l1_ratio : Lors de l'utilisation d'un mélange de L1 et L2 , comme dans
elastic-net, cette fraction spécie combien de poids donner à L1 par
rapport à L2 .
Solveurs :
liblinear : Ce solveur est implémenté dans LogisticRegression et est
recommandé pour les petits ensembles de données.
sag ou saga : Ces solveurs sont implémentés dans LogisticRegression
et RidgeClassier. Ils sont plus rapides pour les grands ensembles de
données.
lbfgs : Ce solveur est implémenté dans LogisticRegression. Il supporte
la pénalité L2 ou aucune régularisation du tout.
Descente de gradient stochastique (SGD) : Il existe des
implémentations dédiées pour SGD - SGDClassier et SGDRegressor.
Contexte Professionnel
Le risque de crédit est la possibilité qu'un emprunteur ne rembourse pas

son prêt selon les termes convenus. Dans le secteur bancaire, c'est un
facteur crucial à prendre en compte avant d'approuver un prêt pour un
demandeur. La société Dream Housing Finance ore des prêts immobiliers
dans toutes les zones, urbaines, semi-urbaines et rurales. Les clients
soumettent d'abord une demande de prêt immobilier, puis la société valide
leur admissibilité au prêt.
Objectif Commercial
La société souhaite automatiser le processus d'admissibilité aux prêts (en

temps réel) en fonction des détails fournis par le client lors de la soumission
du formulaire de demande en ligne. Ces détails comprennent le genre, l'état
civil, l'éducation, le nombre de personnes à charge, le revenu, le montant
du prêt, l'historique de crédit, etc. Pour automatiser ce processus, ils ont
posé un problème pour identier les segments de clients éligibles aux
montants de prêt an de cibler spéciquement ces clients. Ils ont fourni un
ensemble de données partiel.
Jeu de Données
Loan_ID : Identiant unique du prêt
Gender : Homme/Femme
Married : Marié (O/N)
Dependents : Nombre de personnes à charge
Education : Éducation de l'applicant (Gradué/Non gradué)
Self_Employed : Travailleur indépendant (O/N)
ApplicantIncome : Revenu de l'applicant
CoapplicantIncome : Revenu du co-emprunteur
LoanAmount : Montant du prêt en milliers
Loan_Amount_Term : Durée du prêt en mois
Credit_History : Historique de crédit conforme aux directives
Property_Area : Zone (Urbain/Semi-Urbain/Rural)
Loan_Status : Prêt approuvé (O/N)
Importation des Bibliothèques
Étape 1 : Importez d'abord toutes les bibliothèques requises. En important
Seaborn pour des tracés statistiques, an de diviser les trames de données
en ensemble d'entraînement et en ensemble de test, nous utiliserons la
fonction de fractionnement de données du package sklearn, qui est basée
sur une fonction aléatoire. Pour calculer les mesures de précision et les
matrices de confusion, nous avons importé des métriques de sklearn.
Code Python
import pandas as pd
from sklearn.linear_model import LogisticRegression
import numpy as np
import os,sys
from scipy import stats
from sklearn import metrics
import
Nachaoui Mouradseaborn as sn Cours sur la Classication Supervisée
(ENSA de Khouribga) 25 mars 2024 94 / 103
Étape 2 : Chargez l'ensemble de données à l'aide de la commande
read_csv. Le résultat est présenté ci-dessous.
loan_df = pd.read_csv('CreditRisk.csv')
loan_df.head()
Étape 3 : Examinez la forme des données :

loan_df.shape
Etape 4 : credit_df = loan_df.drop('Loan_ID', axis =1 ) # cette

colonne car ce sera de toute façon un mappage 1-1 :
credit_df.head()
Étape 5 : Normalisez ensuite les valeurs de la valeur du prêt et

visualisez-la également.
credit_df['Loan_Amount_Term'].value_counts(normalize=True)
plt.hist(credit_df['Loan_Amount_Term'], 50)
Étape 6 : Visualisez ensuite les données comme un graphique linéaire.
plt.plot(credit_df.LoanAmount)
plt.xlabel('Loan Amount')
plt.ylabel('Frequency')
plt.title("Plot of the Loan Amount")
Étape 7 : Le Loan_Amount_Term est très asymétrique et nous

supprimons donc cette variable.
credit_df.drop(['Loan_Amount_Term'], axis=1, inplace=True)
8 : Le traitement des valeurs manquantes est ensuite eectué et la

valeur manquante de chaque variable est remplacée par 0. Comparez
les résultats après avoir remplacé les valeurs manquantes par la
médiane.
credit_df = credit_df.fillna('0')
##credit_df = credit_df.replace({'NaN':credit_df.median()})
credit_df
Étape 9 : Nous analyserons ensuite la façon dont nos variables sont
distribuées.
credit_df.describe().transpose()
Étape 10 : Examinons la colonne cible, Loan_Status , pour

comprendre comment les données sont réparties entre les diérentes
valeurs.
credit_df.groupby(["Loan_Status"]).mean()
Étape 11 : Nous allons maintenant convertir les variables X et Y en

variable catégorielle.
credit_df['Loan_Status'] = credit_df['Loan_Status'].
astype('category')
credit_df['Credit_History'] = credit_df['Credit_History'].
astype('category')
Étape 12 : Vériez les types de données présents dans les données
dont nous disposons actuellement,
credit_df.info()
Étape 13 : Vériez comment les données sont équilibrées.

prop_Y = credit_df['Loan_Status'].value_counts(normalize=True)
print(prop_Y)
Étape 14 : Nous allons maintenant dénir les variables X et Y.

X = credit_df.drop('Loan_Status', axis=1)
Y = credit_df[['Loan_Status']]
Étape 15 : En utilisant un encodage à chaud, nous convertirons les

variables catégorielles en variables numériques :
X = pd.get_dummies(X, drop_first=True)
Étape 16 : Divisez maintenant en ensembles de formation et de test.
Nous nous divisons dans un ratio de 70 : 30
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_
size=0.30)
Étape 17 : Construisez maintenant le modèle de régression logistique

réel :
Étape 18 : Nous allons maintenant vérier le résumé du modèle.

from scipy import stats
stats.chisqprob = lambda chisq, df: stats.chi2.sf(chisq, df)
print(lg.summary())
Étape 19 : Ensuite, nous calculerons le rapport de cotes à partir des
coecients en utilisant la formule odds ratio=exp(coef ). Ensuite,
nous calculerons la probabilité à partir du rapport de cotes en utilisant
la formule de probabilité= odds / (1+odds).
log_coef = pd.DataFrame(lg.params, columns=['coef'])
log_coef.loc[:, "Odds_ratio"] = np.exp(log_coef.coef)
log_coef['probability'] = log_coef['Odds_ratio']/(1+log_
coef['Odds_ratio'])
log_coef['pval']=lg.pvalues
pd.options.display.float_format = '{:.2f}'.format
Étape 20 : Nous allons maintenant ltrer toutes les variables

indépendantes par valeur de p signicative (valeur de p <0,1) et trier
par ordre décroissant par rapport de cotes.
log_coef = log_coef.sort_values(by="Odds_ratio",
ascending=False)
pval_filter = log_coef['pval']<=0.1
log_coef[pval_filter]
Étape 21 : Nous ajustons maintenant le modèle à l'aide des données
d'entraînement. Le .t est la fonction utilisée pour cela.
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)
Étape 22 : Une fois le modèle prêt et ajusté, nous pouvons l'utiliser

pour faire une prédiction. Mais nous devons d'abord vérier
l'exactitude du modèle sur les données d'entraînement à l'aide d'une
matrice de confusion ;
pred_train = log_reg.predict(X_train)
from sklearn.metrics import classification_report,
confusion_matrix
mat_train = confusion_matrix(y_train,pred_train)
print("confusion matrix = \n",mat_train)
Étape 23 : Nous allons ensuite faire la prédiction pour l'ensemble de
test et la visualiser,
pred_test = log_reg.predict(X_test)
mat_test = confusion_matrix(y_test,pred_test)
print("confusion matrix = \n",mat_test)
ax= plt.subplot()
ax.set_ylim(2.0, 0)
annot_kws = {"ha": 'left',"va": 'top'}
sns.heatmap(mat_test, annot=True, ax = ax, fmt= 'g',
annot_kws=annot_kws); #annot=True to annotate cells
ax.set_xlabel('Predicted labels');
ax.set_ylabel('True labels');
ax.set_title('Confusion Matrix');
ax.xaxis.set_ticklabels(['Not Approved', 'Approved']);
ax.yaxis.set_ticklabels(['Not Approved', 'Approved']);
Étape 24 : Créons maintenant la courbe AUC ROC et obtenons le
score AUC.
from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve
logit_roc_auc = roc_auc_score(y_test, log_reg.predict(X_test))
fpr, tpr, thresholds = roc_curve(y_test, log_reg.predict_
proba(X_test)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='Logistic Regression (area = %0.2f)' %
logit_roc_auc)
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.savefig('Log_ROC')
plt.show()

partie 4

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

partie 4

Transféré par

Droits d'auteur :

Formats disponibles

Cours sur la Classication Supervisée

Intégrité des données : Lorsque vous enregistrez les données dans

Le génie logiciel et l'apprentissage automatique (ML) résolvent tous

Génie Logiciel : implique l'écriture de code précis qui peut être

décision pour prendre une décision nale.

Les règles générées par les algorithmes de ML dépendent des

L'apprentissage automatique est une solution fantastique pour les

Un projet d'apprentissage automatique est similaire à tout autre

1 Découverte des données : exploration des diérentes sources de

4 Modélisation ML : phase de développement réel du modèle. Nous

Avant de commencer le projet, voici quelques questions que nous devrions

Maintenant que vous savez ce qu'est l'apprentissage automatique et les

Le but de l'algorithme d'apprentissage supervisé est d'atteindre une

Régression : utilisée pour prédire la valeur d'une variable continue.

1 Optimisation du risque empirique : En utilisant gradient-descent ou

3 Arbre de Décision : pour les problèmes de régression et de

5 Machine à Vecteurs de Support (SVM) : pour les problèmes de

En pratique commerciale, nous comparons les précisions de quatre ou cinq

Nous avons examiné la dénition de l'algorithme d'apprentissage supervisé

Nous avons la variable cible et les variables indépendantes.

Les données d'entraînement doivent respecter les meilleures pratiques

Nettoyage des données : valeurs nulles, doublons, etc.

Génération d'aperçus initiaux à partir des données.

Création d'un modèle à partir de diérents algorithmes d'apprentissage

Pendant la formation de l'algorithme, les étapes suivantes sont suivies :

les ensembles de données de test, d'entraînement et de validation.

(1 million), certaines études suggèrent d'avoir des ensembles de

manière aléatoire à partir des données brutes originales sans biais de

Dans cette étape, nous comparons et contrastons les exactitudes

Les étapes de prétraitement telles que la normalisation sont eectuées

Les principales bibliothèques utilisées sont numpy, pandas, matplotlib,

2 Générez un ensemble de données d'exemple pour la régression.

Dans le code précédent, n_features est le nombre de fonctionnalités

4 Initialisez une instance de régression.

5 Entraînez le modèle de régression linéaire avec les données.

6 Obtenez les coecients pour l'interception et la pente du modèle de

7 Utilisez le modèle entraîné pour prédire les valeurs et tracez-les pour

1 Nous allons créer une solution de régression linéaire simple en utilisant

house_df.drop('Unnamed: 0', axis=1, inplace=True)

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LinearRegression

plt.scatter(X_train, y_train, color='r')

from sklearn.metrics import mean_squared_error

Erreur quadratique moyenne (RMSE) : 37572.45

Nous avons réalisé une analyse de régression linéaire simple sur un

Les algorithmes de classication sont utilisés pour modéliser la probabilité

1 Détaillant en perte de clients réguliers : Identier les clients à

Voici quelques-uns des algorithmes de classication couramment utilisés :

où : Φ0−1 est la perte 0 - 1.

On cherche à minimiser le risque empirique, mais on ne peut pas le faire

1 Perte quadratique : ici Φ(u) = (u − 1)2

3 Perte hinge : ici Φ(u) = max(1 − u, 0) Soit f (x) = w T x + b, on

Cette dernière peut se reformuler comme suit :

Les variables w , ξ sont liées au problème primal ; les variables α, β sont

l'inni, et tend vers 0 lorsque θ tend vers moins l'inni.

Pour un modèle linéaire avec deux caractéristiques, x1 et x2 , nous pouvons

Séparément, nous pouvons également insérer le côté droit de l'équation

Dans ce cas, la variation des valeurs de x fera évoluer y entre 0 et 1. Des

Pendant la phase d'entraînement, l'algorithme parcourt les données en

Les mathématiciens utilisent une manière plutôt complexe pour exprimer

De plus, l'implémentation des algorithmes de régression logistique de

Enn, comment trouvons-nous les coecients optimaux pour minimiser

Le risque de crédit est la possibilité qu'un emprunteur ne rembourse pas

La société souhaite automatiser le processus d'admissibilité aux prêts (en

Cours sur la Classication Supervisée

décision pour prendre une décision nale.

1 Découverte des données : exploration des diérentes sources de

Nous avons examiné la dénition de l'algorithme d'apprentissage supervisé

Création d'un modèle à partir de diérents algorithmes d'apprentissage

Les étapes de prétraitement telles que la normalisation sont eectuées

6 Obtenez les coecients pour l'interception et la pente du modèle de

Les algorithmes de classication sont utilisés pour modéliser la probabilité

1 Détaillant en perte de clients réguliers : Identier les clients à

Voici quelques-uns des algorithmes de classication couramment utilisés :

l'inni, et tend vers 0 lorsque θ tend vers moins l'inni.

Enn, comment trouvons-nous les coecients optimaux pour minimiser

8 : Le traitement des valeurs manquantes est ensuite eectué et la

Étape 10 : Examinons la colonne cible, Loan_Status , pour

Étape 13 : Vériez comment les données sont équilibrées.

Étape 14 : Nous allons maintenant dénir les variables X et Y.

Étape 18 : Nous allons maintenant vérier le résumé du modèle.

Étape 20 : Nous allons maintenant ltrer toutes les variables