Intro Machine Learning

1
Introduction au Machine Learning

 Post Author:Guillaume Saint-Cirgue
 Post published:juin 21, 2019
 Post Category:Machine Learning
 Post Comments:23 commentaires
Bon. Qu’est-ce-que le Machine Learning ? En tant que Data Scientist professionnel, je désire
vous donner une réponse claire à cette question, en démystifiant au passage le concept
d’Intelligence Artificielle. Voici donc une introduction au Machine Learning qui vous permettra
de comprendre le fonctionnement de cette technologie ainsi que ses applications.
Pour accompagner cet article, je vous offre une copie de mon livre “Apprendre le machine
learning en une semaine“.
Recevoir le livre gratuit
Définition du Machine Learning

Le Machine Learning est un domaine d’étude de l’IA qui vise à donner aux machines la
capacité d’apprendre. Cette technologie très puissante a permit le développement des voitures
autonomes, de la reconnaissance vocale, et de tous les systèmes dits “intelligents” depuis les 10
dernières années.
Le Machine Learning a été inventé par Arthur Samuel en 1959, après que celui-ci ait développé
le premier programme de jeu de Dames doté d’une intelligence artificielle. Ce programme avait
appris à jouer aux Dames tout seul, sans recevoir la moindre instruction de son développeur.
“Comment a-t-il fait ?” Nous le verrons plus loin dans cet article.
Suite à son invention, Arthur Samuel a formulé la définition historique du Machine Learning :
“Le Machine Learning est la science de donner à une machine la capacité d’apprendre, sans la
programmer de façon explicite.“
Apprentissage Statistique
Aujourd’hui, nous avons une façon plus mathématique de définir le Machine Learning. En
français, nous appelons ça Apprentissage Statistique (ou apprentissage automatique) car la
majorité des algorithmes utilisés en Machine Learning sont en réalité des modèles statistiques
développées à partir de données. Parmi ces modèles, on retrouve par exemple les arbres de
décision, la régression linéaire, ainsi que les modèles Bayésien.
2
Le
Machine Learning consiste à laisser la machine développer un modèle statistiques à partir de
données qui lui sont fournies.
Ainsi, pour qu’une machine apprenne à reconnaître un visage sur une photo, nous lui fournissons
des milliers de photos à étudier, et la machine développe ses propres règles statistiques
permettant de différencier les visages.
Comment fonctionne le Machine Learning ?

Pour comprendre comment une machine peut apprendre à partir de données, il faut se pencher sur
les 3 paradigmes d’apprentissage du Machine Learning :
 L’Apprentissage Supervisé (Supervised Learning)

 L’Apprentissage Non-Supervisé (Unsupervised Learning)
 L’Apprentissage par Renforcement (Reinforcement Learning)
Apprentissage Supervisé : Définition

L’Apprentissage Supervisé est utilisé pour développer des modèles prédictifs, c’est-à-dire des
modèles capables de prédire une certaine valeur en fonction de variables
Exemples : Prédire le nom d’une personne ( ) à partir d’une photo ( ), ou bien prédire le prix
d’un appartement ( ) en fonction de sa surface habitable ( ) et du nombre de pièces ( )
Pour développer de tels modèles, il faut en premier lieu fournir à la machine une grande quantité
de données . On appelle cela un dataset (un jeu de données). Ensuite, on demande à la
machine de développer une fonction d’approximation qui représente au mieux la relation
présente dans nos données. Pour ça, on utilise un algorithme d’optimisation qui
minimise les écarts entre la fonction et les données du dataset.
3
Note : Le nom “Apprentissage Supervisé” vient donc du fait que l’on supervise (tel un
professeur) l’apprentissage de la machine en lui fournissant des exemples de question/réponse
à étudier.
Les applications de l’Apprentissage Supervisé sont nombreuses, très nombreuses ! On peut les
diviser en 2 catégories de problèmes : les Régressions, et les Classifications.
Les problèmes de Régression
Les problèmes de Régression correspondent aux situations dans lesquelles la machine doit
prédire la valeur d’une variable quantitative (variable continue)
Exemples de variables :
 le prix d’un appartement

 l’évolution du climat
 le cours de la bourse
 durée de vie d’un patient
Représentation d’un problème de régression
Les problèmes de Classification
Les problèmes de Classification correspondent aux situations dans lesquelles la machine doit
prédire la valeur d’une variable qualitative (variable discrète). Autrement dit, la machine doit
classer ce qu’on lui donne dans des classes.
Exemples de variables :
 Email Spam / non Spam

 Cancer / non Cancer
 Photo de Chat / Chien
4
Représentation d’un problème de classification
Note : La reconnaissance vocale et la vision par ordinateur correspondent à des problèmes de

classification. En effet, la machine apprend à classer les signaux sonores / images qu’elle reçoit
dans différents paquets de mots.
Apprentissage Non-Supervisé : pas de variable y

Une autre méthode d’apprentissage pour développer des programmes de Machine Learning est
l’apprentissage non–Supervisé (Unsupervised Learning). Cette méthode est utilisée quand notre
Dataset ne contient pas d’exemples qui indiquent ce que l’on cherche. Attendez… je vous
explique avec une analogie !
Regardez ces 6 photos. Pouvez-vous les regrouper en 2 familles selon leur ressemblance ?
Bien sûr ! C’est même plutôt simple. Nul besoin de savoir s’il s’agit de cellules animales, de
bactéries ou de protéines pour apprendre à classer ces images. Votre cerveau a en fait reconnu des
structures communes dans les données que vous lui avez montrées.
Dans l’apprentissage non-supervisé, on dispose ainsi d’un Dataset sans variable , et la

machine apprend à reconnaître des structures dans les données qu’on lui montre.
5
On peut ainsi regrouper des donnés dans des clusters (c’est le Clustering), détecter des
anomalies, ou encore réduire la dimension de données très riches en compilant les dimensions
ensembles.
Apprentissage par Renforcement : apprendre dans son

environnement
Une dernière technique très populaire est l’apprentissage par renforcement qui consiste à
laisser la machine apprendre à faire une tâche (par exemple piloter un mini drone) en la laissant
pratiquer seule. Quand la machine réussit ce qu’elle entreprend, elle reçoit un bonus. Quand elle
échoue, elle reçoit un malus.
On développe un programme qui force la machine à vouloir maximiser ses bonus, et la machine
fait alors l’analyse de ses propres erreurs du passé afin de s’améliorer au fil du temps. C’est un
petit peu comme quand nous apprenons à faire du vélo: au début nous n’y arrivons pas du tout,
mais a force d’en faire, nous développons intrinsèquement notre équilibre de façon à éviter les
erreurs du passé qui nous ont fait tomber !
6
Conclusion : Le Machine Learning est la nouvelle électricité,

il va tout révolutionner.
En 2019, le Machine Learning est déjà présent tout autour de nous. En fait, vous l’utilisez
probablement des centaines de fois par jour sans même vous en rendre compte. Chaque fois que
vous effectuez une recherche dans Google, c’est un modèle de Machine Learning qui a appris
comment classer en première page les résultats les plus pertinents parmi des millions de pages
web possibles.
Quand vous postez une photo de vous sur Facebook, il y a un algorithme de Machine Learning
qui parvient à vous identifier parce qu’il a appris à reconnaître des visages sur des photos.
Le machine Learning a déjà commencé à changer la face de notre monde. Il révolutionne

l’industrie des transports avec la voiture autonome et fait fonctionner nos objets connectés :
Iphone, reconnaissance vocale et vision par ordinateur. Il diagnostique le cancer mieux qu’une
équipe de plusieurs docteurs et améliore la sécurité bancaire, la sécurité informatique, prend des
décisions judiciaires plus justes… Même l’industrie agricole et le monde de l’art sont touchés par
le machine Learning.
7
Si vous avez lu tout cet article, cela signifie que vous portez un intérêt important pour le
Machine Learning et je vous en félicite ! N’hésitez pas à me contacter pour toute question, et si
vous désirez vous former au Machine Learning, je vous conseille alors de télécharger mon livre
et de suivre les diverses formations gratuites que j’ai crées (et qui ont déjà convaincu des
milliers de gens à travers le monde)
A bientôt !
Machine Learning : les 9 types d’algorithmes

les plus pertinents en entreprise
Le machine learning devient la priorité de bon nombre
d’entreprises. Elles veulent modéliser d’importants volumes
de données. Le choix du bon algorithme dépend des objectifs
à atteindre et de la maturité de votre équipe de Data Science.
Pour certains, l’affirmation suivante apparaît comme une évidence : un seul algorithme ne pas
répondre à toutes les problématiques. Suivant le type de données et les objectifs de votre
organisation, certains modèles seront plus adaptés. Par exemple, un algorithme de régression
linéaire est plus facile à entraîner et à déployer que d’autres, mais il ne sera sans doute pas le
meilleur pour réaliser des prédictions complexes.
Les neuf algorithmes de machine learning présentés ci-dessous sont parmi les plus utilisés par les
entreprises pour entraîner leurs modèles. Ceux-ci soutiennent non seulement plusieurs objectifs,
mais dépendent également de différentes méthodes d’apprentissage : supervisée, non supervisée,
semi-supervisée ou par renforcement. Au besoin ces techniques peuvent être combinées.
Les algorithmes d’apprentissage supervisé

8
Les modèles d’apprentissage supervisé demandent beaucoup de travail préparatoire aux data
scientists. Les jeux de données en entrée doivent être étiquetés, tandis qu’il faut indiquer les
paramètres de sortie, les résultats attendus. Il faut également ajuster la précision pendant le
processus d’apprentissage.
Régression linéaire
Sans aucun doute possible, les algorithmes de régression linéaire sont les plus utilisés par les
équipes de data science. Il s’agit d’effectuer des corrélations simples entre deux variables dans un
jeu de données. Un ensemble d’entrées et les sorties correspondantes sont examinés et quantifiés
pour montrer une relation, par exemple comment le changement d’une variable affecte une autre.
Les régressions linéaires sont représentées sous forme de lignes sur un graphique.
La popularité de la régression linéaire s’explique par sa simplicité. L’algorithme est facilement

explicable, relativement transparent et il y a peu de paramètres à configurer. Bien connu dans la
pratique des statistiques, ce type d’algorithmes est souvent utilisé pour prévoir des ventes ou des
risques.
La régression linéaire est la meilleure solution lorsque « vous cherchez à prédire votre valeur ou
une classe », déclare Shekhar Vemuri, CTO de Clairvoyant, une société de conseil en analytique.
Machine à vecteurs de support (SVM)
Les machines à vecteurs de support ou SVM (Séparateurs à vastes marges) sont des algorithmes
qui séparent les données en classes. Pendant l’entraînement, un SVM trouve une ligne qui sépare
les données d’un jeu en classes spécifiques et maximise les marges (les distances entre les
frontières de séparation et les échantillons les plus proches) de chaque classe. Après avoir appris
les lignes de classification, le modèle peut ensuite les appliquer aux nouvelles données.
Les spécialistes placent le SVM dans la catégorie des « classificateurs linéaires » : l’algorithme
est idéal pour identifier des classes simples qu’il sépare par des vecteurs nommés hyperplans. Il
est également possible de programmer l’algorithme pour les données non linéaires, que l’on ne
peut pas séparer clairement par des vecteurs. Mais, avec des données d’entraînement
hypercomplexes – visages, traits de personnalité, génomes et matériel génétique – les systèmes de
classes deviennent plus petits et plus difficiles à identifier et nécessitent un peu plus d’assistance
humaine.
Les machines à vecteurs de support sont très utilisées dans la finance. Elles offrent une grande
précision sur les données actuelles et futures. Les modèles associés peuvent servir à comparer
virtuellement les performances financières relatives, la valeur et les retours sur investissement.
Les SVM dits non linéaires sont souvent mis à contribution pour classifier des images (vision par
ordinateur) ou des mots, des phrases et des entités (NLP).
Arbre de décision
9
Un algorithme d’arbre de décision représente graphiquement les données en branches pour

montrer les résultats possibles de diverses actions. Il classifie et prédit les variables de réponse en
fonction des décisions passées.
Cette méthode visuelle a fait ses preuves. Les résultats des arbres de décision sont faciles à
expliquer. Les citizen data scientists n’auront aucun mal à les interpréter. Les décisions et leurs
impacts probables sur un résultat final sont aisément visibles, même lorsque les jeux de données
en entrée s’avèrent incomplets.
Cependant, les arbres de décisions deviennent difficiles à lire quand ils sont associés à de gros
volumes de données et à des variables complexes. C’est pourquoi ils sont utilisés pour les
décisions à faibles enjeux, comme l’anticipation des variations de taux d’emprunt ou les réactions
du marché si une entreprise modifie un élément important d’un de ses produits.
« Les arbres de décision restent populaires parce qu’ils peuvent décrire de multiples résultats sans
faire intervenir de data scientists », déclare Jeff Fried, directeur de la gestion des produits chez
InterSystems.
Choix des
différents types d'algorithmes de Machine Learning en fonction de l'objectif souhaité
Les algorithmes d’apprentissage non supervisé
Les algorithmes dits non supervisés ne sont pas entraînés par le data scientist. Ils dépendent de
méthodes d’apprentissage approfondi pour identifier des patterns en passant au peigne fin des
ensembles de données d’entraînement non étiquetées, puis en observant les corrélations. Les
modèles entraînés avec cette méthode ne sont pas dirigés pour trouver un résultat ou identifier des
données en particulier.
10
Les algorithmes Apriori
Cet algorithme d’exploration de données cherche les affinités entre deux éléments d’un jeu de
données afin d’identifier s’il y a une corrélation négative ou positive entre eux.
L’algorithme Apriori est très utilisé par les équipes commerciales qui cherchent à savoir quels
produits un client va-t-il possiblement acquérir avec un autre. Si un pourcentage élevé de clients
qui achètent du pain achètent aussi du beurre, alors l’algorithme peut conclure que l’achat du
produit A (le pain) sera souvent suivi par celui du produit B (le beurre). Ces données peuvent être
croisées dans des ensembles de données, des points de données et des ratios d’achat.
Un tel algorithme peut également déterminer que l’acquisition d’un élément A n’a de 10 % de
changes de conduire de l’achat d’un produit C. Les équipes de marketing peuvent utiliser ces
informations pour élaborer des stratégies d’agencement de produits dans un magasin, par
exemple. Les algorithmes Apriori sont particulièrement appréciés par les géants du e-commerce
tels qu’Amazon et Alibaba. Les éditeurs de moteur de recherche les utilisent pour prédire la
prochaine requête d’un internaute, tandis que Netflix l’utilise comme un outil de recommandation
du prochain contenu à regarder.
La répartition en K-moyennes (K-means)
L’algorithme K-means s’appuie sur une méthode itérative pour trier des points de données en
groupes basés sur des caractéristiques similaires. Par exemple, un modèle de ce type classifierait
les résultats Web du mot talisman en un groupe relatif à un objet disposant de vertus de
protection et un autre au modèle de voiture produit par le groupe Renault, la berline Renault
Talisman.
La répartition en K-moyennes a la réputation d’être précise, tout en étant capable de gérer des
groupes de données en un laps de temps relativement court. Ce type d’algorithme est aussi bien
utilisé par les éditeurs de moteur de recherche pour proposer des résultats pertinents ou par des
entreprises qui veulent classifier les comportements des utilisateurs. Cette technique s’avère
également efficace dans le contexte d’analyse de performances informatiques.
Les algorithmes d’apprentissage semi-supervisé
Les méthodes d’apprentissage semi-supervisé combinent données étiquetées et non étiquetées.

Les algorithmes de ce type se nourrissent de certaines informations grâce à des catégories
labélisées, des suggestions et des exemples. Ensuite, ils créent leurs propres labels en explorant
les données par eux-mêmes, en suivant un schéma rudimentaire ou les indications de data
scientists.
Réseaux antagonistes génératifs
Les réseaux antagonistes génératifs (generative adverserial networks ou GAN en anglais) sont
des modèles qui imitent la distribution de données. Deux réseaux sont placés en compétition afin
de déterminer la meilleure solution à un problème. Un des réseaux neuronaux, appelé générateur,
11
se nourrit des données d’entrée pour générer une sortie passable, tandis que le second, le
discriminateur, s’appuie sur la sortie du premier pour y repérer les défauts et l’améliorer. Ce
processus est répété autant de fois que nécessaire pour trouver une réponse idéale à un problème.
Dans l’industrie, la fabrication de pièces est l’un des scénarios possibles, même si les
informations en entrée sont limitées.
Un ingénieur indique les dimensions et les paramètres (ses données d’entrée) pour fabriquer la
structure d’une pièce (le résultat) qu’il imprimera ensuite en trois dimensions. Ce procédé permet
d’itérer jusqu’à trouver la forme, la structure ou encore les matériaux idéaux pour la mettre en
production. Dans la production audiovisuelle (notamment dans l’industrie vidéoludique), cette
technique permet de générer des visages, des objets ou des morceaux de musique.
Classificateur bayésien naïf
Le classificateur bayésien naïf (Naive Bayes) s’appuie sur le théorème de Bayes fondé sur les
probabilités conditionnelles. Cet algorithme est utilisé par les chercheurs pour reconnaître des
classes d’objets sur jeux de données étiquetés. Ensuite, l’algorithme est entraîné sur des données
non étiquetées. Une fois ce cycle terminé, les chercheurs associent les étiquettes et relancent
l’entraînement. Cette technique est particulièrement utilisée dans le cadre du traitement du
langage naturel ou pour labéliser des jeux de données sans faire appel à des services comme
Amazon Mechanical Turk. Certains éditeurs, dont TIBCO Software, utilisent la classification
bayésienne naïve au sein de leurs produits (TIBCO Cloud Metadata).
Apprentissage par renforcement
Les algorithmes d’apprentissage par renforcement sont basés sur des systèmes de récompenses et
de punitions. L’algorithme se voit assigner un objectif et cherche à s’en rapprocher pour obtenir
une récompense maximale. Il se base sur des informations limitées et apprend de ses actions
précédentes. Ces algorithmes peuvent dépendre d’un schéma (un modèle) ; ils doivent alors
suivre des étapes prédéfinies et le nombre d’erreurs et d’essais est limité. D’autres ne se reposent
pas sur un schéma et interprètent à chaque nouvel essai.
Q-Learning
Les algorithmes de Q-Learning cherchent à trouver la meilleure méthode (une politique optimale)
pour atteindre un objectif défini en cherchant à obtenir un maximum de récompenses. Ils tentent
le plus grand nombre d’actions possibles par état du système sans avoir de connaissance initiale
de l’environnement. Un algorithme de ce type peut être construit pour obtenir rapidement des
récompenses ou pour atteindre un objectif majeur.
Le Q-Learning est souvent associé à des modèles de Deep Learning dans le cadre de projets de
recherche, dont ceux de Google DeepMind. Cette technique se décline ensuite en divers
algorithmes, dont « deep deterministic policy gradient » (DDPG) ou « hindsight experience
replay » (HER).
12
Algorithme basé sur un modèle (model-based)
À l’inverse du Q-Learning, les algorithmes basés sur un modèle ont une liberté limitée pour créer
des états et des actions. Cela leur apporte néanmoins une efficacité statistique supérieure. Ils sont
formés avec des données spécifiques et des actions de base en provenance de l’environnement via
un entraînement supervisé. Cela permet en principe d’accélérer l’apprentissage. Un tel algorithme
peut servir de référentiel dans le cadre du déploiement d’un jumeau numérique.
Il est possible de combiner cette méthode avec du Q Learning comme l’ont fait les chercheurs de
DeepMind pour créer MuZero.
Apprentissage supervisé : définition et

exemples d'algorithme
13
14
En machine learning, l'apprentissage supervisé consiste à entrainer un modèle à partir de données

préalablement étiquetées ou annotées. Il est utilisé aussi bien en traitement du langage qu'en
vision par ordinateur ou analyse prédictive.
Sommaire
 Apprentissage supervisé : définition

 Applications de l'apprentissage supervisé
 Algorithmes d’apprentissage supervisé
 Apprentissage supervisé vs non supervisé
L’apprentissage supervisé, c'est quoi ?

L’apprentissage supervisé ou supervised learning est une méthode de machine learning
s'appuyant sur des données ou exemples labellisés (étiquetés ou annotés) pour entraîner des
modèles d'intelligence artificielle (IA) prédictifs.
En se basant sur cette base d'apprentissage, par exemple des photos assorties de la mention de ce
qu'elles représentent, les paramètres du modèle s’ajustent en vue ensuite de réagir efficacement face à
des situations similaires. Au fur et à mesure de l'enrichissement du modèle, le résultat gagne en
pertinence, réduisant la marge d’erreur.
Quelles sont les applications de l'apprentissage supervisé ?

Il existe de nombreuses applications de l'apprentissage supervisé :
 le traitement automatique du langage,

 la reconnaissance vocale,
 la vision par ordinateur,
 la bio-informatique…
On utilise également l’apprentissage supervisé pour la détection de spams dans les mails, la
gestion des chatbots et voicebots, ainsi que pour la robotique. Cette méthode permet aussi le
développement des technologies embarquées dédiées aux véhicules autonomes.
Quels sont les algorithmes d’apprentissage supervisé ?

Pour créer un modèle d'apprentissage supervisé, on peut recourir à différents algorithmes :
 la régression linéaire : y = c + b * x ,
 la régression logistique : h(x) = 1 / (1 + e^-x),
 l’arbre de décision avec différentes variables de sortie,
 la machine à vecteur de support (SVM).
15
On peut également évoquer l’algorithme k-NN pour réaliser des tests et la classification naïve
bayésienne pour catégoriser des volumes de données importants.
Quelle différence entre apprentissage supervisé et non

supervisé ?
Aux côtés de l’apprentissage supervisé, il est également possible d’effectuer un apprentissage non
supervisé. Une méthode de machine learning qui n’utilise pas de données d'apprentissage
préalablement annotées ou étiquetées à la différence de l'apprentissage supervisé. Le modèle
découvre alors par lui même la structure et les tendances présentent au sein du data set.
L’apprentissage non supervisé peut servir à partitionner des données (ou data clustering) ou
encore à programmer un système de suggestion, par exemple un moteur de recommandation de
produit tenant compte de clusters d'appétences client. Les fonctions de détection d’anomalies
utilisent généralement la technique de l’apprentissage non supervisé.
 Cours
 Blog
Cours gratuits » Cours informatique » Cours programmation » Cours Python » Tutoriel Python
 Cours
 Blog
Cours gratuits » Cours informatique » Cours programmation » Cours Python » Tutoriel Python
Tuto Python & Scikit-learn : la régression

linéaire
16
Publié le 24 Novembre 2020 par Imane BENHMIDOU
 Tuto Python & Scikit-learn : les arbres de décision

 Tuto Python & Scikit-learn : la régression logistique
 Tuto Python & Scikit-learn : SVM classification et régression
 Tuto Python & Scikit-learn: la classification Naïve Bayésienne
 Tuto Python & Scikit-learn : KNN (k-nearest neighbors)
 Tuto Python & Scikit-learn : réduction de dimensionnalité
 Tuto Python & Scikit-Image : traitement d’images
 Excel : comment tracer une courbe de régression
Support de cours sur la statistique econometrie
Travaux dirigees sur l’hydrologie statistique

17
Best manual to learn the python language and go from beginner to expert
Best course to learn programming using python from A to Z
Programming technique workbook learn to write a python script

18
La statistique regression support de cours
Advanced tutorial to learn how to create python scripts
Manuel sur la statistique regression
Table des matières

