L’INTELLIGENCE

ARTIFICIELLE
&
PYTHON

KASSID Asmaa
DÉFINITON DE L’IA
Intelligence Artificielle : Le concept de l'intelligence artificielle
(IA) est de faire penser les machines « comme des humains » ;
en d'autres termes, effectuer des tâches telles que raisonner,
planifier, apprendre et comprendre notre langage.

Par exemple

une IA prédira la météo (un algorithme prendra

en compte les vents, les nuages, etc… pour
donner en résultat la probabilité qu’il fasse
beau).

Dira si l’image est celle d’un chat (un autre

algorithme regardera les pixels dans l’image,
fera des calculs dessus, et en fonction des
résultats déduira s’il a affaire à un chat ou non),
etc…
 POURQUOI
L'IA EST-ELLE UN SUJET AUSSI BRÛLANT E
N CE MOMENT ?

De nombreuses innovations se sont alignées pour permettre de grandes

avancées pour l'IA.
 La puissance de calcul aujourd'hui est un billion de fois plus importante
qu'il y a 60 ans
 Le coût du traitement de données est devenu plus abordable
 Un plus grand nombre de données doit être analysé, car les entreprises
captent plus d'informations de la part des interactions client
 L'IA a déjà grandement amélioré les applications grand public : les
consommateurs s'attendent désormais à ce que les entreprises s'améliorent
de la même façon dans toutes leurs expériences
 EST-CE QUE J'UTILISE DÉJÀ L'IA ?

un ordinateur, un smartphone ou tout autre objet connecté utilise déjà l'IA pour
se faciliter la vie :
 Facebook suggère des identifications dans les photos à l'aide de la
reconnaissance d'image
 Amazon recommande des produits en utilisant des algorithmes
d'apprentissage automatique
 Waze suggère des itinéraires en utilisant une combinaison de modèles
prédictifs, de prévisions de circulation et de techniques d'optimisation
L’APPRENTISSAGE AUTOMATIQUE : MACHINE
LEARNING
 L'apprentissage automatique (machine learning) est le moteur principal de l'IA. Son
concept : les ordinateurs tirent des leçons des données avec un minimum de
programmation.

SOUS-BRANCHE DE L’IA
 le machine learning est un ensemble de méthodes statistiques appliquées à l’IA.
Elles permettent en particulier à l’IA d’apprendre à partir de données d’exemple.
on montre à l’IA plein d’appartements avec leur prix, puis elle peut deviner le prix
d’un nouvel appartement).

ML = IA + STATS
L’APPRENTISSAGE PROFOND: DEEP LEARNING
SOUS-BRANCHE DU ML
 le Deep learning repose principalement sur l’utilisation de réseaux de
neurones (on se rapproche donc de la neuroscience plutôt que des
statistiques) pour résoudre les problèmes.
 Le principe reste identique, avoir des données d’exemples et adapter son
modèle interne pour qu’il prédise correctement ses sorties.
 l’IA va grouper des données en fonction de leur similarité pour former
Par exemple
des groupes
*la reconnaissance faciale et classification d’images
*la génération de texte
*la prédiction de pannes complexes, un robot qui va découvrir tout
seul comment marcher, etc…).

DL = ML + RÉSEAUX DE NEURONES
HISTORIQUE

(IA) telle que définie dans (ML) est l’application de (PL) S’inspirer de comment
l’industrie est plutôt « des méthodes statistiques aux marche notre cerveau (avec
algorithmes plus ou moins algorithmes pour les rendre plus des réseaux de neurones) pour
évolués qui imitent des actions intelligents. pousser l’analyse plus loin et
humaines ». Il repose donc sur la capacité des savoir extraire les données soi-
algorithmes à recevoir beaucoup même !
de données et à « apprendre »
d’elles .
L’ÉVOLUTION DE LA RECHERCHE

En effet, l'IA a végété plusieurs années à plusieurs reprises notamment dans les
années 1970 et 1990 ; car elle a été longtemps limitée par les coûts et
performances des machines:
-vitesse,
-capacité mémoire,
-capacité de stockage

Aujourd'hui les
superordinateurs et le cloud
ont aboli ces limites et nous
assistons à une explosion de
ses possibilités qui semblent
inarrêtables.
DOMAINE D’APPLICATION DE L’IA
Des disciplines extrêmement compliquées et coûteuses comme la reconnaissance
vocale, la reconnaissance visuelle/faciale, autrefois réservées à des industriels et
l'armée, sont devenues des éléments de notre quotidien.

Reconnaissance d'amis dans les albums photos ou via les

