Hicham Janati

hjanati@[Link]
Machine learning classique: zero-to-hero Exemple: Churn prediction
Un opérateur téléphonique a les données historiques sur ses clients.

Dependents TechSupport Contract InternetService Months MonthlyCharges Churn

0 1 0 1 12 75.65 0
1 0 0 0 24 89.50 0
0 0 0 1 6 65.25 1
0 1 1 0 48 35.30 ?
1 0 0 1 48 85.81 ?

Churn = 1: client a annulé son abonnement

L’entreprise souhaite anticiper le “churn” avec un algorithme de prédiction pour cibler les clients concernés
1 6
X = (X , . . . , X ) ! y 2 {0, 1}
n
X
2
On cherche une fonction f telle que: f (X) ⇡ y min (f (xi ) yi ) Erreur de prédiction
f
i=1

f doit donner 1 ou 0, on considère alors des fonctions de type: f (x) = 1g(x) 0

On ne peut pas chercher g dans la totalité de l’espace des fonctions (dimension in nie), il faut paramétriser g

2
fi
Machine learning classique: zero-to-hero séparateur linéaire en dimension 1

f doit donner 1 ou 0, on considère alors des fonctions de type: f (x) = 1g(x) 0

On ne peut pas chercher g dans la totalité de l’espace des fonctions (dimension in nie), il faut paramétriser g

On considère une seule variable “Months” qui donne la durée du contrat:

x = Months 2 R

Quelle serait la fonction paramétrée g la plus simple ici ?

g(x) = 1x + 0, 0, 1 2R
n
X
2
Chercher la meilleure f = chercher le meilleur : min2 (1{ 1 xi + 0 0} yi )
2R
i=1

Pouvez-vous donner des estimations vagues de ces paramètres ?

3
fi
Machine learning classique: zero-to-hero séparateur linéaire en dimension 2
1 2
On considère une deux variables: “Months” et “MonthlyCharges”: x = (x , x ) f (x) = 1g(x) 0

Quelle serait la fonction paramétrée g la plus simple ici ?

1 2
g(x) = ↵ + 1x + 2x , ↵, 1, 2 2R
2
g(x) = ↵ + h , xi, ↵ 2 R, 2R
> 2
g(x) = ↵ + x, ↵ 2 R, 2 R
Xn
2
min 2 (1{↵+ > xi 0} yi )
↵2R, 2R
i=1

À quoi ressemble l’ensemble des fonctions g ?

On considère g : x 7! >
x. Étudions ses courbes de niveaux, c-à-d pour c 2 R les ensembles: {x|g(x) = c}.
Machine learning classique: zero-to-hero séparateur linéaire en dimension 2

On considère g : x 7! >
x. Étudions ses courbes de niveaux, c-à-d pour c 2 R les ensembles: {x|g(x) = c}.

Exemple avec = (1, 0.5)> et c = 0.

>
Quels sont les x tels que x=0?

Tous les vecteurs orthogonaux à .

{x 2 R2 | >
x = 0} est la droite perpendiculaire à .
Machine learning classique: zero-to-hero séparateur linéaire en dimension 2

On considère g : x 7! >
x. Étudions ses courbes de niveaux, c-à-d pour c 2 R les ensembles: {x|g(x) = c}.

g(x) > 0
Exemple avec = (1, 0.5)> et c = 0.
>
Quels sont les x tels que x=0?

Tous les vecteurs orthogonaux à .

g (x
{x 2 R2 | >
x = 0} est la droite perpendiculaire à .

)=
0
g(x) < 0 >
à droite de (D), x>0
(D)
>
à gauche de (D), x<0

et si c = 1 ? ou c = 1?
Machine learning classique: zero-to-hero séparateur linéaire en dimension 2

On considère g : x 7! >
x. Étudions ses courbes de niveaux, c-à-d pour c 2 R les ensembles: {x|g(x) = c}.

g(x) > 0
Exemple avec = (1, 0.5)> et c = 0.

g (x
)=
>
Quels sont les x tels que x=0?

1
Tous les vecteurs orthogonaux à .

g (x
g (x

)=
{x 2 R2 | >
x = 0} est la droite perpendiculaire à .

)=

1
0
g(x) < 0 >
à droite de (D), x>0
(D)
>
à gauche de (D), x<0

et si c = 1 ? ou c = 1?
Machine learning classique: zero-to-hero séparateur linéaire en dimension 2

Comment change la fonction de prédiction f : 1{↵+ >x 0} en fonction de ↵ et ?

Machine learning classique: zero-to-hero séparateur linéaire en dimension 2

↵ = 0, varie: ↵ varie, = [1, 1]:

Comment change la fonction de prédiction f : 1{↵+ >x 0} en fonction de ↵ et ?