19
Introduction
1. Définition
2. Module Scikit-learn
2.1. Régression linéaire simple
2.2. Régression linéaire multiple
3. Cas d’utilisation
4. Avantages et limites
4.1. Avantages
4.2. Limites
5. Exercices
5.1. Exercice 1
5.2. Exercice 2
5.3. Exercice 3
5.4. Exercice 4
6. Solution des exercices
6.1. Exercice 1
6.2. Exercice 2
6.3. Exercice 3
Conclusion
Introduction
La régression linéaire est l’un des principaux modèles à aborder en Machine Learning. À vrai
dire, il n’existe pas qu’un seul type de régression. On distingue la régression de type linéaire mais
aussi la régression logistique. Lors de ce tutoriel, nous n’aborderons que la régression linéaire en
utilisant la bibliothèque d’apprentissage automatique Scikit-learn.
1. Définition
20
Une régression a pour objectif d’expliquer une variable Y par le moyen d’une autre variable X.
Par exemple, le salaire d’une personne peut être expliqué à travers son niveau universitaire ; c’est
à dire le nombre d’années passées à l’université.
La régression linéaire est alors modélisée par l’équation linéaire suivante qui met en relation X et
Y:
Où
 et sont les paramètres du modèle ;

 X est la variable explicative ;
 Y est la variable expliquée ;
 est l’erreur de l’estimation.
Puisqu’on a une seule variable explicative, alors on est dans le cas de la régression linéaire
simple. Par conséquent, la régression linéaire multiple est lorsque vous avez au moins deux
variables explicatives.
Nous aborderons dans ce qui suit les modules fournis par la bibliothèque d’apprentissage
automatique Scikit-learn pour implémenter les fonctions de régression. Dans un premier temps,
nous allons commencer par un exemple de régression linéaire simple ensuite nous allons voir un
exemple de régression linéaire multiple.
La régression linéaire est l’une des techniques les plus utilisées dans l’apprentissage automatique
et cela revient principalement à sa simplicité et la facilité d’interprétation de ses résultats. Comme
on a pris l’habitude d’appliquer le modèle d’apprentissage sur un exemple pour le voir en action,
on va procéder ainsi pour l’algorithme de régression linéaire simple.
Tout d’abord, on importe le package NumPy et la classe LinearRegression. Ensuite, on définit

les données x et y sur lesquelles le modèle va performer et s’exécuter. On fait appel à la
méthode reshape() parce que le tableau x doit être bidimensionnel.
L’étape suivante consiste à créer une instance de la classe LinearRegression et on entraine celle-
ci sur notre ensemble de données à l’aide de la méthode fit().. On calcule ensuite la précision du
modèle à l’aide de la méthode score(). Ainsi, Le résultat obtenu par cette méthode est également
le coefficient de détermination (R²).
Finalement, on fait de la prédiction en appelant la méthode predict() appliquée sur notre modèle.
21
 Code :
import numpy as np
from sklearn.linear_model import LinearRegression
#données
x = np.array([6, 8, 10, 14, 18]).reshape((-1, 1))
y = np.array([7, 9, 13, 17, 18])
#instancier modèle
model_linReg = LinearRegression()
#entrainement du modèle
model_linReg.fit(x, y)
#précision du modèle
precision = model_linReg.score(x, y)
print(precision*100)
#prédiction
prediction = model_linReg.predict(x)
print(prediction)
 Résultat de l’exécution :
2.1.1. Paramètres du modèle LinearRegression
Le modèle LinearRegression peut prendre plusieurs paramètres optionnels, à savoir :
 fit_intercept : prend une valeur booléenne qui calcule l’interception si elle est mise à la
valeur True, sinon elle prend la valeur zéro. Ce paramètre prend True par défaut.
 normalize : prend une valeur booléenne qui normalise les variables d’entrée si elle est mise à
True ou non sinon. Ce paramètre prend False par défaut.
 copy_X : prend une valeur booléenne qui copie les variables d’entrée si True, sinon elle les
écrase. Par défau,t il prend la valeur True.
22
 n_jobs : prend une valeur entière (ou None par défaut) et représente le nombre d’emplois
utilisés dans le calcul parallèle.
2.1.2. Les attributs du modèle LinearRegression
Les attributs du modèle LinearRegression simple sont :
 intercept_ : qui permet de calculer le paramètre .

 coef_ : qui permet de calculer le paramètre 1.
Code :
model_linReg.intercept_
model_linReg.coef_
Résultat de l’exécution :
Remarque :
On peut réaliser la même prévision sans avoir à faire appel à la méthode predict() et cela en
ajoutant à intercept_ appliquée au modèle la multiplication du coef_ appliquée au modèle par x .
La seule différence entre la prévision ci-dessous et la prévision obtenue à l’aide de la

méthode precidt() est que dans la première on a obtenu un tableau bidimensionnel et dans la
deuxième on a un tableau à une seule dimension.
 Code :
prediction = model_linReg.intercept_ + model_linReg.coef_*x

print(prediction)
23
Pour mettre en œuvre la régression linéaire multiple, on suit les mêmes étapes précédemment
citées pour la régression linéaire simple. Tout d’abord, on importe le package NumPy et la
classe LinearRegression.Ensuite, on définit les données x et y sur lesquelles le modèle va
performer.
Pour la régression linéaire multiple, x est bidimensionnel contenant au moins deux colonnes
et y, quand à lui, représente un tableau d’une dimension unique. L’étape qui suit consiste à créer
une instance de la classeLinearRegression et on entraine celle-ci sur notre ensemble de données
à l’aide de la méthode fit().
On calcule la précision du modèle à l’aide de la méthode score(). Le résultat obtenu par cette
méthode est également le coefficient de détermination (R²). Finalement, on réalise une prédiction
en appelant la méthodepredict() appliquée sur notre modèle.
 Code :
import numpy as np
#données
x = np.array([[5, 1], [8, 2], [10, 13], [14, 15], [18, 9]])
y = np.array([7, 9, 13, 17, 18])
#instancier modèle
model_linRegMul = LinearRegression()
model_linRegMul.fit(x, y)
precision = model_linRegMul.score(x, y)
#prédiction
test = np.arange(10).reshape((-1, 2))
prediction = model_linRegMul.predict(test)
print(prediction)
24
2.2.1. Attribut
On applique les attributs du modèle LinearRegression multiple pour notre exemple :
 Code :
model_linRegMul.intercept_
model_linRegMul.coef_
En général, la régression est utilisée pour avoir une idée concernant comment les liaisons de
variables entre elles. Cette méthode est également utile pour faire de la prévision, par exemple on
peut prévoir la consommation d’électricité d’un ménage pour une période compte tenu du nombre
de résidents dans celui-ci, de la température extérieure et de l’heure de la journée.
De nos jours, l’utilisation de la régression augmente de plus en plus vu la disponibilité de grandes

quantités de données et la sensibilisation de l’importance de ces dernières.
25
4.1. Avantages
Comme mentionné précédemment, la régression linéaire est simple à mettre en œuvre et donne
des résultats satisfaisants. Les modèles de régression peuvent être formés facilement et
efficacement. Ils ont aussi une complexité temporelle considérablement faible par rapport à
d’autres modèles d’apprentissage automatique. Cet algorithme performe sur des ensembles de
données séparables linéairement et il est ainsi souvent appliqué pour déterminer la nature de la
relation entre les variables.
4.2. Limites
Lors de l’application des modèles de régression, les valeurs aberrantes peuvent avoir des effets
énormes sur la régression. Il est possible dans certains cas qu’on retrouve des situations de sous-
ajustement (underfitting), et cela lorsque le modèle d’apprentissage automatique ne parvient pas à
saisir les données correctement ce qui est généralement le résultat d’une fonction d’hypothèse
mal adaptée aux données. La régression linéaire suppose alors que les données d’entrée sont
indépendantes l’une de l’autre.
5. Exercices
5.1. Exercice 1
Appliquez la régression linéaire sur la dataset « iris ».
5.2. Exercice 2
Appliquez la régression linéaire sur la dataset « Boston » de scikit-learn. Utilisez le code suivant
pour afficher une description détaillé de la dataset :
 Code :
from sklearn import datasets

données = datasets.load_boston()
print(données.DESCR)
26
5.3. Exercice 3
Générez un problème de régression aléatoire à l’aide de make_regression, et appliquer le modèle

de régression linéaire.
5.4. Exercice 4
Appliquez la régression linéaire sur un ensemble de données généré aléatoirement.

6.1. Exercice 1
Dans cet exercice, on souhaite prévoir la largeur d’un iris. Tout d’abord, on importe le
package pandas et la classe LinearRegression. Ensuite, on définit les variables x et y sur
lesquelles le modèle va performer. L’étape suivante consiste à créer une instance de la
classe LinearRegression et on entraine celle-ci sur notre ensemble de données à l’aide de la
méthode fit().
27
On calcule la précision du modèle à l’aide de la méthode score(). Finalement, on fait de la

prédiction en appelant la méthode predict() appliquée sur notre modèle.
 Code :
import pandas as pd
#données
df = pd.read_csv('C:/Users/LENOVO/Desktop/coursGratuit/iris.csv')
df.head()
x = df[["petal_length"]]
y = df["petal_width"]
#instancier modèle
#prédiction
longueur = 2.5
prediction = model_linReg.predict([[longueur]])
print(prediction)
6.2. Exercice 2
28
Dans cet exercice, on utilise l’ensemble de données concernant les prix de l’immobilier à Boston.
Tout d’abord, on importe le package pandas, linear_model et datasets. Ensuite, on définit les
variables x et y sur lesquelles le modèle va performer. On crée une instance de la
méthode fit().

 Code :
from sklearn import linear_model

import pandas as pd
#charger la dataset Boston
df = pd.DataFrame(données.data, columns = données.feature_names)
df.head()
# données cible dans un nouveau dataframe
cible = pd.DataFrame(data.target, columns = ["MEDV"])
x = df
y = cible["MEDV"]
#instancier modèle
model_linReg = linear_model.LinearRegression()
#training
model_linReg.fit(x,y)
#prédiction
print(prediction[0:5])
29
6.3. Exercice 3
Dans cet exercice, on importe la classe LinearRegression et make_regression. À l’aide de cette

dernière, on va générer un problème de régression aléatoire sur lequel va se baser et s’entraîner
notre modèleLinearRegression qu’on a instancié en premier lieu et en lui applique ensuite la
méthode fit().
On fait la prédiction en appelant la méthode predict() appliquée sur notre modèle. Finalement, on
calcule la précision du modèle à l’aide de la méthode score().
 Code :

from sklearn.datasets import make_regression
#generer problème de regression aléatoire
30
x, y = make_regression( n_features = 3, random_state = 0)

#afficher les cinq premiers éléments de x et y
print('les valeurs de x :', x[0:5])
print('les valeurs de y :', y[0:5])
#instancier modèle
#Prédiction
prediction = model_linReg.predict( [[0,0,0]])
print('la prediction: ', prediction)
Exercice 4 :
Dans cet exercice, on génère aléatoirement des valeurs d’échantillons et de caractéristiques à

l’aide de la méthode randn() sur lesquelles s’entrainera notre modèle de régression linéaire et
cela en lui appliquant la méthode fit(). On fait ensuite la prédiction en appelant la
31
méthode predict() appliquée sur le modèle de régression linéaire. Finalement, on calcule la

précision du modèle à l’aide de la méthode score().
 Code :
import numpy as np
echantillons = 20
caracteristiques = 15
np.random.seed(0)
x = np.random.randn(echantillons, caracteristiques)
y = np.random.randn(echantillons)
#instancier modèle
#Prédiction
print("la prédiction:" ,prediction)
print("la précision du modèle: ", precision*100)
32
Conclusion
Dans ce tutoriel, nous avons défini le modèle de régression linéaire simple et multiple. Ainsi nous
l’avons appliqué sur plusieurs exemples en utilisant les classes fournies par la bibliothèque
d’apprentissage automatique Scikit-learn de Python.
Tutoriel Python
33
 Contactez-nous
 A propos de nous
 On recrute
 Rechercher dans le site
 Politique de confidentialité
 Droit d'auteur/Copyright
 Informatique
 Blog
 Tuto Excel
 Tuto Python
 Tuto Word
 Comptabilité
 Economie
 Marketing
 Management
 Gestion
 Statistiques
 Finance
 Commerce
 Electronique
 Electricité
 Cours OFPPT
Télécharger votre Calendrier
Tuto Python & Scikit-learn : KNN (k-nearest

neighbors)

 Tuto Python & Scikit-learn : la régression linéaire
 Tuto Python & Keras : Les réseaux de neurones
34

35
Learn the basics to program with the python language step by step
Tutorial to learn how to create programs in the Python programming language
General tutorial to learn python and get started with programming

36
Training guide to learn in detail the Python extension and Integration
Support de cours avancé d’Autocad 2010
Table des matières

Introduction
1. Définition
2. Prérequis
3.1. KNN classifier
3.2. KNN regressor
4. Méthodes de calcul de la distance

37
6.1. Avantages
6.2. Limites
7. Exercices
8. Correction
Conclusion
Introduction
L’apprentissage automatique, en anglais le machine learning, est une discipline de l’intelligence
artificielle qui utilise les mathématiques, en particulier les statistiques, afin de permettre aux
ordinateurs la possibilité de résoudre des tâches sans qu’elles soient explicitement programmées.
Il existe plusieurs types d’apprentissages : apprentissage supervisé, apprentissage non supervisé,

apprentissage semi-supervisé, etc. Lors de ce tutoriel, nous allons nous focaliser sur une méthode
d’apprentissage supervisé qui est les k plus proches voisins (en anglais k-nearest neighbors : K-
NN ou KNN).
1. Définition
L’algorithme des k plus proches voisins est tout d’abord une méthode d’apprentissage supervisé.
Qui est utilisé pour la classification, c’est-à-dire pour les données avec des étiquettes discrètes,
ainsi que la régression, c’est-à-dire les données avec des étiquettes continues.
Afin de faire une prédiction, cet algorithme ne construit pas de modèle prédictif comme il est le
cas pour les algorithmes de régression. Cependant, il n’y a pas de phases d’apprentissage
puisqu’il classifie directement des points dont la classe est inconnue en fonction de leurs
distances par rapport à des points appartenant à une classe connue auparavant. Cet algorithme est
ainsi classé dans la catégorie de lazy learning.
L’algorithme KNN agit en deux étapes :
 1ère étape : L’algorithme en premier lieu calcule la distance et stocke les k voisins plus proches
pour chaque échantillon de l’ensemble d’apprentissages.
 2ème étape : Ensuite pour un échantillon sans étiquette l’algorithme récupère les k voisins plus
proches de celui-ci et prédit sa classe par vote.
Exemple :
Afin de simplifier comment fonctionne cet algorithme, prenons l’exemple suivant où on a deux
classes : la classe étoile et la classe triangle. Et on souhaite déterminer la classe du cercle rouge.
38
Le K dans l’algorithme KNN fait référence au nombre des plus proches voisins dont nous
souhaitons prendre des votes. Prenons alors comme exemple K = 3.
Alors on dessine un cercle dont le centre est le cercle rouge et qui contient trois voisins sur le
plan.
Les trois plus proches voisins du cercle rouge sont deux étoiles et un triangle. Ceci dit, le cercle
rouge appartient alors à la classe étoile puisqu’on a deux votes de la classe étoile et un seul vote
de la classe triangle.
39
2. Prérequis
Afin d’appliquer l’algorithme KNN on suppose que l’ensemble de données (dataset) contient peu
de bruit, qu’il est étiqueté et qu’il ne contient que les caractéristiques pertinentes.
L’utilisation de l’algorithme des k plus proches voisins sur de larges ensembles de données n’est
pas recommandée, car il prendra beaucoup plus de temps.
La bibliothèque Scikit-learn de Python destinée à l’apprentissage automatique approvisionne le
module sklearn.neighbors qui contient les méthodes d’apprentissage basées sur les voisins.
Comme spécifié précédemment, l’algorithme KNN est utilisé ainsi pour la classification plutôt
que pour la régression. Ce que nous allons détailler dans ce qui suit.
3.1. KNN classifier
Afin de bien assimiler le fonctionnement de l’algorithme KNN nous allons aboutir à travers
l’exploitation de l’exemple de dataset suivant concernant des fruits :
Le but est la prédiction de l’étiquette d’un fruit.
Tout d’abord nous allons importer les modules numpy, pandas et sklearn (que les éléments dont
on a besoin), ensuite on charge le fichier Excel comprenant les données. Puis on affiche les cinq
premiers enregistrements de l’ensemble des données à l’aide de la fonction head() afin d’avoir
une idée sur la dataset.
 Code :
40
python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
df = pd.read_excel('C:/Users/Beracham/Documents/fruitDataset.xlsx')
df.head()
On ci-après une correspondance entre la valeur de l’étiquette du fruit et son nom dans le but de
faciliter l’interprétation des résultats.
 Code :
python
nom_fruit_cible = dict( zip (df.etiquette_fruit.unique(),
df.nom_fruit.unique()))
print( nom_fruit_cible )
On définit ensuite deux variables x et y représentant respectivement les valeurs de

caractéristiques et la valeur cible. Puis, on utilise la fonction train_test_split pour fractionner
l’ensemble des données en données de train et de test qui sont par défaut à 75/25 %.
 Code :
41
python
x = df [['poids', 'largeur', 'hauteur']]
y = df['etiquette_fruit']
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0)
Maintenant que les données sont fractionnées en train-test, nous allons créer une instance de
l’objet classifier, qui est dans ce cas un classificateur KNN (KNeighborsClassifier).
On définit par la suite le paramètre k qui est le nombre de voisins à une valeur égale à 3 et qui
sera utilisé par le classificateur.
On entraine le classificateur à l’aide de la méthode fit() qu’on lui passe en

paramètres x_train et y_train.
 Code :
python
from sklearn.neighbors import KNeighborsClassifier
#instanciation et définition du k
knn = KNeighborsClassifier(n_neighbors = 3)
#training
knn.fit(x_train,y_train)
Pour le moment le classificateur KNN n’a pas utilisé aucune donnée de test, alors on va utiliser la
méthode score() qui prend en paramètre ces valeurs de test précédemment défini et en calcule la
précision de l’algorithme. Celle-ci est définie comme la fraction des éléments de l’ensemble de
tests dont le véritable label a été correctement prédit.
 Code :
42
python
knn.score(x_test,y_test)
Alors dans les deux applications suivantes on va entrer le poids, la largeur et la hauteur d’un fruit
et on demande au classificateur de prédire le nom du fruit en utilisant la méthode de
prédiction predict().
 Code :
python
prediction_fruit = knn.predict([[20,4.3,5.5]])
nom_fruit_cible[prediction_fruit[0]]
 Code :
python
prediction_fruit = knn.predict([[180,8.0,6.8]])
target_fruits_name[prediction_fruit[0]]
3.2. KNN regressor
Nous appliquerons cet algorithme sur la même dataset de fruit utilisé pour le KNN classifier.
Nous allons procéder comme précédemment en important les modules nécessaires, puis on
charge la dataset en dataframe avec pandas. Ensuite, on crée les correspondances entre la valeur
43
de l’étiquette d’un fruit et le nom de celui-ci. Après, nous définissons deux variables, l’une pour
les valeurs de caractéristiques et l’autre pour la valeur cible. Pour ensuite fractionner l’ensemble
des données en des données de train et de test.
 Code :
python
import numpy as np
import pandas as pd
#charger dataframe
df = pd.read_excel('C:/Users/LENOVO/Desktop/coursGratuit/fruitDataset.xlsx')
df.head()
#mappint etiquette et nom
#valeurs des caractéristiques
#valeur cible
#fractionner dataset (train-test)
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0)
Maintenant que les données sont fractionnées en train-test, nous allons créer une instance de
l’objet regressor, qui est dans ce cas un classificateur KNN (KNeighborsRegressor).
On entraine le KNeighborsRegressor à l’aide de la méthode fit() qu’on lui passe en

44
 Code :
python
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 3)
knnr.fit(x_train, y_train)
Pour le moment le KNN régression n’a pas utilisé aucune donnée de test, alors on va faire appel
la méthode score() qui prend en paramètre ces valeurs de test précédemment défini et en calcule
la précision de l’algorithme. Qui est définie comme la fraction des éléments de l’ensemble de test
dont le véritable label a été correctement prédit.
 Code :
python
knnr.score(x_test, y_test)
Dans l’application suivante, on va entrer le poids, la largeur et la hauteur d’un fruit et on

demande au regressor de prédire le nom du fruit en utilisant la méthode de prédiction predict().
 Code :
python
prediction_fruit = knnr.predict([[20,4.3,5.5]])
45
4. Méthodes de calcul de la distance

Pour le KNN de classification ainsi que de régression, ils ont un paramètre appelé metric qui
désigne la méthode de calcul de la distance et qui prend par défaut la valeur ‘minkowski’.
Le tableau suivant regroupe les différentes métriques possibles destinées aux espaces vectoriels à
valeurs réelles :
MÉTRIQUE ARGUMENT DISTANCE

euclidean sqrt(sum((x - y)^2))
manhattan sum(|x - y|)
chebyshev max(|x - y|)

minkowski p sum(|x - y|^p)^(1/p)
wminkowski p, w sum(|w * (x - y)|^p)^(1/p)
seuclidean V sqrt(sum((x - y)^2 / V))
mahalanobis V sqrt((x - y)' V^-1 (x - y))
L’algorithme KNN peut être utilisé pour les exemples de cas suivants :
 La prédiction des prix des actions.

 Les systèmes de recommandation.
 L’analyse du risque de crédit.
 Planification prévisionnelle des voyages.
6.1. Avantages
L’algorithme KNN est facile à comprendre et à interpréter. Il est utile pour les données non
linéaires et est considéré comme un algorithme polyvalent puisqu’il est utile pour la classification
et la régression.
6.2. Limites
46
Puisque le KNN ne nécessite pas un modèle pour faire une prévision, en revanche, il doit garder
en mémoire toutes les observations afin de réaliser sa prévision. Alors pour les grandes tailles de
jeu de données ceci entrainera un temps beaucoup plus large.
Ainsi, le choix de la métrique (méthode de calcul de la distance) et e nombre voisins K n’est pas
quelque chose d’évidente. Il faut tester plusieurs combinaisons pour avoir un résultat satisfaisant.
7. Exercices
Exercice 1 :
Appliquez l’algorithme des k (k = 3) plus proches voisins (classifier) sur la dataset iris. Et
calculez la précision de celui-ci.
Notez qu’on veut fractionner la dataset comme suivant : 80% pour les valeurs de training et 20%
pour le test.
Exercice 2 :
Appliquez l’algorithme des k (k = 3) plus proches voisins (regressor) sur la dataset iris en
utilisant la métrique « euclidean ». Et calculez la précision de celui-ci.
8. Correction
Exercice 1 :
Aperçu de la dataset :
 Code :
python
df.head()
47
Nous allons importer tout d’abord les modules nécessaires (pandas et KNeighborsClassifier),
puis on charge la dataset en dataframe avec pandas. Ensuite, nous définissons deux variables,
l’une pour les valeurs de caractéristiques (longueur et largeur) et l’autre pour la valeur cible
(espèce de l’iris). Pour ensuite fractionner l’ensemble des données en des données de train et de
test.
Puis nous allons créer une instance de l’objet classifier, qui est dans ce cas un classificateur KNN
(KNeighborsClassifier).
On entraine le KNeighborsClassifier à l’aide de la méthode fit() qu’on lui passe en

Puis on va entrer la longueur et la largeur d’un iris et on demande au classifier de prédire son
espèce (sachant la dataset contient trois types : 0 pour setosa, 1 pour versicolor et 2 pour
virginica) en utilisant la méthode de prédiction predict().
Et on calcul finalement la précision à l’aide de la méthode score().
 Code :
python
import pandas as pd
from sklearn.neighbors import KNeighborsClassifier
#traitement du fichier csv
a = df.loc[:,"petal_length"]
b = df.loc[:,"petal_width"]
x = list(zip(a, b))
y = df.loc[:,"species"]
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.20)
knn = KNeighborsClassifier(n_neighbors = 3)
48
#training
knn.fit(x_train, y_train)
#Prédiction
longueur = 2.5
largeur = 0.75
prediction = knn.predict([[longueur, largeur]])
#calcule de précision
print(knn.score(x_test, y_test))
#affichage des résultats
resultat = "Résultat : "
if prediction[0] == 0:
resultat = resultat + "setosa"
resultat = resultat + "versicolor"
resultat = resultat + "virginica"
print(txt)
49
Exercice 2 :
On reproduit les mêmes lignes code de l’exercice précédent, mais en faisant appel
à KNeighborsRegressor et en spécifiant dans ces paramètres la métrique « euclidean ».
 Code :