moteurs de recherche
Reconnaissance vocale (lors d'un appel téléphonique), pour
dicter un SMS à votre smartphone ou encore pour -reconnaître une
chanson à la radio (applications Shazam, SoundHound, ...)
Pilotage automatique de nos automobiles
L'APPRENTISSAGE AUTOMATIQUE: DÉFINITION

Apprentissage statistique :

Est un des domaines de l'intelligence artificielle visant à permettre à un

ordinateur d'apprendre des connaissances puis de les appliquer pour
réaliser des tâches que nous sous-traitions jusque là à notre
raisonnement.
L'APPRENTISSAGE AUTOMATIQUE:
TACHE
Le type de tâches traitées consiste généralement en des
problèmes de classification de données:

 Voici 50 photos de ma fille, voici maintenant toutes les

photos de mon album, retrouve celles ou se trouve ma
fille
 Voici 10000 personnes avec leurs caractéristiques (âge,
localisation, taille, profession...), rassemble-les en 12
groupes cohérents partageant les mêmes points communs
 Voici des mesures scientifiques réalisées sur un
échantillon de données, elles semblent répondre à une loi
Mathématique, essaye de l'approximer par des fonctions
Mathématiques puis prédit les valeurs des prochaines
données
L'APPRENTISSAGE AUTOMATIQUE: TYPES

Parmi les types d'apprentissages, les plus

répandus :

Supervisé Non supervisé

vous allez récupérer des données dites annotées de les données d'entrées ne sont pas annotées.
leurs sorties pour entraîner le modèle, c'est-à-dire l'algorithme d'entraînement s'applique dans
que vous leur avez déjà associé un label ou ce cas à trouver seul les similarités et
une classe cible et vous voulez que l'algorithme distinctions au sein de ces données, et à
devienne capable, une fois entraîné, de prédire regrouper ensemble celles qui partagent des
cette cible sur de nouvelles données non annotées. caractéristiques communes.

Mathématiquement

on reçoit des données d'exemple annotées: on reçoit uniquement des observations brutes de
variables aléatoires :
(x1,y1),(x2,y2),(x3,y3),...et on espère prédire la sortie
x1,x2,x3,x4,... et on espère découvrir la
sur de nouvelles observations : x∗→y∗
relation avec des variables latentes
structurelles : xi→yi
APPRENTISSAGE SUPERVISÉ: FONCTIONNEMENT

La machine apprend à partir de milliers

d’exemples d’associations .
x y
APPRENTISSAGE SUPERVISÉ: APPLICATION
 Avec le Supervised Learning on peut développer des modèles pour résoudre
2 types de problèmes

Les problèmes de Classification Les problèmes de Régression

 APPRENTISSAGE SUPERVISÉ: FONCTIONNEMENT

1.Le Dataset constitue le matériel qui sert à l’apprentissage.

2.Le Modèle est le cœur de notre programme. C’est lui qui effectue les prédictions
.
Au début, les paramètres du modèle sont toujours choisis au hasard.
3.La Fonction Coût évalue la performance du modèle en calculant les erreurs entre les
prédictions du modèle et les valeur attendue dans le Dataset.
4.l’Algorithme d’apprentissage est un algorithme de minimisation de la Fonction Coût:
Il cherche quels sont les meilleurs paramètres du modèle,
ceux qui donneront la meilleure performance, c’est-à-dire les plus petites erreurs
(Fonction Coût).
La Descente de Gradient est l’algorithme itératif le plus connu pour entraîner un
modèle de Machine Learning

DATA PHASE D’ENTRAINEMENT

APPRENTISSAGE SUPERVISÉ: FONCTIONNEMENT

Le Dataset : les exemples de ce qu’il faut apprendre

La première étape d’un algorithme de Supervised Learning consiste donc à importer un Dataset qui
contient les exemples que la machine doit étudier.

Ce Dataset inclut toujours 2 types de

variables :

Features
Target

Une variable objectif Une ou plusieurs variables

caractéristiques
LE DATASET

m= nombre d’exemples
n=nombre de facteurs

Pour désigner une cellule de notre tableau

Exemple

X Facteurs
 1/ LE DATASET

Désigner la qualité du 3ième appartement que vous avez visité, on écrit ……..????

Avec un tel Dataset, il devient possible de prédire de nouvelles valeurs y à partir de valeurs de x en

développant un modèle
2/ LE MODÈLE
 un modèle est une représentation simplifiée de la réalité, que l’on peut
utiliser pour prédire ce qui se passerait dans certaines conditions. Ça
peut être un dessin, une équation physique, une fonction mathématique,
une courbe…
 il est construit à partir de données, comme un modèle statistique.
 Si par exemple votre Dataset vous donne le nuage de point suivant, alors
la machine devra trouver le modèle qui rentre le mieux dans ce nuage de
point.
2/ LE MODÈLE
 C’est nous qui décide quel modèle(fonction) choisira la
machine et c’est à la machine de trouver
les coefficients de cette fonction qui donnent les
meilleurs résultats

comment faire pour que la machine

apprenne?
 3/LA FONCTION COÛT : MESURE DE LA
PERFORMANCE
 C’est l’ensemble des erreurs que le modèle prédit dans le dataset (résultat
se base sur une généralisation des points dans le dataset)

On compte en général 2 familles de problèmes

• Les problèmes de Classification, qui consiste

• Les problèmes de régression, qui consiste à
à prédire la valeur d’une variable discrète :
prédire la valeur d’une variable continue :

• Est-ce que l’email est un spam ? • Prix de l’immobilier

• Est-ce-que ce logiciel est un malware ? • Valeur d’une action boursière
• Est-ce que la radio montre une fracture ? • Température qu’il fera demain ou dans 10 ans
• Est-ce que les analyses médicales montrent un • Somme du panier achat client
cancer ? • Consommation électrique d’une usine
• Quel animal est sur la photo ? Chien ? Chat ? • Position du bras d’un robot en automatique
Renard ?
LA FONCTION COÛT : MESURE DE LA
PERFORMANCE

Classification Régression

FC=Nombre d’erreurs sur le FC=la distance entre votre flèche et le centre de la cible,
nombre d’exemples
qui n’est autre que le point qu’elle est sensée atteindre.
L’ALGORITHME D’APPRENTISSAGE
Phase de l’apprentissage:
c’est lorsque la machine cherche les paramètres de modèle qui
minimisent la Fonction Coût.

Il existe un paquet de stratégies

Une stratégie, très populaire en Machine

Learning, est de considérer la Fonction Coût
comme une fonction convexe
une fonction qui n’a qu’un seul minimum, et
de chercher ce minimum avec un algorithme de
minimisation appelé Gradient Descent.
L’ALGORITHME D’APPRENTISSAGE:
GRADIENT DESCENT

La Descente de Gradient est un algorithme d’optimisation qui

permet de trouver le minimum de n’importe quelle
fonction convexe en convergeant progressivement vers celui-ci.
L’ALGORITHME D’APPRENTISSAGE: GRADIENT
DESCENT

Exemple

f(x) = x² - x + 1 ; à minimiser par rapport à f() est la fonction à minimiser

x x joue le rôle de paramètre ici c.-à-d. on
min 𝑓 ( 𝑥 ) = 𝑥 2 − 𝑥 + 1 recherche la valeur de x qui minimise f()
𝑥

25

20 La solution analytique passe par :

15
𝑓′ 𝑥 = 0
10

En s’assurant que 𝑓 ′ ′ 𝑥 > 0

5

0
-5 -4 -3 -2 -1 0 1 2 3 4 5 1
𝑓 ′ 𝑥 = 2𝑥 − 1 = 0 ⇒ 𝑥∗ =
2

26
 L’ALGORITHME D’APPRENTISSAGE: GRADIENT DESCENT
Parfoisla résolution analytique n’est pas possible, parce que le nombre de
paramètres est élevé par exemple, ou parce que le calcul serait trop
coûteux  approximation avec une approche itérative.

Algorithme du GRADIENT

Etape 1:Initialiser avec x0 (au hasard)

Répéter
Etape 2:mesurer la valeur de la pente en ce point
calculer la dérivée de la fonction coût

Etape 3:progresser ensuite d’une certaine distance

dans la direction de la pente qui descend (Learning
Rate=vitesse d’apprentissage)
Jusqu’à convergence
PARLANT MATHÉMATIQUEMENT
1/ modèle de régression linéaire
Le Dataset d’une Régression Linéaire simple (x,y)

Notre nuage de point, on dirait clairement qu’il suit

une tendance linéaire

Valeur de a???

Valeur b????
Impossible de tracer une bonne droite sur le nuage de point,
à moins de choisir des paramètres au hasard.
L’ALGORITHME GRADIENT
DESCENT : L’IMPLÉMENTATION

 Fonction coût: mesure l’erreur entre . les variables a et b qui

sont aléatoires avec la vraie valeur Y (dataset)calcule la
différence entre ce que prédit l’ordinateur et le prix exacte

Éviter l’erreur négative

 .

L’ALGORITHME GRADIENT
DESCENT : L’IMPLÉMENTATION
 Soit J la fonction coût = la moyenne de toutes nos
erreurs

Par convention

En remplace f(x) par son expression

L’ALGORITHME GRADIENT
DESCENT : L’IMPLÉMENTATION

Une fonction convexe

 L’ALGORITHME GRADIENT
DESCENT : L’IMPLÉMENTATION
Lorsque l’algorithme commence au tour i=0 nous pouvons calculer la position a1 en appliquant la formule :

POSITIVE

Se situe a gauche du minimum Se situe a droite du minimum

<0 >0

a1<a0
a1>a0

se déplace vers la gauche

Se déplacer vers la droite.
L’ALGORITHME GRADIENT
DESCENT : L’IMPLÉMENTATION
 Répéter jusqu’à minimisation de la fonction coût:

GRADIENT
 C’est le taux d’apprentissage de la machine
: L’HYPER-PARAMÈTRE
LEARNING RATE

 Un paramètre de réglage dans un algorithme d'optimisation qui détermine la taille du pas à chaque
itération tout en se déplaçant vers un minimum d'une fonction de perte.

objectif objectif objectif

*Risque de mettre un temps infini *Descendre rapidement vers le
avant de converger vers le *Un bon Learning Rate se situe souvent aux minimum de la fonction coût.
minimum de la fonction cout alentours des . *Risque de louper ce minimum en
oscillant autour à l’infini
RÉSUMÉ DES ÉQUATIONS
 MATRICE EN ML
Comment utiliser les données du DATASET ???
DEFINITION :
Une matrice, c’est un tableau de nombre qui effectue des opérations sur des paquets de
nombres, qui, en général, ont tous un lien en commun les uns avec les autres.

AVANTAGES:

1/En Machine Learning on va justement se servir des matrices pour manipuler d’une seule fois toutes
les données de notre Dataset.

2/ calculer les prédictions du Modèle l’erreur de la Fonction Coût et les Gradients sur tout le Dataset,
plutôt que point par point.

3/accélérer les temps de calcul de l’ordinateur .

 MATRICE EN ML: RÉGLES
Dimension lorsqu’elle a lignes et colonnes.(m x n)

NB Il faut vérifier les dimensions de vos matrices (éviter

l’erreur)

La transposée: Soit A (3x2) (2x3)

NB: Les deux matrices doivent toutes deux avoir

Addition et soustractions les mêmes dimensions.

Produit NB: Il faut que le nombre de colonnes dans A soit égal au

nombre de lignes dans B .

Calculer l’élément (ligne 1, colonne 1),

on combine la ligne 1 de A avec la colonne 1 de B

Calculer l’élément (ligne 1, colonne 2),

on combine la ligne 1 de A avec la colonne 2 de B
POURQUOI PYTHON DANS L’IA
Python possède plusieurs propriétés qui en font un outil de choix pour l'analyse de
données.

La simplicité Efficacité Interactivité

L'écosystème

Python possède des librairies pour à peu près tout ce que vous pouvez
imaginer pour L’IA, et notamment:

numpy et scipy pour les calculs

Matplotlib et Seaborn pour la visualisation
Scikit-learn pour les algorithmes
Pandas pour les gérer les données (les charger, appliquer des opérations
d'algèbre relationnelle, etc.)
Tensorflow et PyTorch pour le deep learning
 PYTHON DANS L’IA:INSTALLATION
Installation d’Anaconda

Anaconda est une plateforme Python dédiée aux data sciences elle possède les outils de Machine
Learning.
Il s’agit d’une suite logicielle intégrant les modules les plus utilisés.
Anaconda contient tous les outils et librairies dont vous avez besoin pour faire du Machine Learning :
Numpy, Matplotlib, Sklearn, etc.
Elle est téléchargeable à l’adresse https://www.anaconda.com/download
 PYTHON DANS L’IA: INSTALLATION
Une fois Anaconda installé, vous pouvez lancer l’application Jupyter Notebook depuis
votre barre de recherche.

Pourquoi travailler avec un notebook ?

La Data Science est itérative : il faut souvent tenter plusieurs approches et étudier les résultats avant de
décider de la bonne façon de traiter un problème.

Les notebooks, sont parfaitement adaptés à cette particularité.

 Un notebook est une interface web dans laquelle vous pouvez taper du code Python, l'exécuter et voir
directement les résultats, y compris une visualisation à l'aide de graphiques.

ceci déconnecterait Jupyter de

votre disque dur).
 PYTHON DANS L’IA: INSTALLATION

** Si Python est déjà installé, alors vous aurez besoin

d'installer le notebook Jupyter, ainsi que les librairies
suivantes :
*Pandas #python -m pip install --upgrade #pip
*Matplotlib python -m pip install jupyter
*Numpy
*SciPy

** Pour vérifier si l'installation s'est bien

déroulée, tapez dans votre console la #jupyter notebook
commande suivante

#pip install scipy

**Installer uniquement les librairies Python #pip install numpy
#pip install matplotlib
#pip install pandas
 NUMPY

LIMITES DES STRUCTURES NATIFS

>>> lst = [1, 2, 3]
>>> type(lst)
list

"Ajout" d'un entier à une liste d'entiers

>>> lst + 2
---------------------------------------------------------------------------
TypeError Traceback (most recent call last) <ipython-input-2-
33a94180b36b> in <module>() ----> 1 l + 2
TypeError: can only concatenate list (not "int") to list

"Multiplication" d'une liste d'entiers par un entier

>>> lst = [1, 2, 3]

>>> lst * 2 >>> lst = [1, 2, 3]
>>> for i, val in enumerate(lst):
>>> lst[i] = val * 2
>>> print(lst) [2, 4, 6]
NUMPY

 Afin de remédier à cette difficulté. La bibliothèque NumPy a été crée.

Elle est écrite en langage C afin de permettre de haute performances.
 On trouve dans le module NumPy de nombreux outils de manipulation
des tableaux a plusieurs dimensions(ND ARRAY) pour le calcul
numérique.
Pour l’importer, on recommande d’utiliser

>>> import numpy as np

Toutes les fonctions NumPy seront alors

préfixées par np.
NUMPY :NDARRAY

Ndarray est plus rapide(moins de mémoire)

NUMPY: TABLEAUX(ARRAY)

Création
Affichage

Les tableaux peuvent être créés

avec numpy.array()
>>> a
array([[1, 2, 3], [4, 5, 6]])

>>> a = np.array([[1, 2, 3], [4, 5, 6]])

Notion de type
On utilise des crochets pour délimiter les listes d’éléments dans
les tableaux.
>>>> type(a)

* Ajout d'un entier à un array d'entiers: >>> a + 2

* Multiplication d'un array d'entiers par un entier: >>> a * 2

 NUMPY:ARRAY

>>> np.arange(4, 10, 0.5)

>>> np.linspace(4, 10, 5)
>>> np.zeros(5)
>>> np.zeros((2, 4))
>>> np.ones((2, 4))
>>> np.ones((2, 4), dtype=int)
>>> np.diag([1,2,3,4])
>>>np.random.rand(3,4)
>>> a = np.empty((2,
4))
>>> a.full(5)
>>> a = np.array([[1,2,3], [4,5,6]])
>>> a.zise
>>> a
NUMPY:ATTRIBUT SHAPE
Permet de voir la forme du tableau:
--Combien de ligne ?
--Combien de colonne?
--quelle profondeur?

>>> a = np.array([[1,2,3], [4,5,6]])

>>> a
array([[1, 2, 3],
[4, 5, 6]])
>>> a.shape = (3,2)
>>> a.ndim
array([[1, 2],
[3, 4],
[5, 6]])

NOUS DONNE UN TUPLE

 TRACÉ AVEC MATPLOTLIB
Les premiers tracés
Quel est le but d’un graphique ?

 Voir , plutôt qu’imaginer

 pour mieux expliquer un problème
 Pour mieux comprendre un phénomène

°La fonction Plot dans sa forme la plus simple, elle prend en paramètre deux listes numériques ou encore deux
tableaux unidimensionnels numpy , X et Y de même dimension et de la forme : X = [ x1, x2, ..., xn ] et Y =
[ y1, y2, ..., yn ]

°Plot considère alors que les éléments de X et Y sont les abscisses et les ordonnées de n points du plan (Oxy),
de la forme : (x1, y1), (x2, y2), ..., (xn, yn).

°Elle place ces points et les relie par un trait. Voilà, c’est tout ! Bien entendu, les xi et yi doivent avoir le bon
format : il ne peut s’agir que d’entiers ou de nombres réels.

import matplotlib.pyplot as plt

X = [0, 2, 1, 0]
Y = [0, 0, 3, 0]
plt.figure() # début de la figure 5 plt.plot(X, Y) # on trace la
figure
plt.show()
plt.close()
TRACÉ AVEC MATPLOTLIB

 Afficher plusieurs fenêtres graphiques avec des titres

différents et choisis par vous-même, pour bien les identifier.
 Exemple :
# On affiche deux fenêtres graphiques
import matplotlib.pyplot as plt
X = [0, 2, 1, 0]
Y = [0, 0, 3, 0]
Z = [1, 1, 0, 1]
plt.figure("Chantal")
plt.plot(X, Y)
plt.figure("Robert")
plt.plot(X, Z)

help(plt.figure) dans l’interpréteur ou consultez l’aide en ligne.

TRACÉ AVEC MATPLOTLIB
Tracer des courbes

import matplotlib.pyplot as plt

import math as m
import numpy as np linspace(debut, fin, n) / np.arange(debut, fin, pas)
Renvoie un tableau unidimensionnel commençant à début, se terminant
X = np.linspace(0, 2*m.pi, 50) à fin et contenant exactement n éléments.
C’est très efficace pour générer les abscisses.
Y = np.cos(X)
plt.figure("Mon beau cosinus")
plt.plot(X, Y)
 TRACÉ AVEC MATPLOTLIB
La fonction plot peut prendre un troisième paramètre qui gère le style du tracé du dessin, c’est à dire la
couleur et la façon dont les points sont reliés.

_Vous pouvez combiner les différents caractères dans une même chaîne pour préciser le tracé.
_Par exemple "ro-" signifie que la courbe doit être tracée en rouge, avec des gros points reliés
entre eux par des segments de droite .
_Vous pouvez aussi préciser l’épaisseur du trait grâce au paramètre linewidth = numero.
Plus numero est grand, plus le trait est épais.
import numpy as np
import math as m
import matplotlib.pyplot as plt
X = np.linspace(0, 2*m.pi, 50)
Y = np.cos(X) Z = np.sin(X)
W = 0.5*X - 1
plt.figure(1)
plt.plot(X, Y, "ro-" ) # Courbe en rouge avec de gros points reliés par
des segments
plt.plot(X, Z, "g.’) # Courbe en vert avec des points non reliés
plt.plot(X, W, "k’, linewidth=5)
 REDÉFINIR LES AXES
Par défaut, Python choisit les axes à votre place. Vous pouvez cependant
redéfinir leur étendue à l’aide de la fonction axis,
ajouter une grille sur le schéma à l’aide de la fonction grid
ajouter un label à chaque axe grâce aux fonctions xlabel et ylabel.

import numpy as np
import math as m
import matplotlib.pyplot as plt
X = np.linspace(0, 2*m.pi, 50) plt.axis(L),
Y = np.cos(X) L = [xmin, xmax, ymin, ymax]
plt.figure(1)
plt.plot(X, Y, "ro-" )
plt.axis([-0.5, 2*m.pi+0.5, -1.5, 1.5]) plt.grid()
plt.xlabel("temps")
plt.ylabel("Signal")
 AJOUTER DU TEXTE ET UN TITRE

 Pour ajouter un titre, il suffit de taper : plt.title(nom_titre) où nom_titre est une chaine
de caractères qui sera affichée comme le titre de votre graphique.
 Placer du texte dans le dessin se fait grâce à : plt.text(x, y, text, color = ...). text est
une chaîne de caractères qui sera le texte affiché, x et y sont les coordonnées du
premier caractère de tex

PLUSIEURS GRAPHIQUES DANS UNE MÊME

FENÊTRE
o La fonction subplot est là pour gérer çà. Un sous-graphique d’une fenêtre est introduit:
par subplot(lignes, colonnes, numero) où lignes et colonnes sont les nombres totaux de lignes et
de colonnes utilisées pour afficher tous les graphiques de la fenêtre et où numéro désigne le numéro
du graphique qu’on va afficher
PLUSIEURS GRAPHIQUES DANS UNE
MÊME FENÊTRE
import numpy as np
import math as m
import matplotlib.pyplot as plt
X = np.linspace(0, 2*m.pi, 50)
Y = np.cos(X)
Z = np.sin(X)
plt.figure("Fenêtre avec deux graphiques") # début de la fenêtre graphique
plt.subplot(1, 2, 1) # Deux graphiques sur 1 ligne et 2 colonnes. Début du graph. n°1
plt.plot(X, Y, ’r’)
plt.axis([-0.5, 2*m.pi + 0.5, -1.5, 1.5])
plt.title("Un cosinus")
plt.subplot(1, 2, 2) # 2ème graph., 1 ligne et 2 colonnes. Il sera placé sur la colonne 2.
plt.plot(X, Z, ’b.’)
plt.grid()
plt.title("Un sinus")
plt.text(3.5 , 0.5 , "Oscillogramme", color = ’k’)
 RÉGRESSION LINÉAIRE ET PYTHON
 Rappel : La régression linéaire est un algorithme qui va trouver une droite qui se
rapproche le plus possible d’un ensemble de points. Les points représentent les
données d’entraînement (Training Set).
 On va développer un algorithme de descente de gradient pour résoudre un problème
de régression linéaire avec la librairie Numpy

Etape 1: importer les packages Numpy et Matplotlib.pyplot

**Numpy permet de créer

import numpy as np
des matrices et effectuer des
opérations mathématiques. from sklearn.datasets import make_regression
import matplotlib.pyplot as plt

**Matplotlib permet de créer

des graphiques pour observer facilement
notre dataset ainsi que le modèle construit à
partir de celui-ci.

Génération de données aléatoires avec une tendance linéaire

 RÉGRESSION LINÉAIRE ET PYTHON
Etape 2: création d’un DATASET(x,y)

chaque fois que la cellule est exécutée, des données

différentes sont générer. reproduire le même Dataset a
chaque fois.

np.random.seed(0) # pour toujours reproduire le meme dataset

x, y = make_regression(n_samples=100,n_features=1, noise=10)
plt.scatter(x, y) # afficher les résultats. X en abscisse et y
en ordonnée

NB:vérifier les dimensions de x et y. print(x.shape) (100, 1)

(100,)
print(y.shape)

y = y.reshape(y.shape[0], 1)
On remarque que y n'a pas les
print(y.shape) dimensions (100, 1). On corrige le
problème avec np.reshape
 RÉGRESSION LINÉAIRE ET PYTHON
Une fois le dataset généré
*il faut ajouter une colonne de biais au tableau X,
c’est-à-dire un colonne de 1, pour le développement du futur modèle linéaire ,

X = np.hstack((x, np.ones(x.shape)))
print (X.shape)

colle l'un contre l'autre le vecteur x et un vecteur 1 de

dimension égale a celle de x

*Il faut initialiser des paramètres aléatoires a,b dans un vecteur theta qui
nous donne l’erreur la plus petite  qui minimise la fonction coût.

np.random.seed(0) # pour produire toujours le meme vecteur theta aléatoire

theta = np.random.randn(2, 1)
theta
RÉGRESSION LINÉAIRE ET PYTHON
Etape 3: Modèle Linéaire

On implémente un modèle , puis on teste le modèle pour voir s'il n'y a pas de bug
En plus, cela permet de voir a quoi ressemble le modèle initial, défini par la valeur de .

def model(X, theta): plt.scatter(x, y)

return X.dot(theta) plt.plot(x, model(X, theta))

 RÉGRESSION LINÉAIRE ET PYTHON
Etape 4: Fonction Coût
On mesure les erreurs du modèle sur le Dataset X, y
en implémenter l 'erreur quadratique moyenne, .

def cost_function(X, y, theta):

m = len(y)
return 1/(2*m) * np.sum((model(X, theta) - y)**2)

cost_function(X, y, theta)

On teste notre fonction s’il y a pas de bug

RÉGRESSION LINÉAIRE ET PYTHON
Etape 5: implémenter le Gradients et la Descente de
Gradient

le gradient :

def grad(X, y, theta):

m = len(y)
return 1/m * X.T.dot(model(X, theta) - y)

la descente de gradient :

def gradient_descent(X, y, theta, learning_rate, n_iterations):

for i in range(0, n_iterations):
theta = theta - learning_rate * grad(X, y, theta) # mise a jour
du parametre theta (formule du gradient descent)
return theta
RÉGRESSION LINÉAIRE ET PYTHON
Etape 6: Phase d'entrainement du modèle

On définit un nombre d'itérations, ainsi qu'un pas d'apprentissage α

n_iterations = 1000
learning_rate = 0.001
theta_final= gradient_descent(X, y, theta, learning_rate, n_iterations)
Print(theta_final) #affiche la valeur (a,b)

array([[42.61765864], Est-ce que ces paramètres donnent de bonne

[-0.81309274]]) résultat ?????

On va créer d'un vecteur prédictions qui contient les prédictions de notre modele final

predictions = model(X, theta_final)

Notre dataset
plt.scatter(x, y)
plt.plot(x, predictions, c='r')
RÉGRESSION LINÉAIRE ET PYTHON

Phase d'entrainement

**Je diminue le Learning

rate (0,01)ou bien
**j’augmente le nombre
d’itération
RÉGRESSION LINÉAIRE ET PYTHON
Courbes d'apprentissage

Pour vérifier si notre algorithme de Descente de gradient a

bien fonctionné

on observe l'évolution de la
fonction cout a travers les
itérations.

def gradient_descent(X, y, theta, learning_rate, n_iterations):

cost_history = np.zeros(n_iterations) # création d'un tableau de stockage pour enregistrer

l'évolution du Cout du modèle avec une taille le nbre d’itération
for i in range(0, n_iterations):

theta = theta - learning_rate * grad(X, y, theta) # mise a jour du parametre theta (formule du gradient
descent)

cost_history[i] = cost_function(X, y, theta) # on enregistre la valeur du Cout au tour i

dans cost_history[i]
return theta, cost_history
RÉGRESSION LINÉAIRE ET PYTHON
Courbes d'apprentissage

theta_final,cost_history= gradient_descent(X, y, theta,

learning_rate=0,01, n_iterations=1000)

plt.plot(range(n_iterations), cost_history)

A partir l’itération 300 le coût

n’est pas diminuer

Mettre le n_iterations=400

Économisé le
temps et
l’énergie de
la machine
 RÉGRESSION LINÉAIRE ET PYTHON

Evaluer la performance de notre modèle

Pour évaluer la réelle performance de notre modelé on utilise le coefficient de détermination,

*nb:* Plus le résultat est proche de 1, meilleur est votre modèle

def coef_determination(y, pred):

u = ((y - pred)**2).sum()
v = ((y - y.mean())**2).sum()
return 1 - u/v

coef_determination(y, predictions)

0.9512254636609898
 RÉGRESSION LINÉAIRE POLYNOMIALE

 L’intérêt de la régression polynomiale est de pouvoir introduire de la non-

linéarité dans l’analyse prédictive.
 La régression polynomiale permet de trouver une fonction de prédiction adéquate
pour des données qui ne semblent pas avoir une relation linéaire.

C’est Quoi un polynôme?? Un polynôme est la somme de plusieurs

monômes.
Un monôme est une expression de la forme : .
Avec :
• : un nombre réel (ou complexe) appelé le coefficient du monôme.
• x un entier naturel : représentant le degré du monôme.
Exemple :
• est un monôme du second degré et de coefficient 3

• est un monôme de degré 0 et de coefficient 3

 RÉGRESSION LINÉAIRE POLYNOMIALE
Graphiquement

Polynôme du 1er degré Polynôme du 2éme degré

Polynôme du 3éme degré

 RÉGRESSION LINÉAIRE POLYNOMIALE

une fonction de prédiction sous forme de polynôme de degré 2

Polynôme de degré 10 ??
 RÉGRESSION LINÉAIRE POLYNOMIALE

solution
 RÉGRESSION LINÉAIRE POLYNOMIALE
Les mêmes équations de la régression linéaire pour résoudre des problèmes non
linéaire , il faut juste changer le contenu des matrices
 RÉGRESSION LINÉAIRE POLYNOMIALE
Pratique

import numpy as np
from sklearn.datasets import make_regression
import matplotlib.pyplot as plt

Etape 1 et 2

Pour développer un modèle polynomial à partir des équations de la régression linéaire,

il suffit d'ajouter des degrés de polynôme dans les colonnes de la matrice X
ainsi qu'un nombre égal de lignes dans le vecteur theta .

np.random.seed(0)
x, y = make_regression(n_samples=100, n_features=1, noise = 10)
y = y + abs(y/2) # modifie les valeurs de y pour rendre le dataset non-
linéaire
plt.scatter(x, y) # afficher les résultats. x en abscisse et y en ordonnée
)

RÉGRESSION LINÉAIRE POLYNOMIALE

**Vérification des dimensions **Redimensionner y

.
print(x shape) y = y.reshape(y.shape[0], 1)
Print (y.shape)
print (y.shape)

**Création de la matrice X
X = np.hstack((x, np.ones(x.shape)))

X = np.hstack((x**2, X)) # X c est la matrice de régression linéaire on lui ajoute le vecteur x^2 a
la gauche

.
print(X shape)
print(X[:10])

**Initialisation du vecteur theta aléatoire, avec 3 éléments

theta = np.random.randn(3, 1)
theta

Etapes 3 / 4 / 5 seront les même de notre modèle de régression linéaire

 RÉGRESSION LINÉAIRE MULTIPLE VARIABLES

 On va crée un modèle linéaire avec 2 features

np.random.seed(0) # permet de reproduire l'aléatoire

x, y = make_regression(n_samples=100, n_features=2, noise = 10) # création d'un dataset
(x, y) linéaire
plt.scatter(x[:,0], y) # afficher les résultats. x_1 en abscisse et y en ordonnée

Création de la matrice X
X = np.hstack((x, np.ones((x.shape[0], 1)))) # ajoute un vecteur Biais de
dimension (x.shape[0], 1)
print(X.shape)
Print (X[:10])
 RÉGRESSION LINÉAIRE MULTIPLE VARIABLES
 Modèle Linéaire
 Fonction Cout Déjà implémentés
 Gradient Descent

Phase d'entrainement
n_iterations = 1000 learning_rate = 0.01

theta_final, cost_history = gradient_descent(X, y, theta, learning_rate, n_iterations)

création d'un vecteur prédictions qui contient les prédictions de notre modele final
predictions = model(X, theta_final)
theta_fina

Affiche les résultats de prédictions

plt.scatter(x[ :0], y)
plt.scatter(x[ : 0], predictions, c='r')
RÉGRESSION LINÉAIRE MULTIPLE
VARIABLES
 Pour visualiser notre modèle avec les deux variable il suffit de le voir en
3D


from mpl_toolkits.mplot3d import Axes3D

%matplotlib notebook

ax = plt.figure().add_subplot(111, projection='3d')

ax.scatter(x[:,0], x[:,1], y)
ax.scatter(x[:,0], x[:,1], predictions)
SKLEARN

 Scikit-learn est un module python intégrant les

algorithmes classiques de l’apprentissage automatique.

 Il vise à fournir des solutions simples et efficaces pour

les problèmes d’apprentissage, accessible à tous et
réutilisables dans divers contextes.

 Tout les modèles et les algorithmes du machine learning

ont été implémentés avec l’architecture OO
SKLEARN

Pour crée un modèle on génère un objet de la classe

correspondant

Model=linearRegression(………)

Objet constructeur hyper paramètres

Une fois que notre modèle est initialisé alors on peut :

*l’entraîner
*l’évaluer
Méthodes
*l’utiliser
SKLEARN
 Entraîner avec la méthode fit()
model.fit(x,y)
o L’évaluer avec la méthode score()
model.score(x,y)
o Prévoir avec la méthode predict()
model.predict(x)

Exemple de la régression linéaire

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression from
sklearn.linear_model import SGDRegressor
SKLEARN

 Avec Sklearn, il suffit d’écrire quelques lignes pour

développer des modèles de Régression Linéaire et
Polynômiale.

 Vous devez vous souvenir des fonctions suivantes

*model = SGDRegressor( nb_itérations, learning_rate)
*model.fit(x, y) : pour entrainer votre modèle.
*model.score(x, y) : pour évaluer votre modèle.
*model.predict(x) : pour générer des prédictions.
 SKLEARN
1/Créer un Dataset

np.random.seed(0)
x, y = make_regression(n_samples=100, n_features=1, noise=10)
plt.scatter(x, y)

2/Développer le modèle et l’entraîner

model = LinearRegression()

model.fit(x,y)
model.score(x,y)#coef de détermination
model.predict(x)

prediction=model.predict(x)
plt.scatter(x,y)
plt.plot(x,prediction,c='r')
 LA CLASSIFICATION

On compte en général 2 familles de problèmes

• Les problèmes de Classification, qui consiste

• Les problèmes de régression, qui consiste à
à prédire la valeur d’une variable discrète :
prédire la valeur d’une variable continue :

• Est-ce que l’email est un spam ? • Prix de l’immobilier

• Est-ce-que ce logiciel est un malware ? • Valeur d’une action boursière
• Est-ce que la radio montre une fracture ? • Température qu’il fera demain ou dans 10 ans
• Est-ce que les analyses médicales montrent un • Somme du panier achat client
cancer ? • Consommation électrique d’une usine
• Quel animal est sur la photo ? Chien ? Chat ? • Position du bras d’un robot en automatique
Renard ?
LA CLASSIFICATION

Classification Régression
LA CLASSIFICATION
 Dans ce genre de problème, on aura un Dataset contenant une variable
target 𝒚 pouvant prendre 2 valeurs seulement, par exemple 0 ou 1
• si 𝑦 = 0, alors l’email n’est pas un spam
• si 𝑦 = 1, alors l’email est un spam

La frontière de décision permet de classer un email dans la 𝑐𝑙𝑎𝑠𝑠𝑒 0 ou 1

 LA CLASSIFICATION: RÉGRESSION
LOGISTIQUE

Pour les problèmes de classification binaire, un modèle linéaire 𝑭 = 𝑿. 𝜽, comme je

l’ai tracé sur la figure précédente, ne convient pas

On développe alors une nouvelle fonction

 la fonction logistique = fonction
sigmoïde
LA CLASSIFICATION: RÉGRESSION LOGISTIQUE

 Pour coller la fonction logistique sur un Dataset (𝑿,𝒚) on y fait

passer le produit matriciel 𝑿.𝜽 ce qui nous donne le modèle de
Logistic Regression :
FONCTION COÛT ASSOCIÉE À LA RÉGRESSION
LOGISTIQUE

Il faut donc développer une nouvelle Fonction

Coût spécialement pour la régression logistique
FONCTION COÛT ASSOCIÉE À LA RÉGRESSION
LOGISTIQUE

Si on sépare les cas notre fonction sigma où 𝑦

= 1 des cas où 𝑦 = 0.

Une fonction convexe

Logarithme
 FONCTION COÛT ASSOCIÉE À LA RÉGRESSION
LOGISTIQUE
le cas où 𝑦 = 1 le cas où 𝑦 = 0

Si notre modèle prédit 𝜎(𝑥) = 0 alors

Si notre modèle prédit 𝜎(𝑥) = 1 alors que 𝑦 = 0,
que 𝑦 = 1, on doit pénaliser la machine
on doit pénaliser la machine par une grande
par une grande erreur (un grand coût).
erreur (un grand coût).
 FONCTION COÛT ASSOCIÉE À LA
RÉGRESSION LOGISTIQUE

si y=0

si y=1
GRADIENT DESCENT POUR LA RÉGRESSION
LOGISTIQUE
DÉVELOPPER UN PROGRAMME DE
CLASSIFICATION BINAIRE DANS
JUPYTER
 Voir fichier (régression losigtique)
PANDA

 Pandas est une librairie python qui permet de manipuler

facilement des données à analyser :manipuler des tableaux
de données avec des étiquettes de variables (colonnes) et
d'individus (lignes).
 ces tableaux sont appelés DataFrames,

 on peut facilement lire et écrire ces dataframes à partir ou

vers un fichier tabulé.
 on peut faciler tracer des graphes à partir de ces
DataFrames grâce à matplotlib.
PANDA : CRÉATION DE DATAFRAMES
 un Dataframe se comporte comme un dictionnaire dont
les clefs sont les noms des colonnes et les valeurs sont
des séries.

tab = numpy.array([[1.1, 2, 3.3, 4], [2.7, 10, 5.4, 7], [5.3, 9, 1.5, 15]])
df = pandas.DataFrame(tab, index = ['a1', 'a2', 'a3'], columns = ['A', 'B', 'C', 'D'])

http://www.python-simple.com/python-pandas/panda-intro.php
L’ALGORITHME K NEARST NEIGHBORS (K-NN)

 l’algorithme K-NN (K-nearest neighbors) est une

méthode d’apprentissage supervisé. Il peut être utilisé
aussi bien pour la régression que pour la classification.
 K-NN n’a pas besoin de construire un modèle
prédictif.
Ainsi, pour K-NN il n’existe pas de phase d’apprentissage
proprement dite. C’est pour cela qu’on le catégorise parfois
dans le Lazy Learning.
 Pour pouvoir effectuer une prédiction, K-NN se base sur le
jeu de données pour produire un résultat.
L’ALGORITHME K NEARST NEIGHBORS (K-NN)

 L’Objectif :
est de classé les nouveaux donnés non étiquetés sur la
base de leur similarité avec les exemples de notre Dataset

o Domaine d’utilisations:
 La reconnaissance de formes

 Analyse d’image

 Marketing ciblé
KNN: PRINCIPE DE FONCTIONEMENT

 Le principe de cet algorithme de classification est très simple.

On lui fournit:
• un ensemble de données d’apprentissage D (Dataset )
• une fonction de distance d
• un entier k

Pour tout nouveau point de, test x pour lequel il doit prendre une
décision, l’algorithme :
1/ recherche dans D les k points les plus proches de x au sens de
la distance d ,
2/ et attribue x à la classe qui est la plus fréquente parmi ces k
voisins.
KNN:EXEMPLE
•Dans l’exemple suivant, on a 3 classes et le but est de trouver la
valeur de la classe de l’exemple inconnu x.
•On prend la distance Euclidienne et k=5 voisins
•Des 5 plus proches voisins, 4 appartiennent à ω1 et 1appartient à
ω3, donc x est affecté à ω1, la classe majoritaire
 KNN: ALGORITHME
Début Algorithme

Données en entrée :

•un ensemble de données D .

•une fonction de définition distance d .
•Un nombre entier k

Pour une nouvelle observation X dont on veut prédire sa variable de sortie y Faire :

1.Calculer toutes les distances de cette observation X avec les autres observations Dataset D

2.Retenir les k observations Dataset D les proches de X en utilisation le fonction de calcul de distance

3.Prendre les valeurs de y des k observations retenues :

calculer le mode de y retenues (est la valeur la plus représentée )

4.Retourner la valeur calculée dans l’étape 3 comme étant la valeur qui a été prédite par K-NN pour l’observation
.

Fin Algorithme
KNN : CALCULE DE DISTANCE
**Comme on vient de le voir dans notre écriture algorithme, K-NN a besoin d’une
fonction de calcul de distance entre deux observations.
**Plus deux points sont proches l’un de l’autre, plus ils sont similaires et vice versa.

Les fonctions de calcul de distance:

--la distance euclidienne,
-- la distance de Manhattan,
-- la distance de Minkowski,
--la distance de Hamming…etc.

Le choix de la fonction : On choisit la fonction de distance en fonction des

types de données qu’on manipule.
La distance euclidienne: les données quantitatives (exemple : poids, salaires,
taille, montant de panier éléctronique etc…) et du même type.a distance
La de Manhattan: elle est une bonne mesure à utiliser quand les données (input
variables) ne sont pas du même type (exemple :age, sexe, longueur, poids etc…).
KNN: LE CHOIX DE LA VALEUR K ?

 K petit :
frontières des classes très complexes
 très sensible aux fluctuations des données
(variance élevée).
 risque de sous apprentissage.

 K=grande :
frontière rigide
plus la valeur de k est grande plus le
résultat d’affectation est bien réalisée
 K=N(sur apprentissage)
KNN: CONCLUSION
Avantage :

1/ Dit plus tôt, c'est un algorithme d'apprentissage paresseux et ne nécessite donc

aucune formation avant de faire des prédictions en temps réel. Cela rend l'algorithme
KNN beaucoup plus rapide que d'autres algorithmes qui nécessitent une formation
régression linéaire, etc.

2/ Il n'y a que deux paramètres requis pour implémenter KNN, à savoir la valeur de K
et la fonction de distance ,

Inconvénients :

1/ L'algorithme KNN ne fonctionne pas bien avec des données de grande dimension
car avec un grand nombre de dimensions,
 il devient difficile pour l'algorithme de calculer la distance dans chaque
dimension.
le un coût de prédiction devient élevé. En effet, dans les grands ensembles de
données, le coût du calcul de la distance entre un nouveau point et chaque point
existant devient plus élevé.
IMPLÉMENTATION DU K-NN SUR MNIST
C’ est une base de donnée de chiffres manuscrits très utilisée en Machine Learning, notamment pour
l’entrainement et le test de modèles prédictifs.

** une base de données étiquetée

** chaque chiffre, on a sa représentation sous forme d’image

ainsi que son étiquette

**chaque chiffre est codé dans un format 8 pixels * 8 pixels.

**chaque pixel peut prendre une valeur de 0 à 255

**chaque représentation d’une image est

une matrice de dimension 8x8 .

** un sous-ensemble de la “vraie” base de données MNIST

est présent par défaut dans la librairie Scikit Learn il
comporte 1797 chiffres,
IMPLÉMENTATION DU K-NN SUR
MNIST

 Voir fichier(KNN sur MNIST)

DEEP LEARNING:APPRENTISSAGE
PROFOND
DEEP LEARNING :RÉSEAUX DE
NEURONES

 Un réseau de neurones artificiels, ou Artificial Neural

Network en anglais, est un système informatique
matériel et / ou logiciel dont le fonctionnement est
calqué sur celui des neurones du cerveau humain.
 Il s’agit là d’une variété de technologie Deep
Learning (apprentissage profond), qui fait elle-même
partie de la sous-catégorie d’intelligence artificielle
du Machine Learning (apprentissage automatique).
 L’HISTOIRE DES RÉSEAUX DE
NEURONES ARTIFICIELS
1/ Le concept des réseaux de neurones artificiels fut inventé en 1943 par deux chercheurs
de l’Université de Chicago : le neurophysicien Warren McCullough, et le mathématicien
Walter Pitts. Dans un article publié dans le journal Brain Theory, les deux chercheurs
présentent leur théorie selon laquelle l’activation de neurones est l’unité de base de l’activité
cérébrale.

2/ En 1957, le Perceptron fut inventé. Il s’agit du plus ancien algorithme de Machine

Learning, conçu pour effectuer des tâches de reconnaissance de patterns complexes. C’est
cet algorithme qui permettra plus tard aux machines d’apprendre à reconnaître des objets
sur des images.

à l’époque, les réseaux de neurones étaient limités par les ressources techniques. Par
exemple, les ordinateurs n’étaient pas assez puissants pour traiter les données
nécessaires au fonctionnement des réseaux de neurones.

la recherche dans le domaine des Neural Networks est restée en sommeil durant de
longues années.
 L’HISTOIRE DES RÉSEAUX DE
NEURONES ARTIFICIELS
3/ Il aura fallu attendre le début des années 2010, avec l’essor du Big Data et du
traitement massivement parallèle, pour que les Data Scientists disposent des données et
de la puissance de calcul nécessaires pour exécuter des réseaux de neurones complexes.

4/ En 2012, lors d’une compétition organisée par ImageNet, un Neural Network est
parvenu pour la première fois à surpasser un humain dans la reconnaissance d’image.

C’est la raison pour laquelle cette technologie est de nouveau au

coeur des préoccupations des scientifiques. A présent, les réseaux de
neurones artificiels ne cessent de s’améliorer et d’évoluer de jour en
jour.
RÉSEAUX DE NEURONE Neurone biologique
Définition
Des cellules qu’on trouve dans
notre système nerveux et qui sont
connectées les une avec les autres

Chaque neurone possède une terminaison

qu’on appelle Axone, par laquelle le neurone
peut envoyer un signal aux autres neurones

Fonctionnement

Le neurone reçoit ou pas un signal électrique

des autres neurones qui sont connectés a lui ,
en fonction de ce signal
 soit il n’envoie rien a son axone (0)
 soit il envoie un signal électrique (1)
(décharge)
RÉSEAUX DE NEURONE
 Neurone artificielle:

C’est une fonction mathématique qui va mettre une relation entre les
entrées X et les sorties Y
Une fonction mathématique qui imite le fonctionnement d’un vrai
neurone (biologique)

Fonctionnement
Voila un neurone artificielle avec
3 entrées : X1,X2,X3
Poid1

p1X1+p2X2+p3X3 Poid3 seuil

SI
Poid2
>s <s
ALORS
Y=1 Y=0
 RÉSEAUX DE NEURONE
 Voilà à quoi ressemble un Réseau de Neurones

En règle générale, un réseau de neurones repose sur un grand nombre de

processeurs opérant en parallèle et organisés en tiers.

Le premier tiers reçoit les entrées d’informations brutes, un peu comme les
nerfs optiques de l’être humain lorsqu’il traite des signaux visuels.

Par la suite, chaque tiers reçoit les sorties d’informations du tiers

précédent. On retrouve le même processus chez l’Homme,
 RÉSEAUX DE NEURONE

Vous remarquez :
**un niveau d’entrées (input layer) ,
**un niveau de sorties (output layer) ,
**plusieurs niveaux cachés entre les deux.
**Les ronds ( les neurones) représentent des fonctions d’activation.

Exemple: Pour un réseau de neurone basique, la fonction Logistique est utilisée

comme fonction d’activation,
RÉSEAU DE NEURONE À 1 NEURONE
 Le réseau de Neurones le plus simple qui existe porte le
nom de perceptron = identique à la Régression
Logistique
Le calcul effectué par le neurone peut être
divisé en deux étapes :

Etape 1 Etape 2

Le neurone calcule la 𝒔𝒐𝒎𝒎𝒆 𝒛 de toutes Le neurone passe z dans sa fonction

les entrées 𝒛 = ∑𝒙𝜽. (linéaire) d’activation. Ici la fonction sigmoïde
( non-linéaire ).
RÉSEAUX À PLUSIEURS NEURONES
Pour créer un Réseaux de Neurones, il suffit connecter plusieurs
perceptrons les uns aux autres suivant cette façon :
On réunit les neurones en colonne (en couche): les neurones ne
sont pas connectés entre eux.
On connecte toutes les sorties des neurones d’une colonne
à gauche aux entrées de tous les neurones de la colonne de
droite qui suit.

Plus il y a de couches, plus on dit que le réseau est profond (deep)

et plus le modèle devient riche, mais aussi difficile à entraîner.

le Deep Learning.
LES RÉSEAUX DE NEURONES
Des modèles bien plus complexes que tous les autres modèles de Machine Learning dans
le sens où ils représentent des fonctions
mathématiques avec des millions de coefficients (les paramètres).

la régression linéaire nous n’avions que 2 coefficients 𝑎 𝑒𝑡 𝑏…

L’ENTRAÎNEMENT D’UN RÉSEAU DE
NEURONE
Pour résoudre un problème de Supervised Learning, il vous faut les 4 éléments
suivants

 1. Un Dataset
 2. Un Modèle et ses paramètres

 3. Une Fonction Coût et son gradient

 4. Un Algorithme de minimisation
L’ENTRAÎNEMENT D’UN RÉSEAU DE NEURONE

1/ Pour le Dataset: un tableau (𝑿,𝒚) comme pour les autres problèmes. Les
facteurs (𝒙𝟏,𝒙𝟐,𝒙𝟑,…) sont distribuées à l’entrée du réseau  le premier layer

2/ Pour programmer le Modèle, il faut emboîter les fonctions des différent

niveaux d’activation les unes dans les autres.
C’est ce qu’on appelle Forward Propagation (faire le chemin des
entrée 𝑿 vers la sortie 𝒚).
L’ENTRAÎNEMENT D’UN RÉSEAU DE NEURONE
3/ Pour exprimer la Fonction Coût et son gradient: Il faut calculer la
contribution de chaque neurone dans l’erreur finale ( mathématiquement
délicat)

c’est possible avec une technique appelée Back Propagation (faire

le chemin dans le sens inverse : 𝒚 vers 𝑿).

4/ Enfin, pour minimiser la Fonction Coût, il suffit d’utiliser Gradient

Descent en utilisant les gradients calculés avec Back Propagation.

NB: Le Gradient Descent en lui-même n’est pas différent de celui que nous
avons vu
IMPLÉMENTATION DU RÉSEAU DE NEURONES.
 On va utilisé la BD d’Iris
Normalement, on développe des Réseaux de Neurones avec un Framework
comme Tensorflow, mais on va le faire avec Sklearn. Pour cela,

il faudra importer MLPClassifier (qui signifie : Multi-Layer Perceptron

Classifier).

On développe un programme capable de reconnaitre

une espèce parmi plusieurs de la famille des Iris.
L’algorithme utilise 4 features pour effectuer son
calcul :
• 𝒙𝟏 : La longueur du pétale
• 𝒙𝟐 : La largeur du pétale
• 𝒙𝟑 : La longueur du sépale
• 𝒙𝟒 : La largeur du sépale
APPRENTISSAGE NON SUPERVISÉ
L’Apprentissage Supervisé: on montre à la machine une BD (X,y) de ce qu’elle doit
apprendre
consiste à enseigner à la machine des choses que nous connaissons
déjà
L’Apprentissage non Supervisé: Au lieu de présenter à la machine (X,y) ,
on lui fournit des X et on lui demande d’analyser la structure de ces donnés
pour apprendre elle-même de réaliser certaines tâches:

Clustering

Classification non supérvisé:Elle peut classer des données uniquement

selon leurs ressemblance Algorithme: K-mean clustring
APPRENTISSAGE NON SUPERVISÉ: CLUSTERING

 Une des applications les plus populaires de l’apprentissage non-supervisé

 Le principe est de laisser la machine apprendre à trier des données selon leur
ressemblances en analysant uniquement les features X.
 Les algorithmes à connaitre :
- K-Means : Très rapide, mais non-efficace sur les clusters non-convexes.
- AgglomerativeClustering : assez lent, mais efficace sur les données non-
convexes
- DBSCAN : efficace sur les données non-convexes, mais sélection du nombre
de clusters est automatique

Applications : - Trier des documents, des photos, des tweets - Segmenter la

clientèle d’une entreprise - Optimiser l’organisation d’un système informatique,
etc…
 APPRENTISSAGE NON SUPERVISÉ

Détection
d’anomalie

Détection d’anomalie: trouver les échantillons dont les caractéristiques (x)

Sont très éloignées de celles des autres échantillons

Algorithme: Isolation forest

 APPRENTISSAGE NON SUPERVISÉ:DÉTECTION D’ANOMALIE

 En analysant la structure X des données, la machine est capable de trouver

les échantillons dont les features X sont très éloignées de celles des autres
échantillons.
 Ces échantillons sont alors considérés comme étant des anomalies.
 Les algorithmes à connaitres :
- IsolationForest : Efficace pour détecter des outliers dans le train_set
- Local Outlier Factor : Efficace pour détecter des anomalies futures

Applications : - Nettoyer un Dataset des valeurs aberrantes qui le composent -

Détecter un comportement anormal sur un site Internet ou sur une caméra de
surveillance
APPRENTISSAGE NON SUPERVISÉ

Réduction de
dimension

Réduction de dimension : en étudiant la structure de nos données , la machine apprend

à la simplifier tout en conservant les principales informations;

La machine apprend à projeter nos données dans des espaces de plus petite
dimension

Algorithme: PCA (analyse en composantes principales)

APPRENTISSAGE NON SUPERVISÉ:RÉDUCTION DE DIMENSION

 Le principe est de réduire la complexité superflue d’un dataset en projetant

ses données dans un espace de plus petite dimension (un espace avec moins
de variables).
 Le but est d’Accélérer l’apprentissage de la machine et de Lutter contre le
fléau de la dimension.
 Algorithmes a connaitre :
- Analyse en composantes principales (PCA) : le plus populaire et le plus
simple a comprendre
- TSNE
Isomap

Applications : - Visualisation de données : afficher sur un graphique 2D un

espace de grande dimension - Compression de dataset : réduire au maximum le
poids d’un dataset en conservant un maximum de qualité
ALGORITHME DE K-MEAN CLUSTERING
 L’algorithme fonctionne en 2 étapes répétées en boucle.
 On commence par placer au hasard un nombre K de centres dans notre
nuage de points: Centroide.
 Dans l’exemple ci-dessous, K=2
ALGORITHME DE K-MEAN CLUSTERING

 Ensuite :
- L’étape 1 consiste à rallier chaque exemple au centre le plus proche.
Après cette étape, nous avons K Clusters (ici 2 clusters)
- L’étape 2 consiste à déplacer les centres au milieu de leur Cluster
ALGORITHME DE K-MEAN CLUSTERING
On répète les étapes 1 et 2 en boucle jusqu’à ce que les centres ne bougent
plus
ALGORITHME DE K-MEAN CLUSTERING

 En résumé: K-mean cherche la position des centres qui

minimise la fonction coût Inertia qui n’est que la
distance entre les points d’un cluster(Xi) et le centre (Uj)
de ce dernier:
IMPLÉMENTER UN K-MEAN
CLUSTERING
 La librairie Sklearn nous permet aussi de faire du Unsupervised Learning !
IMPLÉMENTER UN K-MEAN
CLUSTERING
ALGORITHME DE ISOLATION FOREST
permet de détecter des anomalies dans un jeu de données.
 Il isole les données atypiques, autrement dit celles qui sont trop différentes de la
plupart des autres données.
Principe
**Calcule, pour chaque donnée du jeu, un score d’anomalie, c’est à dire une mesure qui
reflète à quel point la donnée en question est atypique.

**Afin de calculer ce score, l’algorithme

1/ isole la donnée en question de manière récursive : il choisit un descripteur (feature) et
un “seuil de coupure”(split value: une valeur divisée entre les valeurs maximale et
minimale de feature sélectionné.) au hasard, puis il évalue si cela permet d’isoler la
donnée en question ;

1.1/ Si OUI , l’algorithme s’arrête,

1.2/ Si NON il choisit un autre descripteur et un autre point de coupure au hasard, et

ainsi de suite jusqu’à ce que la donnée soit isolée du reste.
La plupart des données obtiendront des scores faibles, tandis
que les anomalies devraient se démarquer en obtenant des
scores élevés,
ALGORITHME DE ISOLATION FOREST
Le partitionnement récursif des données peut-être représenté comme un arbre de
décision.
Le nombre de coupures nécessaires pour isoler une donnée correspond tout simplement
au chemin parcouru dans l’arbre depuis la racine jusqu’à la feuille, représentant la
donnée isolée.
La longueur du chemin définit le score l’anomalie : les données ayant un chemin très
court, c’est à dire les données faciles à isoler, ont également de grandes chances d’être
des anomalies, puisqu’elles sont très loin des autres données du jeu.