Machine learning classique: zero-to-hero séparateur linéaire en dimension 2
n
X
2
min (1{↵+ >x
i 0} yi )
↵2R, 2R2
i=1
Machine learning classique: zero-to-hero séparateur linéaire en dimension d

1 2 3 3
Et si on utilise trois variables: g(x) = ↵ + 1x + 2x + 3x , ↵, 2R
> 3
g(x) = ↵ + x, ↵, 2R

Que forment les x tels que {g(x) = 0}?

> d
En dimension d: g(x) = ↵ + x, 2R

Que forment les x tels que {g(x) = 0}?

Un espace de dimension d-1: un hyperplan

11
Machine learning classique: zero-to-hero Régression logistique
n
X
2
min (1{↵+ >x
i 0} yi ) Fonction non di érentiable (discontinue même) di cile à optimiser
↵2R, 2Rd
i=1
>
Au lieu de prendre le signe, transformer les scores ↵ + xi vers [0, 1] et modéliser des probabilités

1
sigmoid: t 7! 1+e t (logistique)

def >
pi = P(y i = 1|xi ) = sigmoid(↵ + xi )

On peut comparer les pi avec les y i avec la cross-entropy:

n
X
min y i log(pi ) + (1 y i ) log(1 pi )
↵2R, 2Rd
i=1

? ? ?> 1
On a donc une fonction de prédiction: f (xi ) = 1 , sigmoid(↵ + xi ) 2

Modèle de régression logistique

12
ff
ffi
Machine learning classique: zero-to-hero Train and test error

def >
pi = P(y i = 1|xi ) = sigmoid(↵ + xi ) Optimisation faite sur (x1 , y 1 ), . . . , (xn , y n )
n
X “Training” data
min y i log(pi ) + (1 y i ) log(1 pi )
↵2R, 2Rd
i=1

predictions true labels

x1 y1 ?
f (x1 ) y1
.. .. “Learned” f* .. .. “Train” error
. . “Training”
. .
xn yn ? yn
f (xn )

Est-ce une bonne manière d’évaluation la performance du modèle ?

L’erreur de prédiction sur ces données est optimisée: elle est forcément petite. predictions true labels
? 0 0
Il faut évaluer la performance du modèle sur des données f (x1 ) y1
nouvelles non vues à l’entraînement: “Test data” .. .. “Test” error
. .
? 0 0
f (xm ) ym
13
Machine learning classique: zero-to-hero Train error goes to zero

Peut-on séparer les classes avec une séparation linéaire dans ces cas ?

d=2 d=3
d=1

Non !

Non ! Oui !

d + 1 représente le nombre de paramètres à estimer: plus d est grand, plus le modèle est riche, complexe.

Comment évolue l’erreur sur le train au fur-et-à mesure que la dimension d augmente ?

14
Machine learning classique: zero-to-hero Test error makes a U shape

Quelle est la meilleure séparation linéaire sur ces données ?

d=1 d=2 d=3

Calculer l’erreur de train et de test.

d = 3 donne la meilleure erreur de train = 0 d = 2 donne la meilleure erreur de test = 0

“La meilleure” séparation linéaire sur le train n’est pas la meilleure sur le test: elle est biaisée par les outliers

Une grande dimension peut causer l’over tting

15
fi
Machine learning classique: zero-to-hero Bias-Variance tradeo

“Bias-Variance” tradeo

Under tting correspond à:

Under tting
Over tting
Grand biais ou grande variance ?

Variance nulle = prédiction constante

= under tting

Model complexity

16
fi
fi
fi
fi
f
f
Machine learning classique: zero-to-hero Regularization

Pour réduire l’over tting, on peut réduire l’espace d’optimisation en privilégiant des coe cients simples:
n
X
min y i log(pi ) + (1 y i ) log(1 pi )
2Rd+1
i=1
k k22 C

Ce problème n’est pas facile à résoudre (contrainte quadratique), on peut montrer que ce problème est équivalent:
n
X 1 2
min y i log(pi ) + (1 y i ) log(1 pi ) + k k2
2Rd+1
i=1
C

Dans les deux cas plus C est petit plus on minimise k k: “Plus on régularise”.

CC!
!00?? lele optimal
optimalest
estlelevecteur
vecteurnul:
nul: lalafonction
fonctionde
deprédiction
prédictionest
estconstante:
constante: underfitting
underfitting

C! ! +1
C +1 ? l’optimisation
? l’optimisation
est est R R en en
sursur d+1d+1
entier:
entier:
risque
risque
d’overfitting.
d’overfitting.

17
fi
ffi
Machine learning classique: zero-to-hero Regularization

18
Machine learning classique: zero-to-hero Regularization

Tout modèle de machine learning (supervisé) cherche une fonction de prédiction f .

Supposons qu’elle est paramétrée par ✓ 2 Rp .