python
import pandas as pd
from sklearn.neighbors import KNeighborsRegressor
df.head()
x = list(zip(a, b))
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.20)
knnr = KNeighborsRegressor (n_neighbors = 3, metric = 'euclidean')
#training
knnr.fit(x_train, y_train)
#Prédiction
longueur = 2.5
largeur = 0.75
prediction = knnr.predict([[longueur, largeur]])
print(knnr.score(x_>Q, y_test))
print(txt)
50
Conclusion
Lors de ce tutoriel, nous avons défini l’algorithme KNN, son principe et ses cas d’utilisation.
Nous avons également vu réagir cet algorithme sur un ensemble de données pour les deux cas
d’utilisation du KNN à savoir le cas de classification et de régression. Et finalement on a cité
quelques avantages ainsi que limites pour cet algorithme.
51

logistique

52
Cours Marketing et logistique
Modèle de tableau de bord logistique sur Excel
Cours complet sur la statistique regression

53

54
Table des matières
Introduction
1. Définition
2. Régression linéaire Vs. Régression Logistique
4. Attributs de la régression logistique
6.1. Avantages
6.2. Limites
7. Exercices
7.1. Exercice 1
7.2. Exercice 2
8.1. Exercice 1
8.2. Exercice 2
55
Conclusion
Introduction
Dans le présent tutoriel, nous allons voir le deuxième type de régression, qui est la régression
logistique, en utilisant la bibliothèque d’apprentissage automatique Scikit-learn.
L’algorithme de régression logistique est un algorithme de classification plutôt que de régression,

il se base sur un ensemble de données indépendantes et il est ainsi utilisé pour estimer une valeur
discrète.
1. Définition
L’algorithme de régression logistique mesure la relation entre la variable dépendante catégorielle
et une ou plusieurs variables indépendantes en donnant une estimation à la probabilité
d’occurrence d’un événement à travers l’usage de sa fonction logistique.
Il existe plusieurs types de régression logistique, à savoir :
 Régression logistique binaire : la variable cible n’a que deux résultats possibles, comme par
exemple « cancer » ou « pas de cancer ».
 Régression logistique multinomiale : la variable cible a trois catégories nominales ou plus,
comme par exemple la prédiction du type d’un iris.
 Régression logistique ordinale : la variable cible a trois catégories ordinales ou plus, comme la
notation des produits de 1 à 5.
2. Régression linéaire Vs. Régression Logistique

Comme nous l’avons vu dans le tutoriel précédent, la régression linéaire donne un résultat
continu. La régression logistique quant à elle, donne un résultat constant.
Prenons l’exemple des prix des maisons et des actions dans la bourse, ce sont alors des exemples
de production continue. Par contre, la prédiction qu’un patient qui souffre d’un cancer ou non est
un exemple de sortie discrète. Nous identifions également l’exemple de la prédiction du taux de
désabonnement de client.
Cependant, la régression linéaire est estimée en utilisant la méthode des moindres carrés ordinaire
(MOC), tandis que la régression logistique est estimée en utilisant l’approche de l’estimateur au
maximum de vraisemblance (EMV).
La bibliothèque d’apprentissage automatique Scikit-learn fournit pour la régression logistique le
module sklearn.linear_model.LogisticRegression.
56
LogisticRegression peut prendre plusieurs paramètres dont :
- random_state : représente la graine du nombre pseudo-aléatoire généré. Ce dernier est utilisé

lors de la réorganisation de données. Il peut prendre trois options, notamment :
 int : random_state dans ce cas est la graine utilisée par le générateur de nombres aléatoires.
 RandomState instance : random_state dans ce cas est le générateur de nombres aléatoires.
 None : le générateur de nombres aléatoires est l’instance RandomState qui est utilisée
par np.random.
Par défaut ce paramètre prend None.
- solver : ce paramètre représente l’algorithme à utiliser pour le problème d’optimisation. Il peut

prendre l’une des options suivantes :
 linlinear : le meilleur choix pour les petits ensembles de données. Il gère la pénalité L1.
 newton-cg : gère que la pénalité L2.
 lbfgs : gère la perte multinomiale pour les problèmes multi classes. Il ne gère également que la
pénalité L2.
 saga : représente un bon choix pour les grands ensembles de données. Pour les problèmes multi
classes, il gère les pertes multinomiales. Il prend en charge la pénalité L1 et la pénalité
« elasticnet».
 sag : cette option est aussi idéale pour les grands ensembles de données et gère la perte
multinomiale pour les problèmes multi classes.
Par défaut ce paramètre prend linlinear.
- multi_class : ce paramètre présente les options suivantes :
 ovr : si cette option est choisie, donc un problème binaire est adapté à chaque étiquette.
 multin : si cette option est choisie, alors la perte minimisée est l’ajustement de la perte
multinomiale sur l’ensemble de la distribution de probabilité. Cette option ne marche pas avec le
solveur « lbfgs».
Par défaut ce paramètre prend ovr.
4. Attributs de la régression logistique

Les attributs du LogisticRegression sont les suivants :
- coef_ : renvoi le coefficient des caractéristiques de la fonction de décision.
- intercept_ : représente la constante ajoutée à la fonction de décision.
- n_iter_ : renvoi le nombre réel d’itérations pour chaque classe.

57
Afin de bien assimiler le fonctionnement du modèle de régression logistique, nous allons

exploiter le data-set suivant qui concerne les fruits. Où le but est de prédire l’étiquette d’un fruit.
Tout d’abord, nous allons importer les modules numpy, pandas et sklearn (uniquement les
éléments dont on a besoin), ensuite on charge le fichier Excel comprenant les données. Puis, on
affiche les cinq premiers enregistrements de l’ensemble des données à l’aide de la
fonction head() afin d’avoir une idée sur la dataset.
 Code :
python
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_spli
df = pd.read_excel('C:/Users/LENOVO/Desktop/coursGratuit/fruitDataset.xlsx')
df.head()
58
On crée ci-contre une correspondance entre la valeur de l’étiquette du fruit et son nom dans le but
de faciliter l’interprétation des résultats. Puis, on définit deux variables x et y représentant
respectivement des valeurs caractéristiques et la valeur cible. Ensuite, on utilise la
fonction train_test_split pour fractionner l’ensemble de données en données d’entrainement et de
test suivant le pourcentage par défaut 75/25%.
On crée par la suite une instance de l’objet LogisticRegression, qu’on lui passe en
paramètres random_state, solver et multi_class.
Finalement, on entraine cette instance en utilisant la méthode fit() qu’on lui passe en
paramètre x_train et y_train. Puis, en faisant appel à la méthode score() on calcule la précision
du modèle.
 Code :
python
#valeurs caractéristiques et valeur cible
#fractionner dataset
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 0)
#instanciation du modèle
modele_regLog = linear_model.LogisticRegression(random_state = 0,
solver = 'liblinear', multi_class = 'auto')
#training
modele_regLog.fit(x_train,y_train)
precision = modele_regLog.score(x_test,y_test)
59
On donne au modèle de régression logistique le poids, la largeur et la hauteur d’un fruit et on lui
demande de classifier ce fruit en utilisant la méthode de prédiction predict().
 Code :
python
#prédiction
prediction_fruit = modele_regLog.predict([[180,8.0,6.8]])
#prédiction
prediction_fruit = modele_regLog.predict([[20,4.3,5.5]])
60
La régression logistique peut être mise en œuvre pour des compagnes de ciblage marketing. Le
but ainsi est d’attirer de nouveaux clients. Alors, la construction d’un modèle de régression
logistique permettra d’expliquer et de prédire les clients susceptibles d’acheter le produit ou le
service offert par l'entreprise.
À titre d’exemple, Booking.com utilise plusieurs algorithmes d’apprentissage automatique sur

tout son site. Ces algorithmes essayent de prédire les intentions des utilisateurs. Et vu que dans la
plupart des cas les données sont plutôt catégoriques que numériques tel que la distinction sur la
base du lieu d’origine de l’utilisateur et l’endroit où il veut se rendre. La régression logistique est
alors idéale pour prévoir un événement sans avoir des données spécifiques concernant
l’utilisateur.
En plus de ces deux exemples, le modèle de régression logistique est utilisé dans le domaine
médical, dans le text editing et dans le gaming.
6.1. Avantages
La régression logistique est un algorithme de classification simple et efficace, alors il ne nécessite

pas une grande puissance de calcul et il est facile à mettre en œuvre. Ce modèle d’apprentissage
est largement utilisé par les analystes de données et les scientifiques et il ne nécessite pas de mise
à l’échelle des fonctionnalités.
Enfin, la régression logistique fournit un score de probabilité pour les observations.
6.2. 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.
7. Exercices
7.1. Exercice 1
Appliquez le modèle de régression logistique sur la dataset “iris“.
7.2. Exercice 2
61
Appliquez le modèle de régression logistique sur la dataset “pima“ qui a pour objectif de prévoir
si un patient est diabétique ou non. Vous pouvez télécharger cette dataset depuis
Kaggle :https://www.kaggle.com/uciml/pima-indians-diabetes-database

8.1. Exercice 1
Tout d’abord, nous allons importer les modules numpy, pandas et sklearn (uniquement les
éléments dont on a besoin), ensuite on charge le fichier Excel comprenant les données. Puis on
affiche les cinq premiers enregistrements de l’ensemble des données à l’aide de la
fonction head() afin d’avoir une idée sur la dataset.
Puis on définit deux variables x et y représentant respectivement des valeurs caractéristiques et la

valeur cible. Ensuite, on utilise la fonction train_test_split pour fractionner l’ensemble de
données en données d’entrainement et de test suivant le pourcentage 80/20%.
On crée par la suite une instance de l’objet LogisticRegression, qu’on lui passe en
paramètres random_state, solver et multi_class.
On entraine cette instance en utilisant la méthode fit() qu’on lui passe en

paramètre x_train et y_train. Puis, en faisant appel à la méthode score() on calcule la précision
du modèle.
Finalement, pour prédire le type d’un iris, on donne au modèle la longueur et la largeur de celui-
ci et on lui applique la méthode predict().
 Code :
python
import numpy as np
import pandas as pd
df.head()
x = list(zip(a, b))
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.20)
modele_regLog = linear_model.LogisticRegression(random_state = 0,
solver = 'liblinear', multi_class = 'auto')
#training
modele_regLog.fit(x_train, y_train)
62
precision = modele_regLog.score(x_test, y_test)
print(precision * 100)
#Prédiction
longueur = 2.5
largeur = 0.75
prediction = modele_regLog.predict([[longueur, largeur]])
print(resultat)
63
8.2. Exercice 2
Dans cet exercice, nous avons tout d’abord importé les

modules numpy, pandas et sklearn (uniquement les éléments dont on a besoin). Ensuite, on
charge le fichier CSV comprenant les données. Puis on affiche les cinq premiers enregistrements
de l’ensemble des données à l’aide de la fonction head() afin d’avoir une idée sur la dataset. On a
aussi donné de nouveaux noms aux colonnes du fichier en ajoutant aux paramètres
deread_csv, names. Finalement, on a supprimé la première ligne qui contenait les anciens noms à
l’aide de drop().
Code :
64
python
import numpy as np
import pandas as pd
nom_colonne = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi',
'pedigree', 'age', 'label']
df = pd.read_csv('C:/Users/LENOVO/Desktop/coursGratuit/diabetes.csv',
header = None, names = nom_colonne)
df = df.drop([0])
df.head()
On
définit deux variables x et y représentant respectivement des valeurs caractéristiques et la valeur
cible. Ensuite, on utilise la fonction train_test_split pour fractionner l’ensemble de données en
données d’entrainement et de test suivant le pourcentage par défaut 75/25%.
On crée par la suite une instance de l’objet LogisticRegression. On entraine cette instance en
utilisant la méthode fit() qu’on lui passe en paramètre x_train et y_train. Pour prédire si une
personne est diabétique ou non on donne au modèle les valeurs de test et on lui applique la
méthode predict().
Puis, en faisant appel à la méthode score() on calcule la précision du modèle.
 Code :
python
65
caracteristique = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp',

'pedigree']
x = df[caracteristique]
y = df.label
x_train, x_test, y_train, y_test = train_test_split(x, y,
test_size = 0.25, random_state = 0)
modele_regLog = linear_model.LogisticRegression()
#training
modele_regLog.fit(x_train, y_train)
#prediction
prediction = modele_regLog.predict(x_test)
print('prédiction du modèle:', prediction)
precision = modele_regLog.score(x_test, prediction)
print('la précision du modèle', precision * 100)
66
Conclusion
La régression logistique est l’un des modèles classiques d’apprentissage automatique. Elle est
considérée des bases de la machine learning. La simplicité de ce modèle lui a permis cette
réputation auprès des scientifiques ainsi que les personnes souhaitant s’initier au monde de
l’apprentissage automatique.
Pour conclure, lors de ce tutoriel nous avons défini le modèle de régression logistique et sa
différence de la régression linéaire. Ensuite, on a vu la classe fournie par scikit-learn pour ce type
de régression et qu’on a appliquée sur un exemple de dataset. Finalement, nous avons vu
différents cas d’utilisations réelles de cet algorithme, ses avantages, ainsi que ses limites.
Tuto Python & Scikit-learn : SVM

classification et régression

67
Cours complet sur la statistique regression

68
Modèle de plan de classification des documents sur Excel

69
Support de cours avancé d’Autocad 2010
Table des matières
Introduction
1. Principede fonctionnement
2.1. SVM classification
2.2. SVM régression
70
4.1. Avantages
4.2. Limites
Conclusion
Introduction
Les machines à vecteurs de support (ou Support Vector Machine, SVM) sont une famille
d’algorithmes d’apprentissage automatique de type supervisé et qui peuvent être utilisées pour
des problèmes de discrimination (à quelle classe appartient un échantillon), de régression et de
détection d’anomalies.
Lors de ce tutoriel nous nous intéresserons aux différents SVM de classification ainsi que de
régression mise en place par la bibliothèque d’apprentissage automatique Scikit-learn de Python.
1. Principe de fonctionnement
Les SVM sont une généralisation des classifieurs linéaires (algorithmes de classement
statistique) dont le principe est de séparer les données en classe à l’aide d’une frontière, de telle
façon que la distance entre les différents groupes de données et la frontière séparatrice soit
maximale. Cette distance est appelée marge. Et les données les plus proches de la frontière sont
appelées vecteurs de support.
Dans le schéma suivant, la frontière est la droite en rouge, les vecteurs de support sont les
éléments les plus proches de la frontière entourés en vert. Finalement, la marge est la distance
entre la droite en rouge et les deux droites en noire et en jaune.
71
2.1. SVM classification
Pour la classification, la bibliothèque scikit-learn de Python met en place trois

classes : SVC, NuSVC et LinearSVC.
Afin de démontrer le fonctionnement de ces trois algorithmes (SVC, NuSVC et LinearSVC) nous
allons procéder à travers l’exploitation de l’exemple de dataset « iris » et qui concerne les trois
espèces de l’iris représentées comme suivant : 0 pour setosa, 1 pour versicolor et 2 pour virginica.
Tout d’abord, nous allons importer le module pandas qui nous permettra de lire le fichier csv, on
importe aussi train_test_split qui nous permettra de fractionner le dataset en données de training
et de test.
Ensuite, on charge le fichier CSV comprenant les données. Et on définit une variable x qui va
contenir les données de caractéristique et une autre variable y pour les valeurs cibles qui sont les
étiquettes de classe pour les échantillons d’entrainement.
A l’aide de la fonction head(), on affiche les cinq premières lignes de la dataset pour avoir une
idée sur celle-ci.
 Code :
python
import pandas as pd
df = pd.read_csv( 'C:/Users/LENOVO/Desktop/coursGratuit/iris.csv')
a = df.loc[:, "petal_length"]
b = df.loc[:, "petal_width"]
x = list(zip(a, b))
y = df.loc[:, "species"]
df.head()
72
2.1.1. SVC
Le SVC est un modèle de classification dont l’implémentation est basée sur libsvm.
Dans le code suivant on a tout d’abord importé la classe SVC puis on a fractionné notre dataset à
l’aide de train_test_split qu’on a précédemment importé.
Puis nous avons créé une instance model_SVC de l’objet SVC. On entraine celle-ci à l’aide de la
méthode fit() qu’on lui passe en paramètres x_train et y_train.
L’objet SVC peut prendre plusieurs paramètres optionnels. Dans ce qui suit, on n’utilise que les
trois paramètres optionnels suivants :
- Kernel : spécifie le type de noyau à utiliser dans l’algorithme, et qui peut être soit « linear »,
« poly », « rbf », « sigmoid » ou « precomputed », par défaut il prend la valeur « rbf ».
- Gamma : correspond au coefficient de noyau pour les noyaux « rbf », « poly », et « sigmoid ».
Prend comme valeur soit « scale », « auto » ou un nombre à virgule.
- shrinking : désigne une valeur booléenne, True si on veut utiliser l’heuristique

rétrécissante, False sinon.
En faisant appel à la méthode score() on calcule la précision de ce modèle.
Puis finalement, on fait entrer la longueur et la largeur d’un iris et on demande au SVC de prédire
son espèce en utilisant la méthode de predict().
 Code :
73
python
from sklearn.svm import SVC
#instanciation
model_SVC = SVC( kernel = 'linear', gamma = 'scale', shrinking = False,)
#training
model_SVC.fit( x_train, y_train)
print( model_SVC.score( x_test, y_test))
#Prédiction
longueur = 2.5
largeur = 0.75
prediction = model_SVC.predict( [[longueur, largeur]])
print( resultat)
74
Attributs
Le tableau suivant regroupe les attributs pouvant être utilisé par la classe sklearn.svm.SVC :
ATTRIBUTS DESCRIPTIONS
support_ Renvoie les indices des vecteurs de support.
support_vectors_ Renvoie les vecteurs de support.
n_support_ Représente le nombre de vecteurs de support pour chaque classe.
dual_coef_ Les coefficients des vecteurs de support dans la fonction de décision.
Renvoie le poids attribué aux caractéristiques.
coef_
Cet attribut n’est disponible que dans le cas d’un noyau linéaire.
intercept_ Représente le terme constant dans la fonction de décision.
fit_status_ Renvoie 0 si la sortie est correctement ajustée et 1 si elle est mal ajustée.
classes_ Renvoie les étiquettes des classes.
On applique ces attributs au modèle précédent :
 Code :
75
python
model_SVC.fit_status_
model_SVC.coef_
model_SVC.support_
model_SVC.n_support_
 Code :
python
model_SVC.support_vectors_
76
 Code :
python
model_SVC.classes_
 Code :
python
model_SVC.intercept_
77
2.1.2. NuSVC
NuSVC est l’acronyme de Nu Support Vector Classification. C’est une classe fournie par la
bibliothèque Scikit-learn et qui permet de faire la classification multi-classes.
Le NuSVC ressemble au SVC avec une légère différence dans les paramètres.
Le NuSVC accepte un paramètre nu qui prend une valeur à virgule dans l’intervalle (0, 1] par
défaut égale à 0.5 et qui représente une limite supérieure de la fraction des erreurs de training et
une limite inférieure de la fraction des vecteurs de support.
Appliquons celui-ci sur la dataset « iris ».
On suit les mêmes étapes que précédemment, et on fait appel cette fois-ci à la classe NuSVC.
 Code :
python
from sklearn.svm import NuSVC
#instanciation
model_NuSVC = NuSVC( kernel = 'linear', gamma = 'scale', shrinking = False,)
#training
model_NuSVC.fit( x_train, y_train)
print(model_NuSVC.score( x_test, y_test))
#Prédiction
longueur = 2.5
largeur = 0.75
prediction = model_NuSVC.predict( [[longueur, largeur]])
print(resultat)
78
Remarque :
Les mêmes attributs du SVC sont valables pour le NuSVC.
2.1.3. LinearSVC
Le linearSVC est similaire à un certain degré au SVC dont le noyau est linéaire (kernel =
‘linear’). La différence entre ces deux est que le linearSVC est implémenté
en liblinear, le SVC, quant à lui, est implémenté enlibsvm.
Le linearSVC est plus adapté au grand nombre d’échantillons. Pour ces paramètres, il n’accepte
pas le paramètre kernel car implicitement il est considéré comme étant linéaire. Il accepte en
revanche les deux paramètres optionnels suivants :
- Penalty : spécifie la norme utilisée dans la pénalisation. Et qui est soit l1 soit l2.
- Loss : représente la fonction de perte.
Remarque :
Le linearSVC n’accepte pas les attributs

suivants : support_, support_vectors_, n_support_, fit_status_ et dual_coef_.
Appliquons ce modèle à la dataset « iris ».

79
 Code :
python
from sklearn.svm import LinearSVC
#instanciation
model_linearSVC = LinearSVC( dual = False, random_state = 0, penalty = 'l1', tol
= 1e-3)
#training
model_linearSVC.fit( x_train, y_train)
print(model_linearSVC.score( x_test, y_test))
#Prédiction
longueur = 2.5
largeur = 0.75
prediction = model_linearSVC.predict( [[longueur, largeur]])
print(resultat)
80
On affiche ci-dessous le poids attribué aux caractéristiques à l’aide de l’attribut coef_. Et les
valeurs constantes dans la fonction de décision en utilisant intercept_.
 Code :
python
model_linearSVC.coef_
model_linearSVC.intercept_
2.2. SVM régression
Pour la régression la bibliothèque scikit-learn de Python met en place principalement les trois
classes suivantes : SVR, NuSVR et LinearSVR.
2.2.1. SVR
Le SVR (Support Vector Regression) est une régression vectorielle de type Epsilon-support et est
implémenté au niveau de libsvm.
SVR peut prendre le paramètre optionnel epsilon qui spécifie le tube epsilon dans lequel aucune
pénalité dans la fonction de perte de training n’est associée aux points prédits à une distance
epsilon de la valeur réelle. Ce paramètre prend par défaut la valeur 0.1.
Les autres paramètres et attributs sont similaires à ceux utilisés dans le SVC.
Exemple :
Prenons l’exemple suivant d’application du modèle SVR.
 Code :
python
from sklearn.svm import SVR
x = [[12, 12], [20,20]]
y = [1, 2]
81
#instanciation
model_SVR = SVR( kernel = 'linear' , gamma = 'auto')
#training
model_SVR.fit( x, y)
#Prédiction
model_SVR.predict( [[20,20]])
Attributs
Les mêmes attributs du SVC peuvent être utilisés par le SVR.
Ci-dessous on les applique sur le modèle de l’exemple précédent.
 Code :
python
model_SVR.support_
model_SVR.support_vectors_
model_SVR.n_support_
model_SVR.dual_coef_
model_SVR.coef_
model_SVR.intercept_
model_SVR.fit_status_
82
2.2.2. NuSVR
Le NuSVR est la régression vectorielle de support Nu, ce modèle est similaire au NuSVC sauf
que le NuSVR utilise le paramètre nu pour contrôler le nombre de vecteurs de support ainsi ce
dernier remplace epsilon.
Exemple :
Dans cet exemple, on génère aléatoirement des valeurs d’échantillons et de caractéristiques à

l’aide de la méthode randn() sur lesquelles s’entraine notre modèle NuSVR.
 Code :
python
from sklearn.svm import NuSVR
import numpy as np
echantillons = 20
np.random.seed(0)
x = np.random.randn( echantillons, caracteristiques)
y = np.random.randn( echantillons)
#instanciation
83
model_NuSVR = NuSVR( kernel = 'linear', gamma = 'auto', C = 1.0, nu = 0.1)

#training
model_NuSVR.fit(x, y)
#Prédiction
model_SVR.predict( [[20,20]])
2.2.3. LinearSVR
LinearSVR est la régression vectorielle de support linéaire et est similaire au SVR quand le
noyau est linéaire (kernel = ‘linear’). La différence entre ces deux est que le linearSVR est
implémenté en liblinear, le SVRquant à lui est implémenté en libsvm.
Le linearSVCR est plus adapté au grand nombre d’échantillons. Pour ces paramètres, il n’accepte
pas le paramètre kernel car implicitement il est considéré linéaire. Il accepte en revanche le
paramètre optionnel :Loss qui représente la fonction de perte et prend par défaut
« epsilon_insensitive ».
Remarque :
Le linearSVC n’accepte pas les attributs

suivants : support_, support_vectors_, n_support_, fit_status_ et dual_coef_.
Exemple :
Dans cet exemple on importe la classe make_regression qui permet de générer un problème de
régression aléatoire, sur lequel va se former notre modèle linearSVR en lui appliquant la
méthode fit().
84
 Code :
python
from sklearn.svm import LinearSVR
#instanciation
model_linearSVR = LinearSVR( dual = False, random_state = 0,
loss = 'squared_epsilon_insensitive', tol = 1e-5)
#training
model_linearSVR.fit( x, y)
#Prédiction
model_linearSVR.predict( [[0,0,0]])
On affiche ci-dessous le poids attribué aux caractéristiques à l’aide de l’attribut coef_. Et la

valeur constante dans la fonction de décision en utilisant intercept_.
 Code :
python
model_linearSVR.coef_
model_linearSVR.intercept_
85
Voici quelques exemples d’utilisation du modèle SVM :
Reconnaissances des formes :
 Reconnaissance de chiffres manuscrits.

 Reconnaissance de visages.
Diagnostic médical :
 Evaluation des risques de cancer.

 Détection d’arythmie cardiaque.
4.1. Avantages
Les classificateurs SVM sont d’une précision élevée et effectuent des prédictions plus rapides que
d’autres modèles. Ils utilisent aussi moins de mémoire car ils utilisent un sous-ensemble de points
d’entrainement dans la phase de décision.
4.2. Limites
Les SVM ne sont pas adaptés aux grands ensembles de données puisqu’ils prennent un temps de
formations plus élevé. Et ils fonctionnent mal avec les classes qui se chevauchent et dépendent du
noyau utilisé.
Conclusion
Dans ce tutoriel nous avons vu le SVM qui fait partie de la famille des algorithmes
d’apprentissage automatique supervisés et qui permet à la fois la classification en utilisant SVC,
NuSVC et linearSVC et la régression en utilisant SVR, NuSVR et linearSVR dans la bibliothèque
scikit-learn de Python.
Tuto Python & Scikit-learn: la classification

Naïve Bayésienne
86
Publié le 21 Novembre 2020 par IBN ALKADI IMAN

Modèle de plan de classification des documents sur Excel
La statistique bayesienne formation generale

87
Cours d’introduction a la statistique bayesienne

88
Cours sur les bases de la statistique bayesienne
Manuel de formation sur la statistique bayesienne
Formation sur la statistique bayesienne approfondie
Table des matières

89
Introduction
1. Definition
2.1. Gaussian Naîve Bayes
2.2. Bernoulli Naîve Bayes
4. Avantages et limites de l’algorithme
4.1. Avantages
4.2. Limites
5. Exercices
5.1. Exercice 1
5.2. Exercice 2
6.1. Solution de l’exercice 1
Conclusion
Introduction
Le Naîve Bayes Classifier (classifieur bayésien naïf ou classifieur naïf de Bayes) est un modèle
d’apprentissage automatique de type supervisé permettant la classification en se basant sur le
théorème de Bayes avec une forte indépendance des hypothèses (c’est-à-dire pas de corrélation
entre les caractéristiques d’un ensemble de données). Cette classification appartient à la catégorie
des classifieurs linéaires.
1. Definition
Nous définirons dans ce qui suit des notions nécessaires à l’apprentissage et la maîtrise du
classifieur Naîf Bayesien.
90
Tout d’abord, le théorème de Bayes décrit la probabilité d’une caractéristique en se basant au

préalable sur des situations liées à celle-ci. Par exemple, si la probabilité qu’une personne soit
diabétique est liée à son âge, alors en utilisant ce théorème, on peut utiliser l’âge pour prédire
avec plus de précision la probabilité de souffrir de cette maladie chronique.
Le mot naïf dans l’intitulé de l’algorithme implique que chaque paire de caractéristiques dans
l’ensemble des données en question est indépendante de l’autre. C’est-à-dire que la valeur d’une
caractéristique particulière est indépendante de la valeur de toute autre caractéristique pour une
classe donnée. Par exemple, un fruit est classé comme une pomme s’il est rond, s’il a un diamètre
d’environ 13 cm et s’il est de couleur rouge. Avec le Naîve Bayes Classifier, chacune des trois
caractéristiques : forme, taille, et couleur contribuent indépendamment à la probabilité que ce
fruit soit une pomme. On suppose, en plus, qu’il n’y a pas de corrélation entre la forme, la taille
et la couleur.
Dans la majorité des cas, vous allez faire face à des caractéristiques continues. Dans ce cas,
l’algorithme en question suppose que les valeurs continues associées à chaque classe sont
distribuées selon une distribution normale.
La bibliothèque Scikit-learn de Python destinée à l’apprentissage automatique fourni le module
sklearn.naîve_bayes qui contient plusieurs classificateurs Bayes Naïfs, dont chacun performe
mieux sur un certain type de donnée.
Les types de classificateurs que la bibliothèque contient sont les suivants :
 Gaussian Naîve Bayes ;

 Multinomial Naîve Bayes ;
 Complement Naîve Bayes ;
 Bernoulli Naîve Bayes ;
 Categorical Naîve Bayes.
Nous nous intéresserons lors de ce tutoriel au classificateur Gaussien et Bernoulli.
2.1. Gaussian Naîve Bayes
Afin de découvrir concrètement le fonctionnement de l’algorithme Gaussian Naîve Bayes, nous

l’appliquerons sur un ensemble de données contenant trois caractéristiques : Glucose, pression
artérielle et diabète afin de classifier si une personne est atteinte de diabète ou non (1 pour oui 0
sinon).
Alors, nous importons dans un premier temps les éléments nécessaires, à

savoir : pandas, train_test_split, GaussianNB et accuracy_score. Ensuite, nous chargeons le
fichier csv contenant les données et nous affichons les résultats à l’aide de la
fonction head(). Ainsi, nous afficherons uniquement les cinq premiers enregistrements pour avoir
une idée sur l’ensemble de données.
91
 Code :
python
import pandas as pd
from sklearn.naîve_bayes import GaussianNB
from sklearn.metrics import accuracy_score
df = pd.read_csv( 'C:/Users/LENOVO/Desktop/coursGratuit/diabete.csv')
df.head()
On définit ensuite deux variables: x et y représentant respectivement les valeurs de

l’ensemble des données en données de train et de test au pourcentage 80% pour les données
d’entrainement et 20 % pour les données de test.
Ensuite, on crée une instance de l’objet GaussianNB et on l’entraine à l’aide de la méthode fit()
qu’on lui passe en paramètre x_train et y_train.
On fait une prédiction des valeurs de test à l’aide de la méthode predict() pour comparer ensuite
le résultat avec les valeurs y_test afin de calculer la précision du modèle.
 Code :
python
a = df['glucose']
b = df['pressionArterielle']
x = list(zip(a, b))
y = df['diabete']
92
#instanciation
model_Gaussian = GaussianNB()
#training
model_Gaussian.fit(x_train, y_train)
#prédiction
prediction = model_Gaussian.predict(x_test)
print(prediction)
#evaluation du modèle
precision = accuracy_score(y_test, prediction)*100
print(precision)
2.2. Bernoulli Naîve Bayes
En guise de découverte de l’algorithme Bernoulli Naîve Bayes, nous l’appliquerons sur un

ensemble de données contenant quatre caractéristiques principales : Sexe, taille, poids et pointure.
Dans le but de classifier si une personne est de sexe féminin ou masculin.
Alors, on importe dans un premier temps les éléments nécessaires à

savoir pandas, train_test_split, BernoulliNB et accuracy_score. Ensuite, on charge le fichier
Excel contenant les données et on affiche tous les enregistrements pour avoir une idée sur
l’ensemble de données.
93
 Code :
python
import pandas as pd
from sklearn.naîve_bayes import BernoulliNB
df = pd.read_excel('C:/Users/LENOVO/Desktop/coursGratuit/personne.xlsx')
print(df)

l’ensemble des données en données de train et de test avec un pourcentage de 80% pour les
données d’entraînement et 20 % pour les données de test.
Ensuite, on crée une instance de l’objet BernoulliNB, on l’entraine à l’aide de la

méthode fit() qu’on lui passe en paramètres x_train et y_train.
On fait une prédiction des valeurs de test à l’aide de la méthode predict() et on compare par la
suite ses valeurs avec les valeurs y_test pour calculer la précision du modèle.
 Code :
python
#Encodage
sexe = dict( zip (df.etiquette.unique(), df.Sexe.unique()))
print( sexe )
94
x = df[['Taille', 'Poids', 'Pointure']]

y = df['Sexe']
 Code :
python

#instanciation
model_Bernoulli = BernoulliNB()
#training
model_Bernoulli.fit(x_train, y_train)
#prédiction
prediction = model_Bernoulli.predict(x_test)
print(prediction)
print(precision)
95
Le Naîve Bayes Classifier peut être appliqué dans différents scénarios, un des cas d’utilisation
classiques pour ce modèle d’apprentissage est la classification des documents. Il s’agit de
déterminer si un document correspond à certaines catégories ou pas.
Il est aussi utilisé pour :
 Le filtrage de spam ;
 L’analyse des sentiments ;
 Les systèmes de recommandation.
4. Avantages et limites de l’algorithme

4.1. Avantages
Le Naîve Bayes Classifier est l’algorithme de classification le plus simple et le plus rapide. Les
calculs de probabilités ne sont pas couteux d’où sa rapidité.
Ce modèle d’apprentissage ne nécessite qu’un nombre faible d’échantillons d’entraînement par

rapport à d’autres modèles, comme la régression logistique et les arbres de décision, pour
effectuer une classification efficace. Il convient aussi aux larges ensembles de données.
4.2. Limites
Le Naîve Bayes Classifier suppose que les variables sont indépendantes, ce qui n’est toujours pas
vrai dans les cas réels.
En effet, si la corrélation entre les caractéristiques est grande, ce modèle d’apprentissage va

donner une mauvaise performance.
5. Exercices
5.1. Exercice 1
Appliquez le modèle Gaussian Naîve Bayes sur l’ensemble de données suivant :
Sexe Taille (cm) Poids (kg) Pointure (cm)

féminin 152 45.5 15
masculin 180 86.2 28
féminin 153 46.0 16
féminin 165 60.3 20
96
féminin 162 63.7 18

féminin 175 68.4 23
5.2. Exercice 2
Appliquez le Gaussian Naîve Bayes sur l’ensemble des données load_breast_cancer de sklearn.

Dans cet exercice, on importe dans un premier temps les éléments nécessaires, à
savoir : pandas, train_test_split, GaussianNB et accuracy_score. Ensuite, on charge le fichier
Excel contenant les données et on affiche tous les enregistrements pour avoir une idée sur
l’ensemble de données.
 Code :
python
import pandas as pd
from sklearn.naîve_bayes import GaussianNB
df = pd.read_excel ('C:/Users/LENOVO/Desktop/coursGratuit/personne.xlsx')
print(df)
97

Ensuite, on crée une instance de l’objet GaussianNB et on l’entraine à l’aide de la

méthode fit() qu’on lui passe en paramètre x_train et y_train.
On fait une prédiction des valeurs de test à l’aide de la méthode predict() pour comparer ses
valeurs résultantes avec les valeurs y_test et calculer ensuite la précision du modèle.
 Code :
python
#Encodage
sexe = dict( zip (df.etiquette.unique(), df.Sexe.unique()))
print( sexe )
x = df[['Taille', 'Poids', 'Pointure']]
y = df['Sexe']
#instanciation
#training
#prédiction
print(prediction)
print(precision)
98
Dans cet exercice, on importe tout d’abord les éléments load_breast_cancer, train_test_split et
train_test_split. Puis, on définit deux variables x et y représentant respectivement les valeurs de
caractéristiques et la valeur cible. Ensuite, on utilise la fonction train_test_split pour fractionner
On crée par la suite une instance de l’objet GaussianNB, on l’entraine à l’aide de la

méthode fit() qu’on lui passe en paramètre x_train et y_train.
On fait une prédiction des valeurs de test à l’aide de la méthode predict() pour comparer ses
valeurs résultantes avec les valeur y_test et calculer la précision du modèle.
 Code :
python
from sklearn.datasets import load_breast_cancer
from sklearn.naîve_bayes import train_test_split
df = load_breast_cancer()
99
x = df['data']
y = df['target']
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.40,
random_state = 42)
#instanciation
#training
#prédiction
print(prediction)
print(precision)
Conclusion
100
Lors de ce tutoriel nous avons découvert les étapes d’implémentation pour l’algorithme Naîve
Bayes Classifier destiné à la classification. Ainsi, nous avons entrainé deux types de cet
algorithme, à savoir le Gaussian Naîve Bayes et le Bernoulli Naîve Bayes, sur différents
ensembles de données pour réaliser une prédiction par la suite.

linéaire

 Excel : comment tracer une courbe de régression
101
Support de cours sur la statistique econometrie
Travaux dirigees sur l’hydrologie statistique
102

103
Table des matières
Introduction
1. Définition
104
4.1. Avantages
4.2. Limites
5. Exercices
5.1. Exercice 1
5.2. Exercice 2
5.3. Exercice 3
5.4. Exercice 4
6.1. Exercice 1
6.2. Exercice 2
6.3. Exercice 3
Conclusion
Introduction
La régression linéaire est l’un des principaux modèles à aborder en Machine Learning. À vrai
dire, il n’existe pas qu’un seul type de régression. On distingue la régression de type linéaire mais
aussi la régression logistique. Lors de ce tutoriel, nous n’aborderons que la régression linéaire en
utilisant la bibliothèque d’apprentissage automatique Scikit-learn.
1. Définition
Une régression a pour objectif d’expliquer une variable Y par le moyen d’une autre variable X.
Par exemple, le salaire d’une personne peut être expliqué à travers son niveau universitaire ; c’est
à dire le nombre d’années passées à l’université.
La régression linéaire est alors modélisée par l’équation linéaire suivante qui met en relation X et
Y:
Où
 et sont les paramètres du modèle ;

105
 X est la variable explicative ;

 Y est la variable expliquée ;
 est l’erreur de l’estimation.
Puisqu’on a une seule variable explicative, alors on est dans le cas de la régression linéaire
simple. Par conséquent, la régression linéaire multiple est lorsque vous avez au moins deux
variables explicatives.
Nous aborderons dans ce qui suit les modules fournis par la bibliothèque d’apprentissage
automatique Scikit-learn pour implémenter les fonctions de régression. Dans un premier temps,
nous allons commencer par un exemple de régression linéaire simple ensuite nous allons voir un
exemple de régression linéaire multiple.
La régression linéaire est l’une des techniques les plus utilisées dans l’apprentissage automatique
et cela revient principalement à sa simplicité et la facilité d’interprétation de ses résultats. Comme
on a pris l’habitude d’appliquer le modèle d’apprentissage sur un exemple pour le voir en action,
on va procéder ainsi pour l’algorithme de régression linéaire simple.
Tout d’abord, on importe le package NumPy et la classe LinearRegression. Ensuite, on définit

les données x et y sur lesquelles le modèle va performer et s’exécuter. On fait appel à la
méthode reshape() parce que le tableau x doit être bidimensionnel.
L’étape suivante consiste à créer une instance de la classe LinearRegression et on entraine celle-
ci sur notre ensemble de données à l’aide de la méthode fit().. On calcule ensuite la précision du
modèle à l’aide de la méthode score(). Ainsi, Le résultat obtenu par cette méthode est également
le coefficient de détermination (R²).
Finalement, on fait de la prédiction en appelant la méthode predict() appliquée sur notre modèle.
 Code :
python
import numpy as np
#données
x = np.array([6, 8, 10, 14, 18]).reshape((-1, 1))
y = np.array([7, 9, 13, 17, 18])
#instancier modèle
106
#prédiction
print(prediction)
2.1.1. Paramètres du modèle LinearRegression
Le modèle LinearRegression peut prendre plusieurs paramètres optionnels, à savoir :
 fit_intercept : prend une valeur booléenne qui calcule l’interception si elle est mise à la
valeur True, sinon elle prend la valeur zéro. Ce paramètre prend True par défaut.
 normalize : prend une valeur booléenne qui normalise les variables d’entrée si elle est mise à
True ou non sinon. Ce paramètre prend False par défaut.
 copy_X : prend une valeur booléenne qui copie les variables d’entrée si True, sinon elle les
écrase. Par défau,t il prend la valeur True.
 n_jobs : prend une valeur entière (ou None par défaut) et représente le nombre d’emplois
utilisés dans le calcul parallèle.
2.1.2. Les attributs du modèle LinearRegression
Les attributs du modèle LinearRegression simple sont :
 intercept_ : qui permet de calculer le paramètre .

 coef_ : qui permet de calculer le paramètre 1.
107
Code :
python
model_linReg.intercept_
model_linReg.coef_
Remarque :
On peut réaliser la même prévision sans avoir à faire appel à la méthode predict() et cela en
ajoutant à intercept_ appliquée au modèle la multiplication du coef_ appliquée au modèle par x .
La seule différence entre la prévision ci-dessous et la prévision obtenue à l’aide de la

méthode precidt() est que dans la première on a obtenu un tableau bidimensionnel et dans la
deuxième on a un tableau à une seule dimension.
 Code :
python
prediction = model_linReg.intercept_ + model_linReg.coef_*x
print(prediction)
Pour mettre en œuvre la régression linéaire multiple, on suit les mêmes étapes précédemment
citées pour la régression linéaire simple. Tout d’abord, on importe le package NumPy et la
classe LinearRegression.Ensuite, on définit les données x et y sur lesquelles le modèle va
performer.
108
Pour la régression linéaire multiple, x est bidimensionnel contenant au moins deux colonnes
et y, quand à lui, représente un tableau d’une dimension unique. L’étape qui suit consiste à créer
une instance de la classeLinearRegression et on entraine celle-ci sur notre ensemble de données
à l’aide de la méthode fit().
On calcule la précision du modèle à l’aide de la méthode score(). Le résultat obtenu par cette
méthode est également le coefficient de détermination (R²). Finalement, on réalise une prédiction
en appelant la méthodepredict() appliquée sur notre modèle.
 Code :
python
import numpy as np
#données
x = np.array([[5, 1], [8, 2], [10, 13], [14, 15], [18, 9]])
y = np.array([7, 9, 13, 17, 18])
#instancier modèle
model_linRegMul = LinearRegression()
model_linRegMul.fit(x, y)
precision = model_linRegMul.score(x, y)
#prédiction
test = np.arange(10).reshape((-1, 2))
prediction = model_linRegMul.predict(test)
print(prediction)
109
2.2.1. Attribut
On applique les attributs du modèle LinearRegression multiple pour notre exemple :
 Code :
python
model_linRegMul.intercept_
model_linRegMul.coef_
En général, la régression est utilisée pour avoir une idée concernant comment les liaisons de
variables entre elles. Cette méthode est également utile pour faire de la prévision, par exemple on
peut prévoir la consommation d’électricité d’un ménage pour une période compte tenu du nombre
de résidents dans celui-ci, de la température extérieure et de l’heure de la journée.
110
De nos jours, l’utilisation de la régression augmente de plus en plus vu la disponibilité de grandes

quantités de données et la sensibilisation de l’importance de ces dernières.
4.1. Avantages
Comme mentionné précédemment, la régression linéaire est simple à mettre en œuvre et donne
des résultats satisfaisants. Les modèles de régression peuvent être formés facilement et
efficacement. Ils ont aussi une complexité temporelle considérablement faible par rapport à
d’autres modèles d’apprentissage automatique. Cet algorithme performe sur des ensembles de
données séparables linéairement et il est ainsi souvent appliqué pour déterminer la nature de la
relation entre les variables.
4.2. Limites
Lors de l’application des modèles de régression, les valeurs aberrantes peuvent avoir des effets
énormes sur la régression. Il est possible dans certains cas qu’on retrouve des situations de sous-
ajustement (underfitting), et cela lorsque le modèle d’apprentissage automatique ne parvient pas à
saisir les données correctement ce qui est généralement le résultat d’une fonction d’hypothèse
mal adaptée aux données. La régression linéaire suppose alors que les données d’entrée sont
indépendantes l’une de l’autre.
5. Exercices
5.1. Exercice 1
Appliquez la régression linéaire sur la dataset « iris ».
5.2. Exercice 2
Appliquez la régression linéaire sur la dataset « Boston » de scikit-learn. Utilisez le code suivant
pour afficher une description détaillé de la dataset :
 Code :
python
print(données.DESCR)
111
5.3. Exercice 3
Générez un problème de régression aléatoire à l’aide de make_regression, et appliquer le modèle

de régression linéaire.
5.4. Exercice 4
Appliquez la régression linéaire sur un ensemble de données généré aléatoirement.

6.1. Exercice 1
Dans cet exercice, on souhaite prévoir la largeur d’un iris. Tout d’abord, on importe le
package pandas et la classe LinearRegression. Ensuite, on définit les variables x et y sur
lesquelles le modèle va performer. L’étape suivante consiste à créer une instance de la
méthode fit().
112

 Code :
python
import pandas as pd
#données
df.head()
x = df[["petal_length"]]
y = df["petal_width"]
#instancier modèle
#prédiction
longueur = 2.5
prediction = model_linReg.predict([[longueur]])
print(prediction)
113
6.2. Exercice 2
Dans cet exercice, on utilise l’ensemble de données concernant les prix de l’immobilier à Boston.
Tout d’abord, on importe le package pandas, linear_model et datasets. Ensuite, on définit les
variables x et y sur lesquelles le modèle va performer. On crée une instance de la
méthode fit().

 Code :
python
import pandas as pd
#charger la dataset Boston
df = pd.DataFrame(données.data, columns = données.feature_names)
df.head()
# données cible dans un nouveau dataframe
cible = pd.DataFrame(data.target, columns = ["MEDV"])
x = df
y = cible["MEDV"]
114
#instancier modèle
model_linReg = linear_model.LinearRegression()
#training
model_linReg.fit(x,y)
#prédiction
print(prediction[0:5])
6.3. Exercice 3
Dans cet exercice, on importe la classe LinearRegression et make_regression. À l’aide de cette

dernière, on va générer un problème de régression aléatoire sur lequel va se baser et s’entraîner
115
notre modèleLinearRegression qu’on a instancié en premier lieu et en lui applique ensuite la

méthode fit().
On fait la prédiction en appelant la méthode predict() appliquée sur notre modèle. Finalement, on
calcule la précision du modèle à l’aide de la méthode score().
 Code :