Tout modèle de machine learning cherche un compromis entre:

Xn
1 1
minp loss(f✓ (xi ), y i ) + pénalité(✓)
✓2R n C
i=1
des paramètres “simples” pour
Minimiser l’erreur de prédiction
généraliser à des données
sur les données “train”
nouvelles test (éviter l’over tting)

C contrôle la complexité du modèle

La fonction “pénalité” est aussi appelée “régularisation”: elle vient simpli er (régulariser) la fonction de prédiction

Ce type de régularisation (+ pénalité) est dit: régularisation de Tikhonov

Comment choisir la pénalité ? Comment choisir C ?

19
fi
fi
Machine learning classique: zero-to-hero Regularization

Comment choisir la pénalité ?

Les pénalités les plus utilisés sont:

1. pénalité Ridge /`2 : 2

k✓k2 1
=
C
1. Facile à optimiser (di érentiable)
2. Toutes les variables contribuent au modèle
3. Peut être ajoutée à n’importe quel modèle
Ridge: “shrink” toutes les coordonnées lentement vers zéro (sans l’atteindre)

2. pénalité Lasso /`1 : k✓k1

1. Moins facile à optimiser (non-di érentiable)
2. Permet d’avoir des coe cients “sparses” (beaucoup
de 0): utile pour la sélection de variables pertinentes

2
3. pénalité Elastic net : k✓k2 + (1 )k✓k1
Souvent, prendre un mélange des deux permet Lasso: annule les coe cients un par un
d’obtenir de meilleures performances.
20
ff
ffi
ffi
ff
Machine learning classique: zero-to-hero Regularization

Comment choisir C ?

On veut le C qui donne la Pour cela on peut:

meilleure performance sur le test 1. Couper le dataset en deux train et test:

X Xtrain Xtest

Y Ytrain Ytest

2. Choisir une liste de valeurs de C, par ex: [0.01, 0.05, 0.1, 1., 10]
Pour chaque C:
Xn
1 1
1. Optimiser sur Xtrain Ytrain minp loss(f✓ (xi ), y i ) + pénalité(✓)
C optimal ✓2R n C
i=1

2. Évaluer l’erreur de prédiction sur Xtest Y test

3. Choisir la valeur de C avec la plus petite erreur de prédiction sur le test

Quel est l’inconvénient principal de cette méthode ? Le C choisi dépend du découpage aléatoire train / test

21
Machine learning classique: zero-to-hero Cross-validation
Idée: E ectuer plusieurs découpages et moyenner l’erreur de test

1. Couper le dataset en 5 parties (folds)

X X1 X2 X3 X4 X5

Y Y1 Y2 Y3 Y4 Y5

2. Choisir une liste de valeurs de C, par ex: [0.01, 0.05, 0.1, 1., 10]
3. Pour chaque k in [1, 2, 3, 4, 5], créer un découpage train/test C optimal

Xtest , Ytest = Xk , Yk Xtrain , Ytrain = [X sans Xk ], . . . , [Y sans Yk ]

Pour chaque C: n
1 X 1
1. Optimiser sur Xtrain Ytrain minp loss(f✓ (xi ), y i ) + pénalité(✓)
✓2R n C
i=1
2. Évaluer l’erreur de prédiction sur Xtest Y test

4. Pour chaque C, calculer l’erreur de prédiction moyenne C’est l’erreur de validation croisée

5. Choisir le C avec l’erreur de prédiction moyenne la plus petite

5-Fold cross validation
22
ff
Machine learning classique Intro to neural nets
Et si les données ressemblent à ceci ?
0 Aucune fonction linéaire ne peut séparer les classes
=
↵1
1 +
> Idée: “combiner” plusieurs fonctions linéaires
x
1 0
= def > 1 def > 2
↵2 z1 = x + ↵1 z2 = x + ↵2
2 +
0 0 >
> < x
↵1 ↵1
1 + 1 +
> >
x x 0
<
↵2 1. Prendre des x dans R et étudier les signes possibles de z 1 , z 2 .
2
2 + 2
>
x 2. Comment peut-on prédire Y = 1 à partir des z i ?

0
>
2
↵
+
2
x>

23
Machine learning classique Intro to neural nets

Surfaces des hyperplans z 1 , z 2 Surface de max(z 1 , z 2 )

Prédire Y = 1 si l’un des z i est positif , max(z 1 , z 2 ) > 0

f↵, (x) = 1{max(x> 1

+↵1 ,x> 2
+↵2 )>0} Linear functions

Comment entraı̂ner ce modèle, c-à-d optimiser ↵, ? +

def > 1 > 2
pi = P↵, (Y = 1|xi ) = sigmoid(max(xi + ↵ 1 , xi + ↵2 ))
n
Non-linearity
X
Comme la régression logistique: min y i log(pi ) + (1 y i ) log(1 pi )
↵2R, 2Rd
i=1
24
Machine learning classique Intro to neural nets