python
#generer problème de regression aléatoire
#instancier modèle
#Prédiction
prediction = model_linReg.predict( [[0,0,0]])
print('la prediction: ', prediction)
116
Exercice 4 :
Dans cet exercice, on génère aléatoirement des valeurs d’échantillons et de caractéristiques à

l’aide de la méthode randn() sur lesquelles s’entrainera notre modèle de régression linéaire et
cela en lui appliquant la méthode fit(). On fait ensuite la prédiction en appelant la
méthode predict() appliquée sur le modèle de régression linéaire. Finalement, on calcule la
précision du modèle à l’aide de la méthode score().
 Code :
python
import numpy as np
echantillons = 20
np.random.seed(0)
x = np.random.randn(echantillons, caracteristiques)
y = np.random.randn(echantillons)
117

#instancier modèle
#Prédiction
print("la prédiction:" ,prediction)
print("la précision du modèle: ", precision*100)
118
Conclusion
Dans ce tutoriel, nous avons défini le modèle de régression linéaire simple et multiple. Ainsi nous
l’avons appliqué sur plusieurs exemples en utilisant les classes fournies par la bibliothèque
d’apprentissage automatique Scikit-learn de Python.
Tuto Python & Scikit-learn : réduction de

dimensionnalité
Publié le 03 Décembre 2020 par Imane BENHMIDOU

119


120
Modèle de bon de réduction sur Word
Introduction to the Python language: installation, variables, functions and operations

121
Cours Python : types, structures de contrôles, Données et Variables
Table des matières

122
Introduction
1. Définition
2.1. PCA avec deux composantes
2.2. PCA avec trois composantes
2.3. LDA avec deux composantes
4.1. Avantages
4.2. Limites
5. Exercices
5.1. Exercice 1 :
6.1. Exercice 1
Conclusion
Introduction
Les algorithmes d’apprentissage automatique reposent sur des facteurs connus sous le nom de
variables. Plus le nombre de caractéristiques est élevé, plus il est difficile de visualiser les
données d’entrainement et de travailler dessus. Parfois, la plupart des caractéristiques sont
corrélées ce qui entraine la redondance. C’est alors là que les algorithmes de réduction de la
dimensionnalité se voient utiles pour lutter contre le fléau de la dimensionnalité.
1. Définition
d La réduction de la dimensionnalité peut se faire suivant deux méthodes :
 Suppression de caractéristiques.
 Combinaison de caractéristiques pour obtenir de nouvelles moins redondantes.
123
Il existe plusieurs méthodes pour la réduction de la dimensionnalité. Dans ce tutoriel, on

s’intéressera aux deux méthodes suivantes :
 L’analyse en composantes principales (en anglais, Principal Component Analysis PCA) : est
l’algorithme d’apprentissage automatique de type non supervisé le plus pratique qui peut être
utilisé pour visualiser des données qui ont plus de trois dimensions;
 L’analyse discriminante linéaire (en anglais, Linear Discriminant Analysis LDA) : est un algorithme
d’apprentissage automatique supervisé qui est utilisé pour la réduction de la dimensionnalité,
son approche est similaire à celle du PCA. Le LDA trouve les composants qui maximisent à la fois
la variance des données et la séparation entre les multiples classes ;
La réduction de la dimensionnalité peut être linéaire ou non linéaire selon la méthode utilisée. La
méthode linéaire la plus utilisée est l’analyse en composantes principales (PCA).
La réduction de la dimensionnalité est utile pour les problèmes de vraies données qui peuvent être
des données de haute dimension et peuvent aller jusqu’à des millions. Alors cela permet de
conserver que les caractéristiques discriminantes pour éviter ainsi le surapprentissage des
modèles.
La bibliothèque d’apprentissage automatique Scikit-learn de Python met en place les
modules sklearn.decomposition et sklearn.discriminant_analysis pour utiliser la réduction de la
dimensionnalité.
Pour illustrer le fonctionnement de l’algorithme de réduction de la dimensionnalité avec Python,

nous procéderons par l’appliquer sur la dataset « iris ».
Tout d’abord, nous importons les bibliothèques nécessaires : Pandas et Numpy qui permettent la
manipulation des données, Seaborn et Matplotlib pour visualiser ces dernières et
finalement sklearn pour l’algorithme en question et pour importer la dataset « iris ».
 Code :
python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
124
On importe par la suite l’ensemble des données « iris ».
 Code :
python
# import de l'ensemble de données
iris = datasets.load_iris()
X = iris.data
y = iris.target
cibles = iris.target_names
print(cibles)
Ensuite, nous examinons l’ensemble des données « iris » qui est assez populaire dans la
littérature sur l’apprentissage automatique. Celui-ci contient trois classes, chacune représente un
type de la plante iris.
 Code :
python
df = pd.DataFrame(iris.data, columns = iris.feature_names)
df['Species'] = iris['target']
df['Species'] = df['Species'].apply(lambda x: iris['target_names'][x])
df.head()
125
Dans le code suivant, on visualise à l’aide des bibliothèques Seaborn et Matplotlib les classes
qui sont séparées en fonction des différentes caractéristiques.
Dans un premier temps, on affiche les classes de l’ensemble des données en fonction de sepal
length et sepal width, ensuite en fonction de petal length et petal width.
 Code :
python
couleur = {'Setosa' : 'blue', 'Versicolor' : 'red', 'Virginica' : 'orange'}

#Voyons comment les classes sont séparées en fonction des différentes
caractéristiques
sns.FacetGrid(df, hue = "Species", height = 4,
palette = couleur.values()).map(plt.scatter, "sepal length (cm)",
"sepal width (cm)").add_legend()
sns.FacetGrid(df, hue = "Species", height = 4,
palette = couleur.values()).map(plt.scatter, "petal length (cm)",
"petal width (cm)").add_legend()
plt.show()
126
La
matrice de corrélation peut aider à mieux comprendre un ensemble de données. Pour notre
exemple de dataset « iris », elle va nous indique comment les quatre caractéristiques sont
corrélées.
En utilisant la bibliothèque seaborn, on obtient facilement la matrice de corrélation, qui à partir

de laquelle on peut remarquer une forte corrélation entre les caractéristiques sepal length et sepal
width.
 Code :
python
#creer une matrice de correlation
df.corr()
sns.heatmap(df.corr(), cmap = 'PiYG', annot = True)
127
Dans le code suivant, nous allons normaliser nos caractéristiques avant d’appliquer le PCA à
deux composantes afin de représenter les données en deux dimensions.
 Code :
python
#normalisation des données en utilisant standard scaler
scaler = StandardScaler()
X = scaler.fit_transform(X)
2.1. PCA avec deux composantes

128
Après avoir normalisé les données, on transforme les caractéristiques en utilisant le PCA.
Le PCA à deux composantes nous aide à visualiser l’ensemble de données « iris », on peut
remarquer que la classe « Setorsa » est très différente des deux autres classes. On calcule
également la variance expliquée qui nous indique la part de variance que prennent les deux
composantes. On obtient alors un résultat de 95,8% qui signifie que les deux composantes
principales absorbent 95.8% de la variance qui veut dire que la représentation en deux
dimensions est significative.
Remarque :
Avec un résultat inférieur à 85%, la représentation des données en deux dimensions peut ne pas
être valide.
 Code :
python
#L’analyse en composantes principales PCA
pca = PCA(n_components=2)
X_reduit = pca.fit_transform(X)
for color, i, cibles in zip(couleur.values(), [0, 1, 2], cibles):
plt.scatter(X_reduit[y == i, 0], X_reduit[y == i, 1], color = color, alpha =
.8,
label = cibles, s = 130, edgecolors = 'k')
plt.legend(loc = 'best', shadow = False, scatterpoints = 1)
plt.xlabel("1ère composante du PCA")
plt.ylabel("2e composante du PCA")
plt.title('PCA de la dataset iris')
# pourcentage de la variance expliquée pour chaque composantes
print('variance expliquée pour chaque composantes: %s' %
str(pca.explained_variance_ratio_))
plt.show()
129
2.2. PCA avec trois composantes
Nous allons tracer dans ce qui suit les trois premières composantes du PCA afin de mieux
comprendre l’interaction des caractéristiques.
 Code :