Comment adapter ce modèle à des données plus complexes ?

Linéarités
def > 1
z1 = x + ↵1
def > 2 non-linéarité
z2 = x + ↵2
.. max(z 1 , . . . , z p )
.
def > p
zp = x + ↵p sigmoid

25
Machine learning classique Intro to neural nets

Comment adapter ce modèle à des données plus complexes ?

Linéarités
def > 1
z1 = x + ↵1
def > 2 non-linéarité
z2 = x + ↵2
.. max(z 1 , . . . , z p )
.
def > p
zp = x + ↵p sigmoid

26
Machine learning classique Intro to neural nets
Linéarités
def > 1
z1 = x + ↵1
.. non-linéarité
. max(z 1 , . . . , z p ) sigmoid
def > p
zp = x + ↵p
En pratique, ce modèle ne fonctionne pas pour ces données complexes. Pourquoi à votre avis ?

1. On n’utilise qu’une seule non-linéarité

2. Elle est xée par la fonction max: on ne l’apprend pas

Il faudrait donc: utiliser plusieurs non-linéarités simples + les combiner pour apprendre des fonctions non-linéaires complexes

Idée: def
z 1 = h(x> 1
+ ↵1 ) p
X
1. Appliquer plusieurs non-linéarités h plus tôt .. !j zj + !0
.
2. Combiner les z j linéairement avec wj à optimiser def j=1
z p = h(x> p
+ ↵p )
sigmoid
27
fi
Machine learning classique Intro to neural nets

def
z 1 = h(x> 1
+ ↵1 ) p h(x) = max(x, 0)
.. X
>
. sigmoid( ! j z j + ! 0 ) = sigmoid(z ! + ! 0 )
def > p j=1
z p = h(x + ↵p )

Quelle est la fonction non-linéaire h la plus simple possible ?

On représente ce type de modèle sous forme de graphe avec des “unités”

de calcul simples: fonction linéaire + non-linéarité. Unité = un neurone: ReLU: Recti ed Linear Unit

def > 1
1 1 z 1 = h(x + ↵1 )
,↵

.. def
z j = h(x > j
+ ↵j )
p
! , !0 >
= sigmoid(z ! + ! 0 )
x .
Output layer
p p def
Input layer
,↵ z p = h(x> p
+ ↵p )
Réseau de neurones à une couche cachée

Hidden layer 28
fi
Machine learning classique Intro to neural nets
On peut augmenter la complexité du modèle à l’in ni…

def
1
z 1 = h(x> 1
+ ↵1 ) 1
, ⌧1 def
, ↵1 1
, µ1 v 1 = h(c> 1
+ µ1 )
.. ..
.
!p , !0

..
.
def
z j = h(x> j

x . + ↵j )
m
,⌧ m
m
, µm
def
v k = h(c> k
+ µk )
p
,↵ p
def
= sigmoid(v > ! + ! 0 )
z p = h(x> p
+ ↵p )

Input layer Hidden layer 1 Hidden layer 2 Hidden layer L Output layer

..
.
Deep neural networks = many layers / many neurons

This is a “general purpose” neural network (NN) known as “fully connected multilayer perceptron” (MLP)

On considère un problème de classi cation binaire avec le réseau ci-dessus optimisé avec une très bonne performance.
d k
On dé nit la transformation des données en s’arrêtant à l’avant dernier layer: g : x 2 R 7! v 2 R
Apprendre à classifier les g(xi ) est-il plus facile ou plus difficile que classifier les xi ?
29
fi
fi
fi
Machine learning classique Representation learning
On peut augmenter la complexité du modèle à l’in ni…

def
1
z 1 = h(x> 1
+ ↵1 ) 1
, ⌧1 def
, ↵1 1
, µ1 v 1 = h(c> 1
+ µ1 )
.. ..
.
!p , !0

..
.
def
z j = h(x> j

x . + ↵j )
m
,⌧ m
m
, µm
def
v k = h(c> k
+ µk )
p
,↵ p
def
= sigmoid(v > ! + ! 0 )
z p = h(x> p
+ ↵p )

Input layer Hidden layer 1 Hidden layer 2 Hidden layer L Output layer

..
.
On considère un problème de classi cation binaire avec le réseau ci-dessus optimisé avec une très bonne performance.
d k
On dé nit la transformation des données en s’arrêtant à l’avant dernier layer: g : x 2 R 7! v 2 R
Apprendre à classifier les g(xi ) est-il plus facile ou plus difficile que classifier les xi ?

Plus facile: car un seul neurone (output) a su t pour les classi er: ils sont forcément linéairement séparables

g(xi ) est un embedding ou une représentation vectorielle de xi

30
fi
fi
ffi
fi
fi