python
from mpl_toolkits.mplot3d import Axes3D
figure = plt.figure(1, figsize = (8, 6))
axe = Axes3D(figure, elev =- 150, azim = 110)
pca3 = PCA(n_components = 3)
X_reduit = pca3.fit_transform(iris.data)
axe.scatter(X_reduit[:, 0], X_reduit[:, 1], X_reduit[:, 2], c = y, cmap =
plt.cm.spring, edgecolor = 'k', s = 130)
axe.set_title("trois premieres composantes du PCA")
axe.set_xlabel("1ère composante du PCA")
axe.w_xaxis.set_ticklabels([])
axe.set_ylabel("2e composante du PCA")
axe.w_yaxis.set_ticklabels([])
axe.set_zlabel("3e composante du PCA")
axe.w_zaxis.set_ticklabels([])
# pourcentage de la variance expliquée pour chaque composantes
print('variance expliquée pour chaque composantes:
130
{}'.format(pca3.explained_variance_ratio_))
plt.show()
2.3. LDA avec deux composantes
Dans la partie du code suivant, on calcule les deux premières composantes du LDA et on les
visualise.
Remarquons que la classe « Setosa » est encore une fois séparée des données des deux autres
classes. On peut aussi constater que le LDA est plus performant que le PCA pour maintenir le
chevauchement à un minimum entre les deux classes « Versicolor » et « Virginica ».
 Code :
python
couleur = {'Setosa' : 'blue','Versicolor' : 'red','Virginica' : 'orange'}

lda = LinearDiscriminantAnalysis(n_components=2)
lda.fit(X, y)
X_reduit = lda.transform(X)
plt.figure(figsize = (10,8))
131
for cl, i, cible in zip(couleur.values(), [0, 1, 2], cibles):

plt.scatter(X_reduit[y == i, 0], X_reduit[y == i, 1], alpha = .8, color = cl,
label = cible, s = 130, edgecolors = 'k')
plt.legend(loc = 3, shadow = False, scatterpoints = 1)
plt.xlabel('lda1')
plt.ylabel('lda2')
plt.title("Projection de l'iris sur les 2 premiers discriminants linéaires")
print('variance expliquée pour chaque composantes:
{}'.format(lda.explained_variance_ratio_))
plt.show()
132
Le PCA fonctionne avec des variables fortement corrélées. Si la relation entre les variables est
faible, le PCA ne sera pas efficace. Alors l’utilisation de la matrice de corrélation avant
d’appliquer l’algorithme de PCA est fortement recommandée.
Il faut cependant examiner les coefficients de corrélation pour déterminer les variables fortement
corrélées.
Le LDA quant à lui est souvent utilisé dans le prétraitement des données destinées aux modèles
de classification. Il est utilisé uniquement pour l’apprentissage supervisé c’est-à-dire lorsqu’on
connait à l’avance les étiquettes des classes.
Le PCA est utilisé dans les domaines tels que la reconnaissance faciale, la vision par ordinateur et
la compression d’images. Cet algorithme de réduction de la dimensionnalité est aussi utilisé dans
le domaine de la finance, la data mining et la bio-informatique pour trouver des tendances dans
des données de haute dimension.
4.1. Avantages
Les principaux avantages du PCA sont :
 La suppression des caractéristiques corrélées : dans les cas réels d’apprentissage automatique,
les ensembles de données contiennent beaucoup de caractéristiques qui réduisent la
performance des algorithmes et rendent difficile la visualisation des données, alors la réduction
du nombre de celles-ci se voit incontournable. Le PCA trouve efficacement les variables corrélées
et donne des composantes principales indépendantes les unes des autres.
 L’amélioration des performances des algorithmes : le PCA est effectivement un moyen très
efficace pour accélérer les algorithmes d’apprentissage automatique en éliminant les variables
corrélées qui ne contribuent pas à aucune prise de décision.
 La réduction du sur-apprentissage : ce phénomène est produit principalement lorsqu’il y a trop
de variables dans l’ensemble de données. Alors, en réduisant le nombre de caractéristiques on
arrive à surmonter ce problème.
 La visualisation des données : le PCA permet de transformer les données en haute dimension en
basse dimension afin de les visualiser facilement.
4.2. Limites
Pour les limites du PCA, elles se résument en ce qui suit :
 Les variables indépendantes deviennent moins significatives : après avoir appliqué le PCA sur
un ensemble de données, les caractéristiques originales deviennent des composantes principales
qui sont la combinaison linéaire des caractéristiques principales. Celles-ci ne sont pas aussi
lisibles et interprétables que les caractéristiques originales.
133
 La normalisation des données est nécessaire avant le PCA : avant de mettre en œuvre le PCA, il
faut obligatoirement normaliser les données sinon ce dernier ne sera pas en mesure de trouver
des composantes principales optimales.
 La perte d’informations : le PCA essaie de couvrir la variance maximale entre les caractéristiques
d’un ensemble de données, alors le choix du nombre de composantes principales doit être fait
avec soin pour ne pas manquer certaines informations liées à la liste originales de
caractéristiques.
5. Exercices
5.1. Exercice 1 :
Appliquez la méthode du PCA sur l’ensemble de données suivant :

6.1. Exercice 1
On importe tout d’abord les bibliothèques nécessaires, ensuite l’ensemble de données.
 Code :
python
import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.decomposition import PCA
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
df = pd.read_csv('C:/Users/LENOVO/Desktop/coursGratuit/mushrooms.csv')
df.head()
134
Dans le code suivant, nous avons encodé les données en utilisant le LabelEncoder car nous ne
pouvons pas utiliser le PCA avec des variables catégorielles.
La caractéristique de « classe » est la première colonne de l'ensemble de données, c'est pourquoi

nous avons divisé les caractéristiques et les étiquettes ainsi.
Ensuite, nous avons standardisé les caractéristiques avec le StandardScaler.
 Code :
python
encoder = LabelEncoder()
# On transforme les colonnes de la dataset
for colonne in df.columns:
df[colonne] = encoder.fit_transform(df[colonne])
X = df.iloc[:,1:23]
y = df.iloc[:, 0]
#on met à l'echelle les caractéristiques
scaler = StandardScaler()
X = scaler.fit_transform(X)
135
Maintenant, nous utilisant le PCA pour obtenir une liste des caractéristiques qu’on va visualiser
dans un tracé représentant les caractéristiques qui ont le plus de pouvoir explicatif : c’est les
composantes principales. Il semble y avoir 17 soit près de 95% des données.
 Code :
python
# on visualise
pca = PCA()
pca.fit_transform(X)
pca_variance = pca.explained_variance_
plt.figure(figsize = (8, 6))
plt.bar(range(22), pca_variance, alpha = 0.5, align = 'center',
label = 'variance individuelle')
plt.legend()
plt.ylabel('Rapport de variance')
plt.xlabel('Composantes princiales')
plt.show()
136
On convertit les deux premières caractéristiques en composantes principales, puis on trace un

diagramme de classification des points en fonction des deux caractéristiques.
 Code :
python
#PCA avec deux composantes
pca2 = PCA(n_components = 2)
pca2.fit(X)
X_reduit = pca2.transform(X)
plt.figure(figsize=(8,6))
plt.scatter(X_reduit[:,0], X_reduit[:,1], c = df['class'])
plt.show()
137
Conclusion
Dans ce tutoriel nous avons vu deux principales méthodes de la réduction de la dimensionnalité
qui sont le PCA et le LDA ainsi que leur implémentation en Python. À la fin du tutoriel, nous
avons renforcé les connaissances acquises à l’aide de quelques exercices d’application.
Tuto Python & Scikit-learn : les arbres de

décision

138


139
Cours pour apprendre la decision financiere
140
General tutorial to learn python and get started with programming
Training guide to learn in detail the Python extension and Integration
Table des matières

141
Introduction
1. Définition
2. Module Scikit_learn
2.1. Classification avec les arbres de décision
2.2. Régression avec les arbres de décision
4.1. Avantages
4.2. Limites
5. Exercices
6. Solution des Exercices
Conclusion
Introduction
Les arbres de décision (Decisions trees) sont des outils d’aide à la prise de décision et
d’exploitation de données permettant de présenter un ensemble de données sous la forme
graphique d’un arbre.
Cette méthode d’apprentissage automatique est de type supervisé permettant de résoudre à la fois
des problèmes de classification et de régression qu’on détaillera tout au long de ce tutoriel.
1. Définition
Comme précédemment introduit, les arbres de décision sont des outils de classification et de
prédiction, populaires pour leur simplicité ainsi que leur performance.
Un arbre de décision est composé de :
 Un nœud racine par lequel les données entrent.

 Des nœuds de décision représentant un classement de questions et de réponses qui
conditionnent la question suivante.
 Des branches qui connectent entre les nœuds et pouvant être orientées. Dans ce cas l’un des
nœuds de la connexion est appelé nœud parent et l’autre nœud enfant.
Remarque :
142
 Les nœuds peuvent être connectés à un seul nœud parent, saut pour le nœud racine qui n’en a
aucun.
 Un nœud qui n’a aucun nœud enfant est appelé nœud feuille ou simplement feuille.
Un chemin cependant est le parcours à partir du nœud racine jusqu’à un nœud feuille.
Comme on a eu l’habitude avec les modèles d’apprentissage supervisés, d’avoir une variable
cible avec plusieurs variables prédictives, pour un arbre de décision chaque nœud correspond à
une variable prédictive, ainsi chaque nœud feuille représente la variable cible et chaque branche
correspond à une valeur pour la variable prédictive du nœud parent.
L’objectif des arbres de décision est de créer un modèle qui permet la prédiction de la valeur de
la variable cible en apprenant des règles de décisions simples conclues des caractéristiques des
données.
Alors le nœud racine est le nœud d’entrée et les nœuds feuilles représentent la sortie finale.
2. Module Scikit_learn
Nous détaillerons dans ce qui suit, les arbres de classification et de régression fournies par la
bibliothèque destinée à l’apprentissage automatique scikit-learn de Python.
2.1. Classification avec les arbres de décision
Les arbres de classification permettent de prédire l’étiquette de la classe à laquelle une variable
cible appartient. Pour cela les variables doivent être catégoriques.
La bibliothèque scikit-learn fournit le module DecisionTreeClassifier qui effectue sur un

ensemble de données une classification multi-classe.
Afin de démontrer le fonctionnement de ce module, nous allons l’appliquer sur la

dataset « iris » qui concerne les trois espèces de l’iris représentées comme suivant : 0 pour setosa,
1 pour versicolor et 2 pour virginica.
Tout d’abord nous allons importer le module pandas qui nous permettra de lire le fichier csv, on
importe aussi train_test_split qui nous permettra de fractionner la dataset en données de training
et de test.
Ensuite on charge le fichier CSV comprenant les données et on définit une variable x qui va
contenir les données de caractéristique et une autre variable y pour les valeurs cibles qui sont les
étiquettes de classe pour les échantillons d’entrainement.
A l’aide de la fonction head() on affiche les cinq premières lignes de la dataset pour avoir une
idée sur celle-ci.
 Code :
143
python
import pandas as pd
df = pd.read_csv( 'C:/Users/LENOVO/Desktop/coursGratuit/iris.csv')
a = df.loc[:, "petal_length"]
b = df.loc[:, "petal_width"]
x = list(zip(a, b))
y = df.loc[:, "species"]
df.head()
Dans le code suivant, on a tout d’abord importé la classe DecisionTreeClassifier puis on a

fractionné notre dataset à l’aide de train_test_split qu’on a précédemment importé.
Puis nous avons créé une instance model_DT de l’objet DecisionTreeClassifier. On entraine
celle-ci à l’aide de la méthode fit() qu’on lui passe en paramètres x_train et y_train.
En faisant appel à la méthode score() on calcule la précision de ce modèle.
Puis finalement, on fait entrer la longueur et la largeur d’un iris et on demande au

modèle DecisionTreeClassifier de prédire son espèce en utilisant la méthode de predict().
 Code :
python
144
from sklearn.tree import DecisionTreeClassifier

#instanciation
model_DT = DecisionTreeClassifier()
#training
model_DT.fit(x_train, y_train)
#Prédiction
longueur = 2.5
largeur = 0.75
prediction = model_DT.predict( [[longueur, largeur]])
print( model_DT.score( x_test, y_test))
print( resultat)
145
Le module DecisionTreeClassifier peut prendre plusieurs paramètres optionnels, nous ne

présenterons ci-après que trois, jugées intéressantes :
- max_depth : Ce paramètre détermine la profondeur maximale de l’arbre. Il prend par défaut la

valeur None qui revient à dire que les nœuds vont se développer jusqu’à ce que toutes les feuilles
soient pures.
- min_samples_leaf : Ce paramètre donne le nombre minimum d’échantillons requis pour se

retrouver à un nœud de feuille. Sa valeur par défaut est 1.
- criterion : Représente la fonction de mesure de la qualité d’une scission. Il peut prendre soit le
critère « gini » qui correspond à l’impureté de Gini, soit « entropy » qui correspond au gain
d’informations. Sa valeur par défaut est « gini ».
On reprend la dataset « iris » et on lui applique le modèle DecisionTreeClassifier en lui passant

en paramètre max_depth et min_samples_leaf.
 Code :
python
146
#instanciation
model_DT = DecisionTreeClassifier(max_depth = 3, min_samples_leaf = 2 )
#training
model_DT.fit(x_train, y_train)
#Prédiction
longueur = 2.5
largeur = 0.75
prediction = model_DT.predict( [[longueur, largeur]])
print( model_DT.score( x_test, y_test))
print( resultat)
147
On peut aussi prévoir la probabilité de chaque classe en faisant appel à la

méthode predict_proba().
 Code :
python
prediction = model_DT.predict_proba([[2.5,0.75]])
print(prediction)
2.2. Régression avec les arbres de décision
Les arbres de régression permettent de prédire une valeur numérique qui est une quantité réelle.
Pour cela les variables de décision sont continues.
La bibliothèque d’apprentissage automatique scikit-learn fournit le

module DecisionTreeRegressor afin de performer l’algorithme d’arbre de décision sur des
problèmes de régression.
Afin de démontrer le fonctionnement de ce module, nous allons générer un jeu de données

aléatoire sur lequel notre algorithme de régression performera.
Dans la partie de code ci-dessous, on a importé dans un premier temps les modules nécessaires, à
savoir numpy, matplotlib et la classe DecisionTreeRegressor. Nous avons ensuite rempli un
tableau de nombres générées aléatoirement à l’aide de RandomState(). Puis à l’aide de la
fonction ravel(), nous retournons un tableau contigu aplati.
Ensuite nous avons créé une instance model_DTReg de l’objet DecisionTreeRegressor. On

entraine celle-ci à l’aide de la méthode fit() qu’on lui passe en paramètre x et y.
Finalement, on fait entrer une valeur de test x_test on demande au

modèle DecisionTreeRegressor de faire sa prédiction en utilisant la méthode de predict().
On affiche par la suite un graphe représentant les données caractéristiques et les données cibles
qu’on a précédemment générées (en rouge) et la prédiction (en bleu).
 Code :
python
148
import numpy as np
from sklearn.tree import DecisionTreeRegressor
#générer les nombre aléatoire
generateur = np.random.RandomState(1)
#tableau trié contenant 80 nombre généré aléatoirement
x = np.sort(5 * generateur.rand(200, 1), axis = 0)
#applatir le tableau en utilisant ravel
y = np.sin(x).ravel()
#ajout d'un bruit
y[::1] += 0.2 * (0.5 - generateur.rand(200))
#instanciation
model_DTReg = DecisionTreeRegressor(max_depth = 3)
#training
model_DTReg.fit(x, y)
#prédiction
x_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
# transformation d’un tableau 1D en un tableau N*1
prediction = model_DTReg.predict(x_test)
plt.figure()
plt.scatter(x, y, c = "red", label = "données")
plt.plot(x_test, prediction, color = "blue", label = "profondeurArbre = 3",
linewidth = 2)
plt.xlabel("données")
plt.ylabel("cible")
plt.title("Arbre de régression")
plt.legend()
plt.show()
149
Le DecisionTreeRegressor prend plusieurs paramètres optionnels qui sont similaires à ceux

du DecisionTreeClassifier. Certes, il diffère au niveau du paramètre criterion.
Pour le DecisionTreeRegressor, le paramètre criterion peut prendre l’une des valeurs suivantes :
- mse : Correspond à l’erreur quadratique moyenne. Elle est égale à la réduction de la variance
comme critère de sélection des caractéristiques.
150
- freidman_mse : Correspond aussi à l’erreur quadratique moyenne mais avec le score

d’amélioration de Friedman.
- mae : Correspond à l’erreur moyenne absolue. Minimise la perte de L1 en utilisant la médiane

de chaque nœud terminal.
Voici quelques utilisations des arbres de décision :
- La prévision des résultats dans le domaine de la finance et l’attribution de probabilité à ces

résultats.
- La prévision binomiale sur les prix et l’analyse des options réelles.
- La volonté d’un client à acheter un produit donné dans un certain contexte.
- La planification des produits.
- Prise de décision générale pour les affaires.
- Approbation de prêt.
4.1. Avantages
Ce qui rend les arbres de décision intéressants est leur simplicité à comprendre et à visualiser,
leur faible nécessité de préparation de données et le fait que leur coût d’utilisation est
logarithmique. Ils peuvent également utiliser des données catégorielles ainsi que numériques.
4.2. Limites
Les modèles d’arbre de décision peuvent quelque fois montrer du sur-apprentissage, c’est-à-dire
que dans certains cas d’utilisations, les arbres générés sont trop complexes. Cependant il est
possible que ces derniers ne soient pas équilibrés ce qui implique que le temps de parcours ne soit
plus logarithmique.
5. Exercices
Exercice 1 :
Appliquez le modèle d’arbre de classification sur l’ensemble de données suivant:
python
151
entrainement = [[2, 4, 3], [2, 1, 4], [2, 1, 7]]

cible = [10, 20, 30]
Faites la prédiction avec des valeurs de votre choix.
Exercice 2 :
Appliquez le modèle Random Forest (pour un problème de régression) sur un jeu de données
généré aléatoirement.
Sachant que le Random Forest (forêts d’arbres décisionnels) repose sur les bases de calcul de
l’apprentissage par arbre de décision.
6. Solution des Exercices

Exercice 1 :
Dans cet exercice, on forme un classificateur d’arbre de décision à l’aide de trois vecteurs de
caractéristiques. On crée pour cela une instance de la classe DecisionTreeClassifier puis on
entraine celui-ci pour finalement prédire le résultat d’un quatrième vecteur inconnu qui est le
vecteur a.
 Code :
python
from sklearn.tree import DecisionTreeClassifier
#données à traiter
entrainement = [[2, 4, 3], [2, 1, 4], [2, 1, 7]]
cible = [10, 20, 30]
#instantiation
model_DTC = DecisionTreeClassifier(random_state = 0)
#training
model_DTC.fit(entrainement, cible)
#prédiction
a = [[2,2,3]]
prediction = model_DTC.predict(a)
#affichage
print(prediction)
152
Exercice 2 :
Dans cet exercice, on a importé dans un premier temps les modules nécessaires, à
savoir numpy, matplotlib et la classe RandomForestRegressor. Nous avons ensuite rempli un
tableau de nombre généré aléatoirement à l’aide de RandomState(). Puis à l’aide de la
fonction ravel() nous retournons un tableau contigu aplati.
Ensuite nous avons créé une instance model_RFReg de l’objet RandomForestRegressor. On

entraine celle-ci à l’aide de la méthode fit() qu’on lui passe en paramètre x et y.
Finalement, on fait entrer une valeur de test x_test on demande au

modèle RandomForestRegressor de faire sa prédiction en utilisant la méthode de predict().
On affiche par la suite un graphe représentant les données caractéristiques et les données cibles
qu’on a précédemment générées (en rouge) et la prédiction (en bleu).
 Code :
python
import numpy as np
from sklearn.ensemble import RandomForestRegressor
#générer les nombre aléatoire
generateur = np.random.RandomState(1)
#tableau trié contenant 80 nombre généré aléatoirement
x = np.sort(5 * generateur.rand(200, 1), axis = 0)
#applatir le tableau en utilisant ravel
y = np.sin(x).ravel()
#ajout d'un bruit
y[::1] += 0.2 * (0.5 - generateur.rand(200))
#instanciation
model_RFReg = RandomForestRegressor(max_depth = 3)
153
#training
model_RFReg.fit(x, y)
#prédiction
x_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
# transformation d’un tableau 1D en un tableau N*1
prediction = model_RFReg.predict(x_test)
plt.figure()
plt.scatter(x, y, c = "red", label = "données")
plt.plot(x_test, prediction, color = "blue", label = "profondeurArbre = 3",
linewidth = 2)
plt.xlabel("données")
plt.ylabel("cible")
plt.title("Arbre de régression")
plt.legend()
plt.show()
154
Conclusion
Lors de ce tutoriel, nous avons défini le modèle d’apprentissage automatique arbre de décision
ainsi que les différentes terminologies utilisées. Nous avons aussi vu les modules fournis par la
bibliothèque d’apprentissage automatique scikit-learn pour les arbres de classification et de
régression.
Tuto Python & Scikit-Image : traitement

d’images
Publié le 03 Décembre 2020 par Sami Nadif
 Tuto Python & Mahotas : traitement d'images

 Tuto Python & OpenCV : traitement d'images
 Tuto Python & NumPy : traitement d'images
 Tuto Python & Scipy : traitement d'images
 Tuto Python & Pillow : traitement d'images
 Tuto Python : Comment faire des animations ?
155
Cours sur le traitement d’images avec OpenCV
Cours sur le traitement d'image avec le langage de programmation python
Débuter avec le Logiciel de traitement d'image GIMP

156
Cours GIMP : Insérer une image ou une photo dans un cadre
Formation complet sur la création et de traitement de l’image avec GIMP
Initiation à GIMP : programme de manipulation des images

157
Améliorer une image
Débuter au traitement des images par le logiciel GIMP
Table des matières
Introduction
1. Premiers pas avec Scikit-image
1.1. Importer une image
1.2. Afficher une image
1.3. Sauvegarder une image
2. Manipuler une image

158
2.1. Histogramme des pixels
2.2. Image en nuance de gris
2.3. Image monochrome
2.4. Détection des bords
2.5. Segmentation
2.6. Les filtres
3. Exercices
3.1. Exercice 1
3.2. Exercice 2
4.1. Exercice 1
4.2. Exercice 2
Conclusion
Introduction
d Dans ce tutoriel, nous allons vous initier au traitement d’images en utilisant la
bibliothèque Scikit Image. L'objectif n'est pas d'apprendre la bibliothèque en détail, mais d'en
apprendre suffisamment afin que vous soyez capable de réaliser quelques manipulations de bases.
Les images sont devenues une source importante des données numériques, d’où la nécessité de
les traiter. En améliorant l'image, en extrayant les données et en les analysant, nous sommes
capables de traiter les images et les utiliser dans divers domaines tels que l'intelligence
artificielle, l'infographie, la recherche médicale et bien d'autres encore.
En raison de sa popularité croissante et de la disponibilité de nombreuses bibliothèques faciles à

utiliser, Python est un excellent choix pour le traitement d’images. Il existe de nombreuses
bibliothèques de traitement d'images disponibles en Python comme Numpy, OpenCV, Python
Image Library (PIL), etc. Ce tutoriel est centré sur Scikit-image. C’est une bibliothèque open
source assez simple, destinée à la recherche, à l'éducation et aux applications industrielles. Elle
dispose de nombreux algorithmes de segmentation, de manipulation des couleurs, de filtrage, etc.
159
Mais avant d'aller plus loin, examinons les bases de l'image numérique. Une image, sous forme
numérique, est composée de pixels. Ce sont les plus petites unités d'information qui composent
une image. Une façon simple de décrire chaque pixel est d'utiliser une combinaison de trois
canaux (couleurs), à savoir le rouge, le vert et le bleu. D’autre part, une image en nuance de gris
ne contient qu’un seul canal (le gris) couvrant différentes tonalités de noir et de blanc et les pixels
sont représentés par une seule valeur entre 0 et 255.
Maintenant vous pouvez commencer! Allons-y.
1. Premiers pas avec Scikit-image

Avant de commencer, il faut choisir une image de test. Tout d'abord, installez la bibliothèque
Scikit Image en utilisant la syntaxe suivante :
Syntaxe:
python
pip install scikit-image
Ensuite, importez-la et vérifiez sa version en utilisant l'attribut version:
Syntaxe:
python
import skimage
skimage.__version__
Ici, nous avons utilisé la version 0.16.2.
1.1. Importer une image
L'étape indispensable à tout traitement est le chargement de l'image. Pour effectuer cette tâche, il
faut importer le module io et utiliser la fonction imread() en lui passant le chemin vers le fichier
image test.jpg. Cela devrait nous renvoyer un objet numpy.ndarray, que nous allons placer dans
la variable image :
Syntaxe:
python
from skimage import io
image = io.imread('/path/test.jpg')
Vu que l’image importée est sous forme d’un vecteur numpy, nous utiliserons les
attributs dtype et shape pour extraire quelques informations. Vous pouvez aller voir le tutoriel
160
« Les bases de traitement d'images en Python : Bibliothèque NumPy », pour vous initier au
traitement d’images avec NumPy.
Syntaxe:
python
# informations
print( 'classe :', type(image) )
print( 'type :', image.dtype )
print( 'taille :', image.shape )
Résultat d’exécution:
Remarquez que notre image importée est un vecteur de classe numpy.ndarray contenant des
valeurs de type uint8 (entier) de 3 dimensions dont la forme est (hauteur, largeur, canal (Rouge,
Vert, Bleu)).
1.2. Afficher une image
Vous pouvez afficher l’image en utilisant la fonction imshow() du module io :
Syntaxe:
python
io.imshow(image)
io.show()
Le script précédant applique les fonctions imshow() et show(). imshow() affiche une image
et show() affiche les images mises en file d'attente par imshow. Pour mieux comprendre cela,
nous allons utiliser le module data de Scikit Image (skimage) qui contient des images pré
161
chargées (images de démonstration standard qui peuvent être utilisées pour effectuer des tests).
Le script suivant affiche deux images (astronautet coffee) de ce module :
Syntaxe:
python
from skimage import data
image_1 = data.astronaut()
image_2 = data.coffee()
io.imshow( image_1 )
# la commande suivante io.show() est obligatoire pour afficher les deux images
simultanément
io.show()
io.imshow( image_2 )
io.show()
Vous pouvez utiliser la fonction dir() (qui permet de lister le contenu d'un objet) pour afficher
toutes les images disponibles dans le module data.
1.3. Sauvegarder une image
Vous pouvez sauvegarder votre image avec la fonction imsave() du module io. La
fonction imsave() prend l'emplacement et l'image qui doit être sauvegardée en tant que
paramètres. Le format du fichier sauvegardé est automatiquement déterminé à partir de
l'extension :
Syntaxe:
162
python
io.imsave('path/nom.png', image)
2. Manipuler une image

Passons à la pratique ! L'objectif est d'apprendre à manipuler les images en utilisant la
bibliothèque Scikit Image et de comprendre les notions basiques avec un exemple concret. Pour
cela, Nous allons utiliser notre image de test :
Syntaxe:
python
io.imshow( image )
io.show()
2.1. Histogramme des pixels
Nous affichons l'histogramme de notre image qui représente la répartition des pixels selon leur
intensité (de 0 à 255). Les trois canaux (rouge, vert et bleu) ont chacun un histogramme
correspondant. Pour créer l’histogramme de notre image test, nous allons utiliser la
fonction histogram() du module exposure. Pour le tracer, nous utilisons la
bibliothèque matplotlib (assurez-vous que la bibliothèque matplotlib est installée). Le script
suivant affiche l’histogramme des pixels de notre image test pour chaque canal :
Syntaxe:
python
from skimage import exposure
fig, axs = plt.subplots(nrows = 1, ncols = 3, figsize = (13,4))
canals = ['rouge', 'vert', 'bleu']
for i, canal in enumerate(canals):
hist = exposure.histogram( image[ : , : , (i)] )
163
axs[i].plot(hist[0])
axs[i].set_title(canal)
2.2. Image en nuance de gris
Une image couleur (mode RGB) peut être convertie en nuance de gris. Une image en nuances de
gris n'a pas de canal puisqu'elle ne donne aucune information sur les couleurs, ainsi la complexité
du calcul est réduite lorsqu'elle est utilisée. Pour convertir une image couleur en une image en
nuances de gris, utilisez la fonction rgb2grey() du module color qui prend l'image originale en
paramètres. Le script est le suivant :
Syntaxe:
python
from skimage import color
grey_image = color.rgb2grey( image )
io.imshow( grey_image )
io.show()
Remarque : L’image en nuance de gris générée à partir de la fonction rgb2grey() a des valeurs
de pixels normalisées (entre 0 et 1). Il faut multiplier par 255 pour avoir des valeurs entre 0 et
255.
2.3. Image monochrome

164
En mode RGB, chaque pixel de l'image est représenté par trois entiers. Pour générer des images
monochromes, vous pouvez utiliser une image en nuances de gris et générer la couleur de votre
choix, simplement en éliminant les autres couleurs. Nous utilisons la fonction grey2rgb() du
module color qui permet de créer une image en mode RGB à partir d’une image en nuances de
gris et ensuite appliquer une couleur de notre choix (dans le script suivant nous utiliserons la
couleur rouge et violète). Voici comment procéder :
Syntaxe:
python
color_image = color.grey2rgb( grey_image )
Red = [1, 0, 0]
Violet = [1, 0, 1]
io.imshow(Red * color_image)
io.show()
io.imshow(Violet * color_image)
io.show()
2.4. Détection des bords
Pour détecter les bords dans une image, vous pouvez utiliser la fonction canny() du
module feature qui implémente le détecteur de bords Canny qui permet de prendre l'image en
nuances de gris et une autre valeur (sigma) en paramètres. Le script suivant implémente le
détecteur de bords Canny avec sigma = 3 et affiche le résultat :
Syntaxe:
python
165
from skimage import feature

edges_image = feature.canny( grey_image, sigma = 3)
io.imshow( edges_image )
io.show()
Le traitement d’images joue un rôle essentiel dans la détection des objets. Comme vous pouvez le
voir, la partie de l'image qui contient des objets a été pointillée grâce à la détection des bords.
2.5. Segmentation
Le but de la segmentation des images est d'étiqueter chaque pixel d'une image avec une classe
correspondante. Il y a plusieurs façons de faire cela, la plus simple consiste à segmenter l’image
en deux régions (premier plan et arrière plan). Cela revient à convertir l'image en nuances de gris,
et fixer un seuil. Les pixels dont la valeur est supérieure au seuil sont traités comme appartenant à
la première région, et les autres pixels (inferieur au seuil) à la deuxième région. Pour réaliser une
segmentation binaire avec un seuil = 180, le script est le suivant :
Syntaxe:
python
seuil = 180
binary_image = grey_image*255 > seuil
io.imshow( binary_image )
io.show()
166
Comme vous pouvez le voir, dans l’image résultante, deux régions ont été établies : la région
noire (valeur de pixel 0) et la région blanche (valeur de pixel 255).
Le module filters du la bibliothèque skimage contient plusieurs algorithmes qui permettent de

choisir le seuil de la segmentation. Dans un premier temps, appelons tous les algorithmes de
seuillage en utilisant la fonction try_all_threshold. Leur application sur notre image de test
génère plusieurs images segmentées :
Syntaxe:
python
from skimage import filters
filters.try_all_threshold( grey_image )
io.show()
Nous pouvons aussi utiliser un seul algorithme à la fois. Dans le script suivant, nous utilisons la
fonction threshold_minimum() du module filters pour générer le seuil de la segmentation :
Syntaxe:
python
seuil = filters.threshold_minimum( grey_image )
binary_image = grey_image > seuil
io.show()
167
2.6. Les filtres
Le filtrage constitue un volet important en traitement d'images. Dans cette partie, nous allons
générer des filtres à partir du module filters, créer des images filtrées et comparer les
histogrammes des deux images (originale et filtrée).
Syntaxe:
python
median_image = filters.median( image )
io.imshow( median_image )
io.show()
Syntaxe:
python
# import matplotlib.pyplot as plt
# from skimage.exposure import histogram
hist1 = histogram( image[ : , : , (i)] )
hist2 = histogram( median_image[ : , : , (i)] )
axs[i].plot( hist1[0], label = 'image originale' )
axs[i].plot( hist2[0], label = 'filre median' )
if i == 0:
168
axs[i].legend()
Syntaxe:
python
gaussian_image = filters.gaussian( image )
io.imshow( gaussian_image )
io.show()
Syntaxe:
python

hist1 = histogram( image[ : , : , (i)] )
hist2 = histogram( gaussian_image[ : , : , (i)] )
axs[i].plot( hist1[0], label = 'image originale')
axs[i].plot( hist2[0], label = 'filre gaussian')
if i == 0:
axs[i].legend()
169
3. Exercices
3.1. Exercice 1
Dans cet exercice nous utilisons l’image coins du module data :
Syntaxe:
python
image_coins = data.coins()
io.imshow( image_coins )
io.show()
Question : Tracez un contour sur toutes les pièces et affichez l’image. Vous pouvez utiliser la
fonction mark_boundaries du module segmentation.
3.2. Exercice 2
Dans cet exercice nous utilisons l’image logo du module data :
Syntaxe:
python
image_logo = data.logo()
170
io.imshow( image_logo )
io.show()
Question 1: Transformez l’image en nuance de gris.
Question 2: Générez une nouvelle image qui ne contient que le serpent (segmentation).
Question 3: Générez une image monochrome de couleur jaune à partir de l’image précédente.

4.1. Exercice 1
Syntaxe:
python
from skimage import feature
from skimage import segmentation
image_coins = data.coins()
image_edges = feature.canny(image_coins, sigma = 4)
image = segmentation.mark_boundaries(image_coins, image_edges)
io.imshow(image)
io.show()
171
4.2. Exercice 2
Question 1:
Syntaxe:
python
from skimage import color
image_logo = data.logo()
grey_image = color.rgb2grey( image_logo )
io.imshow( grey_image )
io.show()
Question 2:
Syntaxe:
python
from ipywidgets import interact
def Seg(seuil):
binary_image = grey_image*255 > seuil
io.show()
interact(Seg, seuil = (0,255,1))
172
Question 3:
Syntaxe:
python
binary_image = grey_image*255 > 160

binary_image = binary_image*255
color_image = color.grey2rgb(binary_image)
Jaune = [1, 1, 0]
io.imshow(Jaune * color_image)
io.show()
Conclusion
Nous sommes arrivés à la fin de ce tutoriel. J’espère qu’il vous sera utile pour vous initier au
traitement d’images avec la bibliothèque Scikit Image. Cependant, il existe d'innombrables
applications de Scikit Imagedans le traitement d’images et de nombreuses fonctions plus
avancées qui, combinées à d'autres bibliothèques comme NumPy et OpenCV, donneraient des
résultats étonnants. Ceci dit, il y a encore des notions à apprendre. Merci d’avoir lu et bon
courage pour la suite.
173
Tuto Python & Keras : Les réseaux de

neurones
Publié le 08 Décembre 2020 par Imane BENHMIDOU

 Tutoriel Python: prétraitement des données numériques
 Tuto Python : notion de scope et nommage des variables
Formation sur les réseaux locaux

174
Cours Python pour les administrateurs systèmes et réseaux
Cours réseaux informatiques Couche Liaison
Cours réseaux informatiques Couche physique

175
Cours Reseaux & Packet Tracer 3
Cours sur les bases de Python

176
Support pour apprendre à travailler avec les réseaux informatiques
Table des matières

Introduction
1. Définition
2. Pourquoi on n’utilisera pas Scikit-learn ?
3. Keras
3.1. Prétraitement des données
3.2. Construction du modèle d’apprentissage profond
3.3. Compilation du modèle
3.4. Entrainement du modèle
3.5. Prévision
3.6. Evaluation du modèle
5. Exercices
6. Correction
Conclusion
177
Introduction
Dans le présent tutoriel nous nous intéresserons à un sous domaine de l’apprentissage
automatique qui est l’apprentissage profond (deep learning). Celui-ci présente des algorithmes
inspirés de la structure du cerveau humain souvent appelé réseaux de neurones artificiels (en
anglais, Artificial Neural Networks ANN). Le deep learning est un domaine de tendance, qui a
fait preuve de résultats étonnants en robotique, en reconnaissance d’images et en intelligence
artificielle.
1. Définition
Le cerveau humain est l’inspiration derrière les réseaux de neurones artificiels, puisqu’il est
composé d’un certain nombre de neurones et il est ainsi capable d’effectuer des calculs
complexes. Le réseau en lui-même est un puissant outil de modélisation. Nous exposerons dans
ce qui suit les éléments les plus importants à maîtriser dans ce sujet.
Nous commençons dans un premier temps par une définition du perceptron qui est le plus simple
réseau de neurones. Sa simplicité revient à sa forme qui est constituée d’un seul neurone.
Similaire aux neurones biologiques, qui ont des dendrites et des axones, le neurone artificiel
unique est une structure en arbre qui a des nœuds d’entrée et un seul nœud de sortie, connecté à
chaque nœud d’entrée.
Voici une représentation visuelle de ceci :
Alors un neurone artificiel est composé de :

178
- Nœuds d’entrée : chaque nœud d’entrée est associé à une valeur numérique qui peut être un
nombre réel quelconque (positif, négatif, entier ou décimal).
- Connexion : chaque connexion qui part d’un nœud d’entrée est associée à un poids, qui peut
être n’importe quel nombre réel.
- Somme pondérée : les valeurs des nœuds d’entrée et les connexions sont rassemblées dans la
formule suivante : , autrement dit .
- Fonction d’activation ou de transfert : c’est le résultat de la somme précédente. Dans le cas

simple on a la fonction d’identité, où qui revient à dire , dans ce cas x est la
somme pondérée des nœuds d’entrée et des connexions.
Tout comme un neurone biologique qui ne s’allume que lorsqu’un seuil est dépassé, un neurone
artificiel ne s’allume que lorsque la somme des entrées dépasse un seuil. Ceci n’est pas réalisable
à travers une fonction d’identité, ce qui pousse à concevoir le système suivant :
 si x < 0 ;
 si x = 0 ;
 si x > 0.
Alors il s’agit d’une fonction discontinue et dans le but d’obtenir une fonction continue, on utilise
la fonction sigmoïde.
- Nœud de sortie : associé à la fonction de la somme pondérée des nœuds d’entrée.
- On peut avoir un paramètre supplémentaire qui est le biais, c’est le poids associé à un nœud
d’entrée supplémentaire dont la valeur est fixée à 1. Cette valeur du biais est essentielle car elle
permet de déplacer la fonction d’activation vers la gauche ou la droite pour déterminer le succès
de l’apprentissage.
On peut remarquer que le perceptron ne fonctionnera qu’avec des données numériques. Alors
évidemment il faut convertir toutes les données nominales en format numérique avant d’utiliser
ce modèle d’apprentissage.
Pour des fins de classification, le modèle perceptron accepte que toute sortie supérieure à un
certain seuil indique qu’une instance appartient à une certaine classe, tandis qu’une sortie
inférieure au seuil déterminera que l’entrée appartient à une autre classe. Ainsi, la limite entre les
deux classes est déterminée par la sortie qui est égale au seuil.
Maintenant qu’on a vu le perceptron, on passe aux perceptrons multicouches. Ces derniers sont
les réseaux de perceptron, ils sont plus compliqués que le perceptron parce qu’ils sont constitués
de plusieurs neurones organisés en couches. En pratique, le nombre de couches est généralement
limité à deux ou trois, mais en théorie il n’y a pas de limite. Ces couches agissent de la même
manière que les neurones biologiques où les sorties d’une couche servent d’entrées pour la
179
couche suivante. Alors, on distingue une couche d’entrée, des couches cachées (Dropout) et une
couche de sortie.
Les types de couches pour les modèles d’apprentissage profond sont nombreux. On retrouve,
d’une part, les CNN qui sont les réseaux de neurones convolutifs ou à convolution (en anglais,
Convolutional Neural Networks) et qui classifient les images ou font de la détection d’objets.
D’autre part, il y a les RNN qui sont les réseaux de neurones récurrents (en anglais, Recurrent
Neural Networks) et qui sont utilisés dans le traitement du langage naturel et la reconnaissance
vocale.
2. Pourquoi on n’utilisera pas Scikit-learn ?

La bibliothèque Sckit-learn n’est pas adaptée aux réseaux de neurones vu que son interface ne
permet pas la construction de réseaux de neurones complexes, ni de contrôler les détails de
fonctionnement de ces réseaux. Ainsi cette bibliothèque n’est pas adaptée au deep learning.
3. Keras
Keras est l’une des bibliothèques Python les plus puissantes et les plus faciles à utiliser pour les
modèles d’apprentissage profond et qui permet l’utilisation des réseaux de neurones de manière
simple. Keras englobe les bibliothèques de calcul numérique Theano et TensorFlow. Pour définir
un modèle de deep learning, on définit les caractéristiques suivantes :
 Nombre de couches ;
 Types des couches ;
 Nombre de neurones dans chaque couche;
 Fonctions d’activation de chaque couche ;
 Taille des entrées et des sorties.
Le type de couches qu’on va utiliser est le type dense. Les couches denses sont les plus
populaires car il s’agit d’une couche de réseau neuronal ordinaire où chacun de ses neurones est
connecté aux neurones de la couche précédente et de la couche suivante.
Comme mentionné précédemment, il existe plusieurs types de fonctions d’activation, chacune

d’entre elles relie l’entrée et le poids du neurone d’une manière différente ce qui influe sur le
comportement du réseau. Les fonctions les plus utilisées sont la fonction Unité Linéaire Rectifiée
(ReLU en anglais, Rectified Linear Unit), la fonction Sigmoïde et la fonction linéaire.
Pour ce qui est du nombre de neurones dans la couche d’entrée il est le même que le nombre de
caractéristiques de l’ensemble de données. Dans la suite de ce tutoriel, nous allons essayer de
construire un modèle d’apprentissage profond.
3.1. Prétraitement des données

180
Tout d’abord, nous devons nettoyer l’ensemble des données que nous utiliserons pour le modèle
d’apprentissage.
On importe les bibliothèques nécessaires, à savoir : matplotlib, numpy, pandas, seaborn et

tensorflow.
 Code :
python
from matplotlib import ticker
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
On importe ensuite l’ensemble des données sur lequel on va travailler sous forme de data-frame.
 Code :
python
#import de la dataset
df = pd.read_csv('C:/Users/LENOVO/Desktop/coursGratuit/AmesHousing.csv')
df.head()
181
On affiche dans la partie du code suivante le nombre de valeurs manquantes pour chaque colonne
de notre ensemble de données ainsi que le pourcentage de celles-ci.
 Code :
python
#Valeurs manquantes
VM = pd.DataFrame({
'Colonne': df.columns.values,
'nbr de VM': df.isna().sum().values,
'% de VM': 100 * df.isna().sum().values / len(df),})
VM = VM[VM['nbr de VM'] > 0]
print(VM.sort_values(by='nbr de VM', ascending=False).reset_index(drop=True))
182
On supprime les colonnes contenant un pourcentage élevé de valeurs manquantes.
 Code :
python
#suppression des colonnes contenant un pourcentage élevé de VM
df.drop(['Pool QC', 'Misc Feature', 'Alley', 'Fence', 'Fireplace Qu'],
axis = 1, inplace = True)
Dans le code suivant on affiche les variables catégorielles et les variables numériques de la
dataset afin de pouvoir traiter les valeurs manquantes qui restent dans la dataset.
 Code :
183
python
#on affiche les variables catégorielles et les variables numériques
colonnes_avec_VM = df.columns[df.isna().sum() > 0]
for col in colonnes_avec_VM :
print(col)
print(df[col].unique()[:5])
print('*'*30)
On remplace ensuite les valeurs manquantes numériques d’une colonne par la moyenne de celles-
ci.
 Code :
python
#on remplace les VM numériques par la moyenne de la colonne
num_VM = ['Lot Frontage', 'Mas Vnr Area', 'BsmtFin SF 1', 'BsmtFin SF 2',
184
'Bsmt Unf SF', 'Total Bsmt SF', 'Bsmt Full Bath',

'Bsmt Half Bath', 'Garage Yr Blt', 'Garage Cars', 'Garage Area']
for n_col in num_VM:
df[n_col] = df[n_col].fillna(df[n_col].mean())
On remplace également les valeurs manquantes catégorielles d’une colonne par le mode de
celles-ci.
 Code :
python
#On remplace les VM nominales par le mode variable
nom_VM = [x for x in colonnes_avec_VM if x not in num_VM]
for nom_col in nom_VM:
df[nom_col] = df[nom_col].fillna(df[nom_col].mode().to_numpy()[0])
Pour appliquer un modèle de deep learning, l’ensemble de données ne doit contenir que des
variables numériques. Alors, on va encoder les variables catégorielles. Dans un premier temps, on
affiche le type de données de chaque colonne de la dataset.
 Code :
python
#encodage des variables catégorielles
#on affiche tout d'abord les types de données pour chaque colonne
types = pd.DataFrame({
'Colonne': df.select_dtypes(exclude='object').columns.values,
'Type': df.select_dtypes(exclude='object').dtypes.values})
print(types)
185
Même si Pandas ne considère pas les données de la colonne MS SubClass étant nominaux, le
descriptif de la dataset en dit autrement. Il arrive des fois que Pandas retourne incorrectement le
type d’une colonne.
Alors, on va sélectionner des variables qui représenteront notre dataset (pour ne pas avoir
beaucoup de colonnes après l’encodage des valeurs catégorielles ce qui pourrait impliquer le sur-
apprentissage du modèle) puis on transforme ces données catégorielles en utilisant la
fonction get_dummies() de la bibliothèque pandas.
 Code :
python
#encodage des variables catégorielles,
#selon le descriptif de la dataset la colonne MS SubClass est nominale,
#Pandas a du mal à retourner son vrai type
df['MS SubClass'] = df['MS SubClass'].astype(str)
selection_de_variables = ['MS SubClass', 'MS Zoning', 'Lot Frontage', 'Lot
Area',
186
'Neighborhood', 'Overall Qual', 'Overall Cond',

'Year Built', 'Total Bsmt SF', '1st Flr SF', '2nd Flr SF',
'Gr Liv Area', 'Full Bath', 'Half Bath', 'Bedroom AbvGr',
'Kitchen AbvGr', 'TotRms AbvGrd', 'Garage Area',
'Pool Area', 'SalePrice']
df = df[selection_de_variables]
#la dataset comprendera maintenant que 67 variables
df = pd.get_dummies(df)
Maintenant on fractionne l’ensemble de données en des données d’entrainement et des données

de test.
 Code :
python
#fractionner dataset en des données de test et de train
train = df.sample(frac = 0.8, random_state = 9)
test = df.drop(train.index)
#variable cible
train_cible = train.pop('SalePrice')
test_cible = test.pop('SalePrice')
On standardise ensuite les variables afin de les avoir sur la même échelle.
187
 Code :
python
#Standardisation
variables_pred = train.columns
for col in variables_pred:
col_moyenne = train[col].mean()
col_ecart_type = train[col].std()
if col_ecart_type == 0:
col_ecart_type = 1e-20
train[col] = (train[col] - col_moyenne) / col_ecart_type
test[col] = (test[col] - col_moyenne) / col_ecart_type
3.2. Construction du modèle d’apprentissage profond
Maintenant que les données sont prétraitées, nous allons commencer à construire notre modèle.
On crée une instance du Sequential() de la bibliothèque Keras, celle-ci superpose un ensemble de

couches pour en créer un seul modèle. On lui passe en paramètre une liste de couches qu’on
souhaite utiliser pour notre modèle.
Comme vous allez le remarquer dans ce modèle, on a créé plusieurs couches denses et une seule
couche de type Dropout. La première couche est la couche d’entrée, son nombre de neurones est
égal au nombre de caractéristiques de l’ensemble de données.
Dans chaque couche on retrouve 64 neurones, ce nombre est le résultat optimal de plusieurs tests.
En effet, 64 neurones par couches pour l’exemple de cet ensemble de données donnent un résultat
assez précis.
Remarque :
Il est recommandé d’essayer plusieurs chiffres jusqu’à l’obtention de résultats précis.

188
Pour la couche Dropout, on a diminué de 30% le nombre des données d’entrée afin d’éviter le
phénomène du overfitting. La graine prend une valeur de 2 pour avoir des résultats plus
reproductibles.
Finalement, la dernière couche dense avec un seul neurone est la couche de sortie. Par défaut, elle
prend la fonction d’activation linéaire.
 Code :
python
modele = keras.Sequential([
layers.Dense(64, activation = 'relu', input_shape = [train.shape[1]]),
layers.Dropout(0.3, seed = 2),
layers.Dense(64, activation = 'swish'),
layers.Dense(64, activation = 'relu'),
layers.Dense(1)])
3.3. Compilation du modèle
L’étape suivante est la compilation du modèle. Pour ce faire, il faut choisir :
 La fonction de perte : utilisée pour diminuer l’erreur. Plus l’erreur est faible plus le modèle est
précis ;
 L’optimiseur : aide à obtenir de meilleurs résultats pour la fonction de perte ;
 Métriques : utilisées pour évaluer le modèle.
Dans le code suivant nous avons utilisé la fonction de perte comme étant l’erreur quadratique
moyenne avec l’optimiseur RMSprop qu’on lui donne un taux d’apprentissage de 0,001. Et pour
la métrique nous avons utilisé l’erreur absolue moyenne qui va avec la fonction de perte.
 Code :
189
python
optimiseur = tf.keras.optimizers.RMSprop(learning_rate = 0.001)

modele.compile(loss = tf.keras.losses.MeanSquaredError(),
optimizer = optimiseur,
metrics = ['mae'])
3.4. Entrainement du modèle
Dans ce qui suit, on entraine le modèle sur le jeu de données train. Celui-ci passe 70 fois sur
l’ensemble de données pour en tirer le meilleur résultat possible. Ensuite, 20% des données
d’entrainement sont utilisées pour la validation.
La fonction fit() affiche la valeur de la fonction de perte et la métrique pour chaque époque.
 Code :
python
training = modele.fit (train, train_cible, epochs = 70, validation_split = 0.2)
190
3.5. Prévision
Avant de commencer d’utiliser le modèle pour nos prévisions, nous allons illustrer comment la
fonction de perte et la mae vont changer. Remarquons que ces valeurs ont diminué au fil du
temps, alors le modèle est devenu plus précis.
 Code :
python
historique = pd.DataFrame(training.history)
historique['epoque'] = training.epoch
figure, axe = plt.subplots(figsize = (14,8))
num_epoque = historique.shape[0]
axe.plot(np.arange(0, num_epoque), historique["mae"],
label = "Training MAE", lw = 3, color = 'red')
axe.plot(np.arange(0, num_epoque), historique["val_mae"],
label = "Validation MAE", lw = 3, color = 'blue')
axe.legend ()
plt.tight_layout()
plt.show()
191
On prend une unité des valeurs de test pour avoir sa prédiction en utilisant notre modèle. Ensuite,
on affiche la valeur de la prédiction et la valeur actuelle pour les comparer.
 Code :
python
test1 = test.iloc[[10]]
test_prediction = modele.predict(test1).squeeze()
test_label = test_cible.iloc[10]
print("Prédiction du modèle = {:.2f}".format(test_prediction))
print("Valeur actuelle = {:.2f}".format(test_label))
192
3.6. Évaluation du modèle
L’étape finale dans ce tutoriel est l’évaluation du modèle qu’on a créé.
 Code :
python
score = modele.evaluate( test, test_cible, verbose = 0)

print(score)
Le deep learning est utilisé dans différents domaines de la vie réelle, notamment :
 Reconnaissance d’image ;
 Traduction automatique ;
 Diagnostic médical ;
 Prédiction financière ;
 Détection de fraudes ;
 Chatbots ;
 Robots intelligents.
5. Exercices
Exercice 1 :
1. Reprenez la même dataset utilisée dans ce tutoriel.

2. Créez un modèle d’apprentissage profond qui utilise l’optimiseur ‘Adam’.
3. Modifiez dans les étapes précédemment suivies pour obtenir de meilleurs résultats.
193

Exercice 1 :
Nous avons dans cet exemple suivi les mêmes étapes de ce tutoriel pour construire un modèle
d’apprentissage profond, on a juste apporté quelques modifications aux fonctions d’activation de
chaque couche et on a changé l’optimiseur.
La première étape est de créer une instance du Sequential() de la bibliothèque Keras, celle-ci
superpose un ensemble de couches pour en créer un seul modèle. On lui passe en paramètres une
liste de couches qu’on souhaite utiliser pour notre modèle.
Puis la deuxième étape est de compiler le modèle. Pour ce faire, nous avons utilisé la fonction de
perte comme étant l’erreur quadratique moyenne avec l’optimiseur Adam avec un taux
d’apprentissage de 0,001. Et pour la métrique, nous avons utilisé l’erreur absolue moyenne qui va
avec la fonction de perte.
 Code :
python
modele2 = keras.Sequential([
layers.Dense(64, activation = 'swish', input_shape = [train.shape[1]]),
layers.Dropout(0.3, seed = 2),
layers.Dense(1)])
optimiseur = tf.keras.optimizers.Adam(learning_rate=0.001)
modele2.compile(loss = tf.keras.losses.MeanSquaredError(),
optimizer = optimiseur,
metrics = ['mae'])
194
La troisième étape est d’entrainer le modèle sur le jeu de données train. Celui-ci passe 70 fois sur
l’ensemble de données pour en tirer le meilleur résultat possible. Ensuite, 20% des données
d’entrainement sont utilisées pour la validation.
La fonction fit() affiche la valeur de la fonction de perte et la métrique pour chaque époque.
 Code :
python
training = modele2.fit (train, train_cible, epochs = 70, validation_split =

0.2)
195
Cette étape est facultative, mais elle nous permet d’illustrer comment la fonction de perte et
la mae vont changer. Remarquons que ces valeurs ont diminué au fil du temps, alors le modèle
est devenu plus précis.
 Code :
python
historique = pd.DataFrame(training.history)
historique ['epoque'] = training.epoch
figure, axe = plt.subplots(figsize = (14,8))
num_epoque = historique.shape[0]
axe.plot(np.arange(0, num_epoque), historique["mae"],
label = "Training MAE", lw = 3, color = 'red')
axe.plot(np.arange(0, num_epoque), historique["val_mae"],
label = "Validation MAE", lw = 3, color = 'blue')
axe.legend ()
plt.tight_layout ()
plt.show ()
196
L’avant dernière étape est celle du test, on prend une unité des valeurs de test pour avoir sa
prédiction en utilisant notre modèle. Ensuite, on affiche la valeur de la prédiction et la valeur
actuelle pour les comparer.
 Code :
python
test1 = test.iloc[[10]]
test_prediction = modele2.predict(test1).squeeze()
test_label = test_cible.iloc[10]
print("Prédiction du modèle = {:.2f}".format(test_prediction))
print("Valeur actuelle = {:.2f}".format(test_label))
197
Finalement, on évalue le modèle en utilisant la méthode evaluate().
 Code :
python
score = modele2.evaluate (test, test_cible, verbose = 0)

print(score)
Conclusion
Dans le présent tutoriel, nous avons vu les différents éléments de base à savoir pour s’initier à
l’apprentissage profond. Nous avons ensuite prétraité un ensemble de données, puis construit un
modèle d’apprentissage profond en utilisant Keras pour compiler le modèle par la suite et
l’ajuster afin qu’il soit convenable à notre ensemble de données. Finalement, on a fait de
prédictions en se basant sur ce que le modèle a développé en terme d’apprentissage.
Tutoriel Python: prétraitement des données

numériques
198
 Tuto Python & pandas : installation et manipulations de base

 Tutoriel Python : créer un histogramme
 Tutoriel python : la bibliothèque Ipywidgets
 Tutoriel Python : manipuler les types de variables
 Tutoriel Python & Numpy : les types de données
 Tutoriel Python : manipuler les chaines de caractère
Tutoriel accelerometer Arduino enjeux et pratique

199
Complete and detailed course pandas for everyone: python data analysis
Tutoriel Base de Données et langage SQL
Cours de Matlab Introduction aux méthodes numériques

200
Tutoriel d’apprentissage du Framework Python Pygame pour débutant
Formation avancé sur le Scrapping web en Python avec Scrapy
Cours Python : les fonctions, les modules, les classes et les exceptions
Table des matières

201
Introduction
1. Importation des bibliothèques

2. Importation de la dataset
3. Vérification des valeurs manquantes
4. Vérification des valeurs catégorielles
5. Fractionnement de l’ensemble de données
6. Mise à l’échelle des caractéristiques
7. Exercices
7.1. Exercice 1
8.1. Exercice 1
Conclusion
Introduction
Le prétraitement des données est une technique d’exploitation de données brutes qui consiste à
transformer ces dernières en un format compréhensible. Sachant que les données du monde réel
sont dans la plupart des cas incomplètes, incohérentes ou dépourvues de certaines tendances, le
prétraitement de celles-ci est une méthode certaine pour résoudre ces problèmes ainsi que de
nombreuses erreurs susceptibles d’exister dans ces données.
Des données incomplètes c’est à dire qu’elles manquent de valeurs d’attributs, d’attributs
intéressants ou ne contiennent que des données agrégées. Ainsi, avoir des données bruyantes est
équivalent à dire que ces données contiennent des erreurs ou des valeurs aberrantes. Enfin, les
données incohérentes sont des données contenant des divergences dans les codes ou les noms.
Le prétraitement des données pour l’apprentissage automatique consiste à suivre les étapes
suivantes :
 Étape 1 : Importation des bibliothèques ;

 Étape 2 : Importation de la dataset en question ;
 Étape 3 : Vérification des valeurs manquantes ;
 Étape 4 : Vérification des valeurs catégorielles ;
 Étape 5 : Fractionnement de l’ensemble de données ;
 Étape 6 : Mise à l’échelle des caractéristiques.
1. Importation des bibliothèques

Les bibliothèques fondamentales dont on aura besoin sont les suivantes :
 Code :
202
python
import numpy as np
import pandas as pd
NumPy (Numerical Python) est la première bibliothèque à connaitre si vous utilisez Python pour
des domaines qui touchent aux mathématiques. Elle est une extension fondamentale de Python
qui permet de faire du calcul scientifique en Python. Cette bibliothèque contient :
 L’objet de type tableau à N dimension ;

 Des fonctions sophistiquées ;
 Des outils pour l’intégration du code C/C++ et Fortran ;
 Des utilités d’algèbre linéaire, de transformée de Fourier et de nombres aléatoires.
Pandas est une bibliothèque open source, sous licence BSD, de Python qui permet la
manipulation et l’analyse des données à travers des DataFrames qui correspondent à des matrices
d’individus qui représentent des observations (lignes) et de variables qui sont des attributs
décrivant les individus (colonnes). À partir de ces DataFrames, on peut facilement tracer des
graphes à l’aide de la bibliothèque matplotlib.
2. Importation de la dataset
En utilisant la bibliothèque Pandas, on importe la dataset qui est dans l’exemple ci-après sous
format CSV. Il n’est pas toujours le cas que ça soit sous ce format, il se peut que l’ensemble de
données soit un fichier html, Excel ou Xlsx.
Remarque :
L’utilisation des fichiers de type CSV est dû à leur faible poids.
Exemple 1 :
Nous importons en DataFrame l’ensemble de données « food-consumption » qui est une dataset
relative à la consommation de certains produits alimentaires dans les pays européens et
scandinaves, les chiffres représentent le pourcentage de la population qui consomme ce type
d’aliment.
Et on affiche les cinq premiers enregistrements de cette dataset en utilisant la fonction head(),
afin de vérifier rapidement si l’objet contient le bon type de donnée.
 Code :
203
python
df = pd.read_csv ('C:/Users/LENOVO/Desktop/coursGratuit/food-consumption.csv')
df.head()
3. Vérification des valeurs manquantes

Les valeurs manquantes en statistique sont relatives au cas lorsqu’une variable donnée n’a pas
d’observations pour un certain individu. Lors de l’analyse statistique, les valeurs manquantes ne
peuvent pas être ignorées. Cependant, si ces données ne sont pas traitées correctement, le
chercheur peut tirer des conclusions inexactes sur les données.
Exemple 2 :
Nous affichons ci-dessous le nombre de valeurs manquantes pour chaque colonne de l’ensemble
de données.
 Code :
python
df.isnull().sum()
 Résultat de l’exécution
204
Nous nous intéresserons lors de ce tutoriel à deux méthodes jugées les plus importantes pour
résoudre le problème des valeurs manquantes :
 La première méthode consiste à : soit supprimer une ligne particulière contenant une valeur
manquante pour une caractéristique donnée, soit supprimer toute une colonne si elle comporte
plus de 75% de valeurs manquantes. Cette méthode est recommandée lorsqu’il y a suffisamment
d’échantillons dans la dataset. Il faut s’assurer que la suppression de données n’impactera pas
les résultats finaux.
 La deuxième méthode s’applique aux éléments contenant les données numériques où les valeurs
manquantes peuvent être remplacées par la moyenne, la médiane ou le mode de l’élément en
question. Cette méthode donne un meilleur résultat comparant à la première méthode parce
qu’il s’agit d’une approximation statistique qui peut ajouter de la variance à l’ensemble de
données. On peut aussi approximer avec l’écart des valeurs voisines si les données sont linéaires.
Exemple 3 :
Méthode 1 :
On retourne les dimensions du dataframe df à l’aide de l’attribut de pandas shape.
 Code :
python
df.shape
205
À l’aide de la fonction dropna(), on supprime toutes les valeurs manquantes de notre ensemble
de données. Ensuite, en faisant appel aux deux fonctions isnull() et sum(), on retourne la somme
des valeurs manquantes pour chaque colonne et qui est 0 partout !
Finalement, on affiche la dimension de la dataframe qui est différente de la première, car on vient
de supprimer les valeurs manquantes de chaque colonne.
 Code :
python
#méthode 1
df.dropna( inplace = True)
df.isnull().sum()
Méthode 2 :
206
Dans ce qui suit, on calcule la moyenne de la colonne « Biscuits », on affiche cette colonne pour
comparer ses valeurs après avoir modifié la valeur manquante par la moyenne des valeurs de la
colonne « Biscuits ».
 Code :
python
#méthode 2
df['Biscuits'].mean()
print( df['Biscuits'])
df['Biscuits'].replace( np.NaN, df ['Biscuits'].mean())
207
Jusqu’à présent, nous avons vu comment traiter des données numériques, l’étape suivante se
focalisera sur les données catégorielles.
4. Vérification des valeurs catégorielles

Les modèles d’apprentissage automatique se basent sur des équations mathématiques, alors
intuitivement la présence de données catégorielles entrainera un problème car on ne peut garder
que des nombres dans les équations. Alorsn ces données catégorielles doivent être codées en
données numériques.
Exemple 4 :
208
Prenons la dataset « iris », le type de l’iris est une donnée catégorielle :
 Code :
python
import numpy as np
import pandas as pd
df = pd.read_csv('C:/Users/LENOVO/Desktop/coursGratuit/iris_dataset.csv')
df.head()
Pour convertir les données de la colonne « flower » en données numériques, on peut faire appel à
la classe LabelEncoder() de la bibliothèque preprocessing.
Après avoir créé une instance de cette classe, on l’ajuste à l’aide de fit_transform() à la colonne
« flower » pour qu’elle revoie celle-ci sous format encodée.
 Code :
python
y = df.iloc[ : , 4: ].values
print(y)
from sklearn.preprocessing import LabelEncoder
Label_encoder = LabelEncoder()
y = Label_encoder.fit_transform(y)
print(y)
209
Maintenant que les données catégorielles sont encodées, un problème se présente : puisque 0<1 et
1<2, les équations des modèles d’apprentissage penseront que « Iris-setosa » a une valeur moins
élevée que « Iris-versicolor » et que « Iris-versicolor » a une valeur moins élevée que « Iris-
verginica », alors que ce n’est pas le cas, ce sont trois différentes catégories qu’elles n’ont pas
d’ordre relationnel entre eux.
Alors, pour éviter cela, nous utiliserons les Dummies Variables qui sont des variables qui
prennent la valeur 0 pour indiquer l’absence d’un effet catégorique pouvant modifier le résultat et
1 pour sa présence.
Exemple 5 :
Nous continuons avec l’exemple de la dataset « iris ». Alors dans ce cas au lieu d’avoir une
colonne, nous allons avoir trois.
Méthode 1 :
Pour créer les dummies variables nous ferons appel à la classe OneHotEncoder de la
bibliothèque preprocessing.
210
 Code :
python
from sklearn.preprocessing import OneHotEncoder
Onehotencoder = OneHotEncoder( categories = 'auto')
y = Onehotencoder.fit_transform(y)
Méthode 2 :
Cette deuxième méthode de création des dummies variables consiste à faire appel à la
fonction get_dummies() de la bibliothèque Pandas.
 Code :
python
dummy = pd.get_dummies (df ['flower'])
dummy
211
Maintenant, il ne reste plus qu’à concaténer les deux tableaux et de supprimer la colonne
« flower »:
 Code :
python
df = pd.concat( [df, dummy ], axis = 1)
df.drop( ['flower'], axis = 1)
5. Fractionnement de l’ensemble de données

Pour tous les modèles d’apprentissage automatique, qu’ils soient supervisés ou non supervisés,
nous allons fractionner l’ensemble de données en deux :
 Un ensemble de données d’entrainement : Training.

 Un ensemble de données de test.
En général, on divise l’ensemble de données en un rapport 75/25% ou 80/20%, qui signifie que
75% des données sont des données de training et 25% pour les tests. Toutefois, ces répartitions
peuvent varier en fonction de la forme et de la taille de la dataset.
Exemple 6 :
On utilise la fonction train_test_split pour fractionner l’ensemble des données en données de

train et de test qui sont par défaut à 75/25 %.
212
 Code :
python
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 0)
6. Mise à l’échelle des caractéristiques

La mise à l’échelle ou la standardisation des caractéristiques est la méthode qui permet de limiter
la différence de fourchette des variables pour qu’elles puissent être comparées sur des bases
communes.
Exemple 7 :
Voici l’exemple d’un dataset, les variables « Salaire » et « Age » n’ont pas la même échelle ce
qui engendrera des problèmes dans les modèles d’apprentissage automatique.
 Code :
python
import numpy as np
import pandas as pd
df = pd.read_excel ('C:/Users/LENOVO/Desktop/coursGratuit/achat.xlsx')
df.head()
213
Si on prend deux valeurs de ces deux colonnes et on utilise la distance euclidienne, la colonne
Salaire sera dominée par celle-ci.
Remarque :
Dans certains cas, les modèles d’apprentissage automatique ne sont pas basés sur la distance
euclidienne, mais la mise à l’échelle des caractéristiques permettra à l’algorithme de converger
plus rapidement. C’est le cas du modèle d’arbre de décision.
Dans le code suivant, on fait appel à la classe StandardScaler qui permet de standardiser les
variables. On crée une instance de celle-ci puis on l’entraine sur notre ensemble de données grâce
à la méthodefit_transform().
Résultat : toutes les valeurs sont à la même échelle.
 Code :
python
x = df[['Age', 'Salaire']]
mise_a_echelle = StandardScaler()
x = mise_a_echelle.fit_transform(x)
print(x)
Le code suivant permet de transformer le tableau contenant les valeurs standardisées des deux
variables Salaire et Age en un dataframe, pour ensuite le concaténer avec les données de la
dataset. Puis on supprime les deux anciennes colonnes en question.
 Code :
214
python
dfx = pd.DataFrame(data = x, columns = ['Age2', 'Salaire2'])
df = pd.concat( [df, dfx ], axis = 1)
df = df.drop( ['Age', 'Salaire'], axis = 1)
print(df)
7. Exercices
7.1. Exercice 1
Appliquez les différentes étapes du prétraitement à la dataset suivante :

8.1. Exercice 1
Cet exercice est une application directe des étapes vues précédemment dans ce tutoriel.
 Code :
python
import numpy as np
import pandas as pd
#import des données
df = pd.read_csv ('C:/Users/LENOVO/Desktop/coursGratuit/pokemon.csv')
#affichage des 5 premiers enregistrements
df.head ()
215
On affiche les informations relatives à la dataset en utilisant la fonction suivante :
 Code :
python
df.info ()
216
Pour savoir la somme des valeurs manquantes on procède ainsi :
 Code :
python
df.isnull ().sum ()
217
Encodage de la colonne Type_1 en dummies variables.
 Code :
python
Df ['Type_1'].unique ()
dummy = pd.get_dummies ( df ['Type_1'])
dummy
218
Finalement, on standardise les valeurs des colonnes suivantes : Total, HP, Attack, Defense,
Height_m, Weight_kg.
 Code :
python
x = df[['Total', 'HP', 'Attack', 'Defense', 'Height_m', 'Weight_kg']]
mise_a_echelle = StandardScaler ()
x = mise_a_echelle.fit_transform(x)
print(x)
219
Conclusion
Lors de ce tutoriel, nous avons prêté attention à la préparation des données avant l’application des
modèles d’apprentissage automatique. C’est une étape très importante, car elle permet d’éliminer
plusieurs problèmes et c’est lors de laquelle qu’une grande partie de la véracité des résultats est
établie.
Tuto Python : notion de scope et nommage

des variables
Publié le 24 Octobre 2020 par Mouna HAMIM
 Tutoriel Python: créer et utiliser des fonctions

 Tutoriel Python : manipuler les types de variables
 Tutoriel Python & SciPy : notion d’interpolation
 Exercice portée d'une variable
 Tuto Python : Trouver les valeurs max et min d'une liste
 Tuto Python & Mahotas : traitement d'images
220
Detailed course on the fundamentals of python first programs
Introduction to the Python language: installation, variables, functions and operations
Les bases de Python : les Variables, les boucles et les conditions

221
Python language course: types, variables, functions and operations
Tutoriel Python : variables, fonctions, Boucles et opérateurs
Débuter et progresser avec la programmation PYTHON

222
Cours sur les bases de Python
Advanced python programming tutorial with examples: functions
Table des matières
Introduction
Notion de Scope
 Définition
 Noms et Scopes en Python
 Scope globale
 Scope local
Nommage des variables
 Le Mot-Clé Global
223
 Mot clé nonlocal
Règle LEGB pour les scopes en Python
Accéder à une variable à partir de scope
 Méthode 1 : locals ()
 Méthode 2 : globals()
Exercices
 Exercice 1
 Exercice 2
Conclusion
Introduction :
Bonjour et Bienvenue dans un nouveau tutoriel Python ! Aujourd’hui, nous sommes de retour
avec de nouvelles connaissances. La notion qu’on verra aujourd’hui est celle des scopes en
Python. C’est une notion très intéressante qui permet de comprendre le fonctionnement des
variables au sein d’un programme.
Ce cours sera très riche en exemples et exercices afin de mettre en pratique les notions acquises
durant ce tutoriel.
Vous devez avoir des connaissances basiques en Python comme les classes ou les fonctions. Si ce
n’est pas fait, je vous invite à jeter un coup d’œil aux tutoriels précédents.
À la fin de ce tutoriel vous apprendrez ce que sont les scopes en Python et leur fonctionnement,
l’importance de cette notion en programmation, la règle LEGB et finalement comment modifier
le comportement des scopes.
Voila ! Nous pensons que tout est dit ! Commençons notre voyage.
Notion de Scope:
Définition :
Le terme Scope en Python réfère à la portée d’une variable au sein d’un programme, c’est une
autre manière de dire si la variable est accessible ou non dans un bloc de code .
Le plus souvent, vous distinguerez deux types de Scope générales :

224
 Scope globale : Les noms que vous définissez dans cette portée sont disponibles pour tout votre
code.
 Scope locale : Les noms que vous définissez dans cette portée ne sont disponibles ou visibles que
pour le code de la portée.
Les noms dans vos programmes auront la portée du bloc de code dans lequel vous les
définissez. Quand vous pouvez accéder au nom d’une variable à partir d’un endroit de votre code,
vous direz que le variable est à la portée. Si vous ne pouvez pas accéder au nom, alors vous allez
dire que le nom est hors de la portée.
Noms et Scopes en Python :
Python est un langage à typage dynamique, les variables sont effectifs dès que vous leur attribuez
une valeur pour la première fois. Par ailleurs, la même chose pour les classes et fonctions
lorsqu’on les définis en utilisant def ou class . Enfin, les modules existent après leur
importation. En résumé, vous pouvez créer des noms Python via l’une des opérations suivantes :
Opérations Syntaxe
Affectation x = valeur
from module import nom ou
Opérations d’import
import module
Définition des fonctions def ma_fonction()
Définitions des arguments dans le contexte des fonctions def ma_fonction (arg1, arg2,…., argN)
Définition des classes class MaClasse :
Toutes ces opérations créent ou, dans le cas d’affectations, mettent à jour de nouveaux noms
Python parce qu’ils attribuent tous un nom à une variable, constante, fonction, classe, instance,
module ou autre objet Python.
Par exemple, si vous assignez une valeur à un nom à l’intérieur d’une fonction, alors ce nom aura
une portée Python locale. En revanche, si vous assignez une valeur à un nom en dehors de toutes
les fonctions, au niveau supérieur d’un module , alors ce nom aura une portée globale en Python .
Scope globale
Les variables globales sont celles qui sont définies et déclarées en dehors de toute fonction et ne
sont spécifiées à aucune fonction. Ils peuvent être utilisés par n’importe quelle partie du
programme.
Exemple :
Dans cet exemple, la fonction f utilise la variable globale s
Syntaxe :
225
python
# Cette fonction utilise la variable globale s
def f():
print(s)
# scope global
s = "J'aime Python"
f()
Exemple :
Dans cet exemple on définit une variable globale a que nous allons utiliser pour plusieurs
fonctions .
Syntaxe :
python
a=3
def fonction1(x):
return x + a
def fonction2 (x):
return x - a
def fonction3 (x,y):
return x - a*y
print (fonction1(3))
print (fonction2(3))
print (fonction3(3,2))
226
L’exécution montre bien que la variable a est reconnue et utilisée par les trois fonctions car elle a
été définie globalement.
Exemple : calcul des poids
Ici , on veut définir g=9.887 comme variable globale de pesanteur afin de pouvoir calculer le
poids des individus en fonction de leurs masses.
Syntaxe :
python
g=9.887
def calcul_poids(m):
return m*g
print (calcul_poids(75))
227
Scope local
Par défaut, les paramètres et les noms que vous assignez à l’intérieur d’une fonction n’existent
que dans la fonction ou le périmètre local associé à l’appel de fonction. L’exemple suivant vous
montre que les variables définies à l’intérieur ne sont pas accessibles.
Exemple :
Fonction qui calcule le cube d’un nombre.
Syntaxe :
python
def cube(a):
... resultat1= a ** 3
... print (f'le cube de {a} est: {resultat}')
cube(3)
print (resultat1)
228
Exemple :
Dans cet exemple, on veut définir une variable local salaire_brut qui ne sera accesible qu’à
l’intérieur de la fonction.
Syntaxe :
python
def salaire_net ():

salaire_brut=10000
salaire_net =salaire_brut - ((salaire_brut*40)/100)
return salaire_net
229
Et voilà ! Comme prévu le programme ne connait pas la variable salaire_brut.
Exemple : fonction à l’intérieur d’une fonction
Dans cet exemple, on veut définir une fonction mafonc() qui affiche le message contenu dans la
variable x . Cependant , c’est la fonction mafoncinterne() qui doit faire le travail . Donc , on va
la définir puis l’appeler à l’intérieur de notre fonction de base .
Syntaxe :
python
def mafonc():
x = 'Bonjour ! Bienvenue dans ce nouveau tutoriel ! '
def mafoncinterne ():
print(x)
mafoncinterne ()
mafonc()
mafoncinterne()
La fonction mafoncinterne () n’est pas accessible en dehors de la fonction principale où elle a

été définie .
Nommage des variables :

230
Si vous opérez avec le même nom de variable à l’intérieur et à l’extérieur d’une fonction, Python
les traitera comme deux variables distinctes, une disponible dans la portée globale (en dehors de
la fonction ) et une disponible dans la portée locale (à l’intérieur de la fonction ) .
Exemple :
La fonction va afficher la variable locale et le code la variable globale .
Syntaxe :
python
x = 30
def mafonc ():
x = 20
print(x)
mafonc()
print(x)
Le Mot-Clé Global :
Imaginons que vous voulez créer ou modifier une variable globale au sein d’une scope locale.
Que faire ? Heureusement, le mot-clé global permet de rendre cette variable globale .
Exemple :
Syntaxe :
231
python
def mafonct ():

global x
x = 300
mafonct()
print(x)
Et voilà , la variable est accessible même en dehors de la fonction !
Vous pouvez aussi utiliser le mot-clé global si vous voulez faire un changement à une variable
globale dans une fonction .
Exemple :
Dans cet exemple , on veut modifier la valeur d’une variable globale x mais de l’intérieur de la
fonction en utilisant le mot global .
Syntaxe :
python
x = 300
def mafonct ():
global x
x = 200
mafonct ()
print(x)
232
Effectivement, L’exécution retourne 200 car la valeur de x a été modifiée.
Exemple :
Dans cet exemple, on va modifier la valeur de la variable t .
Syntaxe :
python
# Cette fonction modifie la variable globale ‘t’
def f():
global t
print(t)
t = "Ce tutoriel est très instruisant ! "
print(t)
# Global Scope
t = "Python es intéressant!"
f()
print(t)
233
Exemple :
Voici un exemple complet pour bien comprendre la portée d’une variable dans un programme et
comment on peut la modifier.
Syntaxe :
python
# Programme Python pour comprendre la scope d'une variable
var = 2
# Cette fonction utilise la 'var' global car il n'ya pas de 'var' local
def f():
print (" à l'intérieur de f() : ", var)
# la variable 'var' est redéfinie autant que locale Variable 'a'
def g():
var = 3
print ("a l'intérieur de g() : ", var)
# On utilise le mot clé global pour modifier 'var'
def h():
global var
var = 4
print ("à l'intérieur de h() : ", var)
# Global scope
print ('global : ', var)
f ()
g ()
234
h ()
Mot clé nonlocal :
En Python, le mot-clé nonlocal est utilisé dans le cas de fonctions imbriquées. Ce mot-
clé fonctionne comme le global, mais plutôt que global, ce mot-clé déclare une variable pour
pointer vers la variable de la fonction d’enclenchement externe, dans le cas de
fonctions imbriquées.
Voici un exemple pour bien comprendre cette notion .
Exemple :
Nous voulons tester ce que retourne le programme si on utilise le mot-clé nonlocal sur une
variable.
Syntaxe :
python
235
# Programme Python pour démontrer l'intérêt du mot-clé nonlocal

print ("Valeur de a en utilisant non locale est : ", end ="")
def externe():
var = 6
def interne():
nonlocal var
var = 11
interne()
print (var)
externe()
print ("Valeur de a sans utiliser non locale est : ", end="")
def externe():
var = 6
def interne():
var = 11
interne()
print (var)
externe()
Le concept de scope détermine comment les variables et les noms sont recherchés dans votre
code. Il détermine la visibilité d’une variable dans le code. La portée d’un nom ou d’une variable
dépend de l’endroit dans votre code où vous créez cette variable. Le concept de portée Python est
généralement présenté en utilisant une règle connue sous le nom de règle LEGB. Nous allons
voir cette règle en détail dans la section qui suit.
Règle LEGB pour les scopes en Python :

En Python, la règle LEGB est utilisée pour décider de l’ordre dans lequel les espaces de noms
doivent être recherchés pour la résolution de Scope.
Les Scopes sont listés en termes d’hiérarchie selon l’ordre suivant :

236
 Local (L) : Définies à l’intérieur d’une fonction ou classe.

 Enclosed (E) : Fonctions d’enclenchement définies à l’intérieur (concept de fonction imbriquée)
 Global (G) : Défini au niveau le plus élevé .
 Built-in (B) : Noms réservés dans les modules intégrés Python.
La règle LEGB est une sorte de procédure de recherche de noms, qui détermine l’ordre dans
lequel Python recherche les noms. Par exemple, si vous référencez un nom donné, alors Python
cherchera ce nom séquentiellement dans la portée locale, englobant, globale et intégrée. Si le nom
existe, alors vous obtiendrez la première occurrence de celui-ci. Sinon, vous obtiendrez une
erreur.
Accéder à une variable à partir de scope :

Dans cette section, nous allons voir comment accéder à une variable dans un code en utilisant
deux méthodes différentes :
Méthode 1 : locals ()
C’est une fonction qui stocke les valeurs de toutes les variables dans le périmètre local de la
fonction si dans une fonction ou du périmètre global si à l’extérieur.
Exemple :
Syntaxe :
python
237
# initialisation de la variable
var = "Python est le meilleur"
# On affiche la variable originale
print ("la variable originale est : " +
var
)
# Accès à la valeur variable du périmètre de code
# utilisation de locals()
resultat= locals()['var']
# Affichage du résultat
print ("Variable résultante après l'utilisation de locals() : " + resultat)
Méthode 2 : globals()
C’est encore une autre fonction qui maintient un dictionnaire de variables de portée globale.
Exemple :
Voici un exemple qui démontre l’utilisation de la méthode globals() .
Syntaxe :
python
# initialisation de la variable
var = "Python est le meilleur"
# On affiche la variable originale
print ("la variable originale est : " +
var)
# Accessing variable value from code scope
# using globals
238
resultat = globals()['var']
# printing result
print (" la Variable résultante après l'utilisation de globals(): " +var)
Nous allons passer à quelques exercices d’applications pour être sûr que vous avez bien compris !
Exercices :
Exercice 1 :
Ecrivez une fonction Plus6() qui ajoute 6 à chaque paramètre en entrée de la fonction . La
variable 6 doit être globale et x locale.
Solution :
Synyaxe :
python
def plus6(x):
global num
num=6
res=num+x
return x
plus6(10)
239
Exercice 2 :
Essayez de deviner la sortie de ce programme !
Syntaxe :
python
# Programme Python pour comprendre la scope d'une variable
var = 20
# Cette fonction utilise la 'var' global car il n'ya pas de 'var' local
def f ():
print (" à l'intérieur de f () : ", var)
# la variable 'var' est redéfinie autant que locale Variable 'a'
def g ():
var = 30
print ("a l'intérieur de g() : ", var)
# On utilise le mot clé global pour modifier 'var'
def h():
global var
var = 40
print ("à l'intérieur de h() : ", var)
# Global scope
f ()
g ()
h ()
240
Conclusion :
Voila ! Nous sommes arrivés à la fin de ce tutoriel. Nous supposons que vous avez parfaitement
compris la notion de scope et que vous savez maintenant gérer vos variables au sein d’un
programme. En tout cas, plusieurs autres notions aussi intéressantes que celle d’aujourd’hui vous
attendent. Ne lâchez rien ! Continuez sur ce chemin. À un très prochain tutoriel !

Intro Machine Learning

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

Intro Machine Learning

Transféré par

Droits d'auteur :

Formats disponibles

1

Introduction au Machine Learning

Recevoir le livre gratuit

Définition du Machine Learning

Comment fonctionne le Machine Learning ?

 L’Apprentissage Supervisé (Supervised Learning)

Apprentissage Supervisé : Définition

Les problèmes de Régression

 le prix d’un appartement

Représentation d’un problème de régression

Les problèmes de Classification

 Email Spam / non Spam

Représentation d’un problème de classification

Note : La reconnaissance vocale et la vision par ordinateur correspondent à des problèmes de

Apprentissage Non-Supervisé : pas de variable y

Dans l’apprentissage non-supervisé, on dispose ainsi d’un Dataset sans variable , et la

Apprentissage par Renforcement : apprendre dans son

Conclusion : Le Machine Learning est la nouvelle électricité,

Le machine Learning a déjà commencé à changer la face de notre monde. Il révolutionne

Machine Learning : les 9 types d’algorithmes

Les algorithmes d’apprentissage supervisé

La popularité de la régression linéaire s’explique par sa simplicité. L’algorithme est facilement

Machine à vecteurs de support (SVM)

Un algorithme d’arbre de décision représente graphiquement les données en branches pour

Les algorithmes d’apprentissage non supervisé

Les algorithmes Apriori

La répartition en K-moyennes (K-means)

Les algorithmes d’apprentissage semi-supervisé

Les méthodes d’apprentissage semi-supervisé combinent données étiquetées et non étiquetées.

Réseaux antagonistes génératifs

Classificateur bayésien naïf

Apprentissage par renforcement

Algorithme basé sur un modèle (model-based)

Apprentissage supervisé : définition et

En machine learning, l'apprentissage supervisé consiste à entrainer un modèle à partir de données

 Apprentissage supervisé : définition

L’apprentissage supervisé, c'est quoi ?

Quelles sont les applications de l'apprentissage supervisé ?

 le traitement automatique du langage,

Quels sont les algorithmes d’apprentissage supervisé ?

Quelle différence entre apprentissage supervisé et non

Tuto Python & Scikit-learn : la régression

Publié le 24 Novembre 2020 par Imane BENHMIDOU

 Tuto Python & Scikit-learn : les arbres de décision

Support de cours sur la statistique econometrie

Travaux dirigees sur l’hydrologie statistique

Best course to learn programming using python from A to Z

Programming technique workbook learn to write a python script

La statistique regression support de cours

Advanced tutorial to learn how to create python scripts

Manuel sur la statistique regression

Table des matières

2.1. Régression linéaire simple

2.2. Régression linéaire multiple

6. Solution des exercices

 et sont les paramètres du modèle ;

2.1. Régression linéaire simple

Tout d’abord, on importe le package NumPy et la classe LinearRegression. Ensuite, on définit

2.1.1. Paramètres du modèle LinearRegression

Le modèle LinearRegression peut prendre plusieurs paramètres optionnels, à savoir :

2.1.2. Les attributs du modèle LinearRegression

Les attributs du modèle LinearRegression simple sont :

 intercept_ : qui permet de calculer le paramètre .

La seule différence entre la prévision ci-dessous et la prévision obtenue à l’aide de la