. Montrer que

Chapitre 1

G´ eom´ etrie des espaces de grande dimension

Exercice 1.1. Distances et plus proches voisins en grande dimension.

1. Soient X, Y deux variables ind´ ependantes, de distribution uniforme sur [0, 1]

. Montrer que

E [kX − Y k

] = p/6 et Std[kX − Y k

] ' 0.2 √ p.

2. Que peut-on dire si X et Y ne suivent pas une loi uniforme mais que toutes leurs coordonn´ ees sont i.i.d. ?

3. Tirer n = 100 points avec une loi uniforme dans [0, 1]

et calcu- ler la distribution empirique de leurs distances deux ` a deux. Affi- cher cette distribution pour diff´ erentes valeurs de p (par exemple p = 2, 10, 100, 1000). Ces observations confirment-elles le r´ esultat th´ eorique ? 4. Faire plusieurs tirages pour chacune des valeurs de p et d´ eterminer la

distribution empirique de la plus petite distance entre les points.

Exercice 1.2. Volume de la boule unit´ e

On veut calculer le volume V

(r) de la boule de rayon r en dimension p.

1. Montrer que la fonction Γ(x) = R

0

t

e

dt (d´ efinie pour x > 0) v´ erifie Γ(1) = 1, Γ(1/2) = √

π et Γ(x + 1) = xΓ(x). En d´ eduire que pour tout entier p,

Γ(p + 1) = p! et Γ(p + 3/2) = (2p + 1)(2p − 1) . . . 1 2

√ π.

2. Montrer que V

(r) = r

V

(1) pour tout p ≥ 1 et v´ erifier que V

(1) = 2 et V

(1) = π.

3. Pour p ≥ 3, montrer que V

(1) =

Z

t²+s²≤1

V

p 1 − s

− t

dsdt = V

(1) Z

r=0

Z

θ=0

(1−r

)

r dr dθ = 2π

p V

(1)

1

En d´ eduire que

V

(1) = π

Γ(p/2 + 1) 4. Utiliser la formule de Stirling (qui dit que p! ∼ √

2πp(p/e)

) pour en d´ eduire que

V

(r)

∼

2πer

p

(pπ)

5. Ecrire une fonction permettant d’afficher la courbe du volume de la boule unit´ e en fonction de p, pour p entre 1 et 100. En d´ eduire une fonc- tion permettant de calculer une borne inf´ erieure du nombre minimum de boules unit´ es n´ ecessaires pour recouvrir l’hypercube en dimension p. Donner le r´ esultat pour p = 1, 10, 20, 50, 100.

6. Ecrire une fonction qui donne le rayon d’une boule dont le volume est une fraction 1% du volume de l’hypercube unit´ e.

Exercice 1.3. Montrer que la probabilit´ e qu’une variable X de loi uniforme sur la boule unit´ e en dimension p appartienne ` a la coque entre les boules de rayons 1 − ε et 1 est

P (X ∈ S

(p)) = 1 − (1 − ε)

−→

p→∞

1

Exercice 1.4. Soient X

, . . . X

i.i.d. en dimension p, de loi uniforme sur la boule unit´ e.

1. Quelle est la loi de la distance entre X

et l’origine de la boule ? 2. En d´ eduire la loi de la distance entre l’origine et le point X

le plus

proche de l’origine

3. Montrer que la m´ ediane de cette distance est med(p, n) =

1 − 1

2

.

Que vaut cette distance m´ ediane pour n = 500 et p = 10 ? Comment l’interpr´ eter ?

Exercice 1.5. Montrer que l’angle θ entre la diagonale v de l’hypercube [0, 1]

et le premier vecteur e

de la base euclidienne tend vers π/2. La diagonale de l’hypercube tend donc ` a devenir orthogonale ` a tous les cˆ ot´ e du cube lorsque p grandit !

Exercice 1.6. Estimation en grande dimension. Dans cet exercice, on

souhaite estimer la valeur en 0 d’une fonction f ` a partir de n observations

(x

, y

) telles que y

= f (x

). On propose d’estimer la valeur de f en 0 en

trouvant les 10 points x

les plus proches de 0 et en calculant la moyenne

des y

correpondants.

3 1. Faites l’exp´ erience num´ erique pour la fonction f (x) = e

, avec n = 1000 ´ echantillons et pour p = 1, 10, 100. Qu’observez-vous et comment expliquez-vous ce r´ esultat ?

2. Supposons que les x

soient ´ echantillonn´ es selon une loi uniforme sur l’hypercube [−1, 1]

. Pour n = 1000 ´ echantillons et en dimension 10, calculer la probabilit´ e que le plus proche voisin de 0 soit ` a une distance sup´ erieure ` a

de l’origine.

Exercice 1.7. Matrices de covariance empirique. Ecrire un script qui

tire al´ eatoirement n vecteurs suivant une loi gaussienne N (0, I

), calcule

leur matrice de covariance empirique et affiche l’histogramme de ses valeurs

propres. Lancer le script pour p = 1000 et n = 10∗p (le nombre d’´ echantillons

est 10 fois plus grand que la dimension de l’espace). Quel est le support

de cette distribution des valeurs propres ? Comparer l’histogramme obtenu

(normalis´ e) avec la loi de Mar˘ cenko-Pastur. Tester avec d’autres valeurs de

n et p. Que se passe-t-il si p > n ?

Chapitre 2

Mod` ele lin´ eaire en petite dimension

Les mod` eles lin´ eaires peuvent ˆ etre appris ` a l’aide de la fonction glm. Le r´ esultat peut ˆ etre visualis´ e ` a l’aide de la fonction summary.

Exercice 2.1. On consid` ere les donn´ ees iris.

1. Charger les donn´ ees ` a l’aide de data(iris) et comprendre ce qu’elles contiennent.

2. Apprendre un mod` ele lin´ eaire gaussien expliquant la longueur des p´ e- tales en fonction des autres variables. Analyser les r´ esultats.

Commenter les variables apparaissant dans la solution concernant l’es- p` ece de fleurs.

3. D´ eterminer ` a l’aide d’un mod` ele logistique quelle variable caract´ erise l’esp` ece versicolor.

Exercice 2.2. On consid` ere les donn´ ees airquality.

1. Charger les donn´ ees ` a l’aide de data(airquality) et comprendre ce qu’elles contiennent.

2. Quelles sont les variables qui ont une influence lin´ eaire sur le taux d’Ozone. Quels signes confortent vos ` a-priori ?

3. Que dire du signe affect´ e au coefficient du mois ? Pour mieux l’analyser, tracer les boxplots par mois du taux d’ozone ` a l’aide de boxplot.

R´ eduire les donn´ ees ` a celles de mai ` a juillet. Quel signe attendez- vous pour l’influence du mois ? Relancer l’apprentissage d’un mod` ele lin´ eaire. Commentez. Avez-vous une explication ?

5

Exercice 2.3. Le but de cet exercice est d’illustrer le probl` eme de la coli- n´ earit´ e et de la grande dimension par simulation.

Pour cela, nous allons consid´ erer deux entiers p et n et une covariance 0 ≤ ρ ≤ 1. Nous allons construire un jeu de donn´ ees de 2p + 1 variables (X

, . . . , X

, Y ) mesur´ ees dans n ´ echantillons, et telles que

— var(X

) = 1 pour tout i.

— X

et X

sont ind´ ependantes si i ≤ p et j ≥ p + 1, cov(X

, X

) = ρ sinon.

— Y = X

+ X

+ , suivant une loi normale centr´ ee d’´ ecart-type 0.5.

1. Ecrire une fonction qui prend en argument p, n et ρ et qui, ` a l’aide de la fonction mrvnorm du package MASS, g´ en` ere des donn´ ees correspondant

`

a n ´ echantillons.

2. Pour ρ = 0.1, g´ en´ erer des donn´ ees et apprenez un mod` ele lin´ eaire gaussien pour diff´ erentes valeurs de p et n : n >> p, n > 2p et n ≤ 2p.

3. Mˆ eme question pour ρ = .9. Commenter les r´ esultats pour n l´ eg` ere- ment sup´ erieur ` a p.

Exercice 2.4. La r´ egression logistique correspond au cas o` u Y suit une loi binomiale et g est la fonction de lien g : x → ln

.

On note p(x) = P (Y = 1|X = x). La cˆ ote (odds en anglais) pour un individu dont les caract´ eristiques sont x ∈ R

est d´ efinie par odds(x) =

p(x)

1−p(x)

. L’odds-ratio entre 2 individus de caract´ eristiques x et x

est d´ efini par

OR(x, x

) = odds(x)

odds(x

) = p(x)(1 − p(x

)) (1 − p(x))p(x

) .

Il est ` a noter que comparer l’odd-ratio ` a 1 revient ` a d´ eterminer si Y = 1 est plus probable sous X = x ou sous X = x

.

1. Que vaut l’odd-ratio si x et x

ne diff` erent que par leur k

coordon- n´ ee ? En d´ eduire une interpr´ etation de β

.

2. Si Y d´ esigne une maladie rare, comment peut s’interpr´ eter l’odd-ratio entre x et x

?

On consid` ere la base de donn´ ees BreastCancer disponible sous le package mlbench.

3. Eliminer les cas pour lesquels il y a des donn´ ees manquantes. S´ eparer le jeu de donn´ ees en un jeu d’apprentissage et un jeu test, faisant respectivement 2/3 et 1/3 du jeu initial.

4. Appliquer le mod` ele logit aux donn´ ees du jeu d’apprentissage. Inter- pr´ eter les r´ esultats.

5. Regarder l’aide de la fonction step. L’appliquer aux donn´ ees.

7 6. Quelles sont les variables qui influent sur Y =Class ? Interpr´ eter les

odds-ratio.

7. Estimer l’erreur de pr´ evision ` a l’aide du jeu d’apprentissage.

Chapitre 3

Expression diff´ erentielle et tests multiples

3.1 Tests Multiples : d´ efinitions et illustration sur jeu simul´ e

Question 1.1

Simuler un jeu de donn´ ees portant sur 5000 g` enes et deux conditions telles qu’on dispose de 10 r´ eplicats dans chacune d’elle. On suppose l’ind´ e- pendance entre tous les g` enes et tous les r´ eplicats.

Dans la premi` ere condition, chacun des g` enes a une expression, que nous qualifierons de normale, qui suit une loi N (500, 100). Dans la seconde condi- tion, chaque g` ene a une probabilit´ e de 0.01 d’ˆ etre sur-exprim´ e et une proba- bilit´ e 0.01 d’ˆ etre sous-exprim´ e. Suivant qu’il est sous-exprim´ e, rest´ e normal ou sur-exprim´ e, son expression dans la condition 2 suit une loi N (400, 100), N (500, 100) ou N (600, 100).

La simulation sera stock´ ee sous la forme d’un tableau ` a 5000 lignes et 21 colonnes contenant de gauche ` a droite les dix r´ eplicats de la condition 1, les dix r´ eplicats de la condition 2 puis une variable ´ egale ` a −1, 0 ou 1 indiquant le v´ eritable ´ etat du g` ene dans la condition 2 (sous-exprim´ e, normal, sur- exprim´ e).

On notera que le jeu de donn´ ees simul´ ees est une simplification extrˆ eme de la r´ ealit´ e : toutes les moyennes et variances sont ´ egales pour un ´ etat donn´ e ; la sur ou sous-expression touche tous les g` enes de la mˆ eme fa¸ con ; le changement d’expression n’afecte que la moyenne alors qu’il peut en r´ ealit´ e affecter uniquement la variance, ou les deux ; les expressions de g` enes sont suppos´ ees ind´ ependantes entre elles (niant l’existence de r´ egulations). Ce jeu simplifi´ e sera cependant suffisant ici pour illustrer la probl´ ematique des tests multiples.

9

Question 1.2

On ne s’int´ eresse dans un premier temps qu’au g` ene num´ ero 1. Quels tests pouvez-vous proposer afin de d´ ecider s’il est diff´ erentiellement exprim´ e ? Question 1.3

Appliquer l’un de ces tests, au taux de 5% ` a l’ensemble des g` enes du jeu de donn´ ees.

Fonction R : Lire l’aide de la fonction apply et utiliser la commande apply(sdata,1,function(x) t.test(x[1:10],x[11:20])$p.value).

Examinez la liste des g` enes retenus. Que pouvez-vous en dire ?

En particulier, quel est le nombre de faux positifs, c’est-` a-dire le nombre de g` ene qui ne sont pas diff´ erentiellement exprim´ es mais qui sont s´ electionn´ es comme tels par la proc´ edure de test. Ce r´ esultat est-il surprenant ?

Afin de r´ esoudre le probl` eme de la surabondance de faux positifs, il faut rendre les tests plus stringents, c’est-` a-dire rendre plus difficile le fait de d´ ecider H

.

La question se pose alors de savoir quel crit` ere on cherche ` a maˆıtriser (dans le test simple, on maˆıtrise l’erreur de premi` ere esp` ece ` a travers le choix de α).

Pour cela, introduisons la table de comptage suivante : H

accept´ e H

rejet´ e

H

vrai T N F P m

H

faux F N T P m − m

m − R R m

3.1.1 Maˆıtrise du FWER

D´ efinition 3.1. Le Family Wise Error Rate ou FWER est la probabilit´ e d’avoir au moins un faux positif.

F W ER = P (F P ≥ 1)

Il peut ˆ etre relax´ e en k-FWER qui est la probabilit´ e d’avoir au moins k faux positifs.

k − F W ER = P (F P ≥ k)

Soit α ∈ [0, 1]. Il existe plusieurs fa¸ cons de choisir la confiance de chaque

test individuel afin d’obtenir un FWER inf´ erieur ` a α. On note m le nombre

de tests ` a effectuer.

3.1. TESTS MULTIPLES : D ´ EFINITIONS ET ILLUSTRATION SUR JEU SIMUL ´ E11

Question 1.4 : Proc´ edure de Bonferroni

On effectue chaque test avec un risque de premi` ere esp` ece de

. D´ e- montrer que le FWER est bien inf´ erieur ` a α, quel que soit les relations de d´ ependance entre variables.

L’appliquer au jeu de donn´ ees simul´ ees. Commenter.

Question 1.5 : Proc´ edure de Sid` ak

Sous l’hypoth` ese d’ind´ ependance des variables test´ ees, on effectue chaque test avec un risque de premi` ere esp` ece de 1 − (1 − α)

. D´ emontrer que le FWER est bien inf´ erieur ` a α. Montrer que cette correction est moins conservatrice que celle de Bonferroni. Que peut-on en dire si m est grand ?

L’appliquer au jeu de donn´ ees simul´ ees. Commenter.

Question 1.6 : Proc´ edure de Holm-Bonferroni 1. effectuer les m test et ordonner les m p-valeurs obtenues

p

≤ p

≤ . . . ≤ p

2. d´ eterminer I = max{k|∀i ≤ k, p

≤

} 3. on rejette les p-valeurs inf´ erieures ` a

.

Montrer que cette correction est moins conservatrice que celle de Bon- ferroni. L’appliquer au jeu de donn´ ees simul´ ees. Commenter.

3.1.2 FDR

On constate que pour des valeurs grandes de m, ce qui est typiquement le cas en g´ enomique quand on teste un grand nombre de g` enes simultan´ ement, le contrˆ ole du FWER entraˆıne des test tr` es conservatifs, et possiblement des listes vides de g` enes diff´ erentiellement exprim´ es.

Un alternative moins conservatrice est de s’int´ eresser non pas au nombre absolu de faux positifs mais ` a leur proportion de parmi les positifs.

D´ efinition 3.2. La False Discovery Proportion ou FDP est la proportion de faux positifs parmi les positifs :

F DP = F P F P + T P

Cette quantit´ e est par d´ efinition une variable al´ eatoire. Son esp´ erance est appel´ ee False Discovery Rate ou FDR.

F DR = E ( F P

F P + T P )

Question 1.7 : Proc´ edure de Benjamini-Hochberg 1. effectuer les m test et ordonner les m p-valeurs obtenues

p

≤ p

≤ . . . ≤ p

2. d´ eterminer I = max{i|p

≤ α

}

3. on rejette les p-valeurs inf´ erieures ` a α

.

Appliquer la m´ ethode de Benjamini et Hochberg au jeu de donn´ ees si- mul´ ees. D´ eterminer, ` a l’aide de la colonne donnant le vrai ´ etat des g` enes, la vraie valeur de la FDR obtenue. Commenter les r´ esultats comparativement

`

a ceux obtenus avec les proc´ edures de contrˆ ole de la FWER.

Question 1.8 : p-valeur ajust´ ees

Les corrections pr´ ec´ edentes peuvent ˆ etre vues diff´ eremment : par exemple, la correction de Bonferroni peut ˆ etre vue comme le remplacement de la p- valeur p

du g` ene i par la p-valeur ajust´ ee p

= min(mp

, 1) ` a laquelle on applique un test habituel de risque α.

Suivant les auteurs, les corrections pour test multiple sont pr´ esent´ ees sous cet angle. En particulier, les corrections introduites dans ce TP sont disponibles dans la fonction p.adjust.

Red´ eterminer les listes de g` enes diff´ erentiellement exprim´ es ` a l’aide de cette fonction.

3.2 Application

Question 2.1 : Donn´ ees

Charger les donn´ ees Golub M erge disponibles dans le package golubEsets de Bioconductor.

Que contiennent ces donn´ ees ? Question 2.2 : filtrage

La matrice des expressions se trouve en tapant exprs(Golub M erge).

En tracer l’histogramme. Pourquoi certaines valeurs sont-elles aberrantes ? Cela est en fait dˆ u au fait que le bruit de fond a d´ ej` a ´ et´ e enlev´ e (et parfois sur-estim´ e).

A la suite des auteurs de l’article d’origine, remplacez toutes les valeurs inf´ erieures ` a 100 par 100 et toutes celles sup´ erieures ` a 16000 par 16000.

On souhaite ensuite enlever les g` enes dont l’expression n’est pas assez

importante ou dont la variance est trop faible. Pour cela, d´ eterminer l’ex-

pression maximale emax et minimale emin de chaque g` ene et ne garder que

les g` enes tels que

> 5 et emax − emin > 500.

3.2. APPLICATION 13 Puis passez les donn´ ees en logarithme en base 10.

Enfin, ` a l’aide de la fonction scale, centrez et r´ eduisez les donn´ ees par g` ene. Cette op´ eration aura-t-elle une influence sur le fait que les g` enes sont consid´ er´ es comme diff´ erentiellement exprim´ es ou non ` a l’aide d’un t-test ? Question 2.3 : Analyse diff´ erentielle

R´ ealiser l’analyse diff´ erentielle ` a l’aide d’un test de Student et d’une FDR

` a 1%.

Cr´ eer une sous-matrice DEgene des donn´ ees pr´ ec´ edentes en ne gardant que les g` enes diff´ erentiellement exprim´ es.

Question 2.4 : Visualisation

A l’aide de la fonction heatmap de la librairie gplots, repr´ esenter l’ex- pression des g` enes diff´ erentiellement exprim´ es. Que pouvez-vous dire des conditions AML et ALL ?

Question 2.5 : Signature

Gardez uniquement les 50 g` enes les plus diff´ erentiellement exprim´ es (la fonction *order* vous sera utile). On se demande si cet ensemble de 50 g` enes peut ˆ etre une bonne signature du type de cancer, c’est-` a-dire permet bien de s´ eparer les deux types de conditions.

Pour r´ epondre plus avant ` a cette question, mettre en oeuvre une m´ ethode de classification, avec ensemble d’apprentissage et test, et tester son effica- cit´ e. Toute m´ ethode est possible (SVM, k-means, forˆ et al´ eatoire, r´ egression logistique ...).

Question 2.6 : Analyse d’enrichissement

Installer le package hu6800.db de Bioconductor. Ce package permet de retrouver notamment les correspondances entre les noms de *probes* de la puce Affymetrix Hgu6800 (sur laquelle a ´ et´ e faite cette exp´ erience) et les noms de g` enes dans les bases de donn´ ees, dont ENSEMBL.

Les commandes

> DElist <- rownames(DEgene)

> DEensemblIds <- mget(DElist, envir=hu6800ENSEMBL)

> DEensembllist <- unlist(unname(DEensemblIds[!is.na(DEensemblIds)]))

> write.table(DEensembllist,file= ' DElist.txt ' ,row.names=FALSE,col.names=FALSE,quote=FALSE) permettent de r´ ecup´ erer les noms des g` enes diff´ erentiellement exprim´ es

sur la puce (ligne 1), leur ´ equivalent dans la base ENSEMBL (ligne 2) et de

supprimer les g` enes n’´ etant pas pr´ esent dans ENSEMBL (ligne 3). La ligne

4 ´ ecrit la liste des identifiants ENSEMBL dans un fichier *DElist.txt*.

Appliquer ces quatre lignes et faire de mˆ eme avec l’ensemble des g` enes de la puce (l’univers) et les cinquante g` enes le plus diff´ erentiellement exprim´ e.

Rendez-vous ensuite sur la page du serveur *GOrilla* permettant de r´ ealiser des analyses d’enrichissement GO en ligne.

R´ ealisez l’enrichissement de l’ensemble des g` enes diff´ erentiellement ex- prim´ es puis de des cinquante meilleurs, par rapport ` a l’univers.

R´ ealisez ensuite l’enrichissement propos´ e sur le serveur GOrilla avec une

seule liste. Quel en est l’avantage ?

Chapitre 4

R´ eduction de dimension

Exercice 4.1. Maximisation de la variance expliqu´ ee Soit X une matrice de donn´ ees. On consid` ere le probl` eme

argmax{k XQk

|Q projection orthogonale de rang au plus r}

o` u kAk

= tr(A

A).

On rappelle que pour toute matrice de projection orthogonale Q de rang r, il existe une matrice orthogonale U telle que

Q = U

I

0 0 0

U

1. Soit x

, . . . , x

les points du nuage X. Une autre formulation du pro- bl` eme de l’ACP est de chercher le sous-espace de dimension r tel que le nuage projet´ e sur cet espace soit aussi proche que possible du nuage X. En d’autres termes, on cherche ` a minorer P

i=1

kx

− q(x

)k

sur l’ensemble des projections orthogonales q vers un espace de dimension r. Justifier que le probl` eme pos´ e dans cet exercice est ´ equivalent.

2. Justifier que X

X peut s’´ ecrire sous la forme P

Λ

P o` u P est ortho- normale et Λ est une matrice diagonale ` a coefficients rang´ es par ordre d´ ecroissant.

3. En d´ eduire qu’il est ´ equivalent de r´ esoudre le probl` eme

argmax{k ΛQk

|Q projection orthogonale de rang au plus r}

4. Montrer que

k ΛQk

=

p

X

k=1

λ

q

et justifier que 0 ≤ q

≤ 1 pour tout k.

15

5. Justifier que si Q est de rang r, tr(Q) = r. Montrer que la matrice I

0

0 0

est une solution du probl` eme.

6. Justifier que l’ACP peut ˆ etre r´ esolu indiff´ eremment par l’approche axe par axe ou par la diagonalisation de X

X.

Exercice 4.2. On consid` ere dans ce TD les donn´ ees Colon du package plsgenomics. Le but de ce TD est de construire des r` egles pour d´ etermi- ner ` a l’aide de l’expression g´ enomique le type de cancer en pr´ esence.

1. Donn´ ees Que contiennent ces donn´ ees ? Justifier le fait qu’elles sont de grande dimension.

Cr´ eer un jeu d’apprentissage et un jeu test en gardant chaque ´ echan- tillon dans le jeu d’apprentissage avec probabilit´ e

.

Ecrire un mod` ele logistique pour l’´ etablissement du type en fonction des expressions de tous les g` enes. Est-il possible/souhaitable d’ap- prendre un tel mod` ele sur ces donn´ ees.

2. R´ eduction de dimension par ACP Proc´ eder ` a une ACP (on pourra utiliser la fonction pcr du package pls par exemple). Combien faut-il utiliser de composantes pour expliquer 95% de la variance du nuage ? L’´ el´ ement loadings du r´ esultat de pcr permet de r´ ecup´ erer la matrice de r´ eduction de dimension. L’appliquer ` a l’ensemble des g` enes pour r´ ecup´ erer un probl` eme de classification en petite dimension.

Apprendre une classification dans ce nouveau jeu ` a l’aide d’un r´ egres- sion logistique (on utilisera la fonction glm).

Pr´ edire les types de cancer du jeu test ` a l’aide de ce mod` ele et com- menter.

Remarque : Il est possible d’utiliser predict directement que le mo- d` ele appris avec pcr. Cependant, c’est alors une r´ egression lin´ eaire gaussienne qui est appliqu´ ee, ce qui n’est pas appropri´ e pour pr´ edire une variable binaire.

3. R´ eduction de dimension par PLS Reprendre la question pr´ ec´ edente en utilisant une PLS plutˆ ot qu’une ACP. Quelle en est l’avantage ` a priori. Cela se confirme-t-il au niveau du nombre de composantes re- tenues ?

4. Pr´ e-s´ election. Une pr´ e-s´ election des g` enes via une proc´ edure de tests multiples est possible en amont de l’application des m´ ethodes de r´ e- duction de dimension. Quelles en seraient les avantages ` a priori. La mettre en pratique.

Exercice 4.3. ACP probabiliste On consid` ere le mod` ele de l’ACP probabi- liste :

x

= µ

+ Γ

z

+

17 avec

— z ∼ N (0

, I

)

— ∼ N (0

, σ

I

)

— z et sont ind´ ependants.

On rappelle qu’une variable Y ∈ R

suit une loi gaussienne multivari´ ee si, pour tout vecteur a ∈ R

, a

Y suit une loi normale univari´ ee.

1. Justifier que x suit une loi normale multivari´ ee N (µ, C) avec C = ΓΓ

+ σ

I

.

2. On consid` ere que un ´ echantillon (x

, . . . , x

) et sa matrice variance- covariance empirique

S = 1 N

N

X

n=1

(x

− µ)(x

− µ)

Montrer que la log-vraisemblance de l’´ echantillon s’´ ecrit

` = − N

2 p log(2π) + log | det C| + tr(C

S)

Chapitre 5

R´ egression p´ enalis´ ee

Exercice 5.1. Montrer que la fonction objectif d’une r´ egression Elastic-Net (et donc d’une r´ egression Ridge ou Lasso) est une focntion convexe.

Exercice 5.2. On consid` ere les donn´ ees Colon de plsgenomics.

On souhaite comparer sur ces jeux de donn´ ees la pr´ ediction faite ` a l’aide d’un mod` ele lin´ eaire p´ enalis´ e avec celle faite en petite dimension suite ` a une PLS p´ enalis´ ee. Ces deux m´ ethodes sont disponibles respectivement dans les fonctions glmnet du package glmnet et plsr de plsgenomics.

1. Appliquer la fonction glmnet par d´ efaut (avec 100 valeurs diff´ erentes de λ) et tracer les trajectoires des coefficients en appliquant plot au r´ esultat.

Faire cela pour alpha qui vaut 1 ou 0.5. A quoi correspondent ces deux cas ? Que peut-on des deux figures ? Est-ce attendu ?

2. En utilisant la fonction glmnet, proposer un mod` ele de pr´ ediction.

3. Proposer ´ egalement un mod` ele de pr´ ediction bas´ e sur plsr.

4. Appliquer ces deux mod` eles et les comparer, en termes de qualit´ e de la pr´ ediction et de nombre de g` enes s´ electionn´ es, sur la base d’un jeu d’apprentissage et d’un jeu test.

19

Chapitre 6

Inf´ erence de r´ eseau - package huge

Le but de ce TP est d’´ etudier l’inf´ erence de r´ eseau, ` a travers des simula- tions et d’une application r´ eelle, ` a l’aide du package huge disponible sur le CRAN. Commncer par installer ce package.

6.1 Simulations

Question 1 : La fonction huge.generator permet de g´ en´ erer des graphes d’interaction entre g` enes et des expressions correspondantes.

G´ en´ erer des tels graphes avec les structures random, hub et scale-free.

Ces derni` eres correspondent plus ` a la structure observ´ ee sur les r´ eseaux r´ eels et visualiser les objets g´ en´ er´ es.

Comment complexifier/simplifier la tˆ ache d’inf´ erence ?

Question 2 : Le but de cette question est d’illustrer la diff´ erence entre corr´ elation et corr´ elation partielle.

— G´ en´ erer un graphe d’interaction sur dix noeuds avec un hub. On appelle hub le hub et nei1 et nei2 deux de ses voisins.

— Utiliser la fonction lm pour d´ eterminer un mod` ele lin´ eaire expli- quant les expressions de nei1 et nei2 en fonction de celle de hub.

Faire de mˆ eme pour nei2 en fonction de nei1. Interpr´ eter les si- gnificativit´ es.

— La corr´ elation partielle correspond ` a la corr´ elation entre deux va- riables ´ etant donn´ ee toutes les autres. Pour estimer celle entre nei1 et nei2, utiliser lm pour d´ eterminer deux mod` eles lin´ eaires gaussiens expliquant ces deux g` enes en fonction de tous les autres sauf ces deux-l` a. Stocker les r´ esidus associ´ es puis apprendre un dernier mod` ele lin´ eaire d’un r´ esidu en fonction de l’autre.

Commenter.

21

Question 3 : Le fichier external functions.R contient une fonction one.simu qui g´ en` ere des jeu de donn´ ees pour 25 g` enes et un nombre d’´ echan- tillons croissants. Il contient aussi les fonctions perf.roc et perf.auc.

Que fait la fonction one.simu ? A quoi correspondent les m´ ethodes ct et glasso de la fonction huge ? Pour la construction des courbes ROC, quel est le param` etre qui varie ?

Appliquer cette fonction ` a la simulation d’un jeu de donn´ ees et afficher les r´ esultats ` a l’aide de la focntion ggplot du package ggplot2 : out <- out.simu(1)

ggplot(out, aes(x=sample.size, y=score,group=variable,colour=variable)) + geom_point(alpha=.5) + coord_trans(x="log10")

Question 4 : (optionnelle car gourmande en temps) Utiliser les fonctions pr´ ec´ edentes et la fonction mclapply du package parallel pour obtenir les boxplots des AUC plutˆ ot qu’une estimation ponctuelle.

6.2 Donn´ ees r´ eelles

On consid` ere les donn´ ees sur le cancer du sein de Guedj et al. 2011, qui sont r´ eparties en deux sous-types ER- et ER+ (ER signifiant Estrogen Receptor).

Le but est d’inf´ erer les r´ eseau d’interaction entre g` enes dans les deux types pour ´ etudier les diff´ erences. Cependant, pour simplifier la tˆ ache d’apprentissage, on va se restreindre aux candidats les plus probables pour une diff´ erence, ` a savoir les g` enes diff´ erentiellement exprim´ es.

Commencez par charger les donn´ ees :

load ("data_school/breast_cancer_guedj11.RData") load ("data_school/gen_name.RData")

gene.name <- unlist(gene.name) data.raw <- expr

Question 5 : S´ electionner les g` enes diff´ erentiellement exprim´ es avec une FDR de 0.05, manuellement ou ` a l’aide du package limma.

Question 6 : R´ eduire les donn´ ees au 100 g` enes les plus diff´ erentielle- ment exprim´ es. R´ ealiser l’apprentissage des r´ eseaux r´ eduits ` a ces cent g` enes dans les types ER+ et ER-.

La fonction huge.select permet de choisir le meilleur param` etre de r´ egularisation λ. Utiliser avec le crit` ere ebic pour le choix.

Question 7 : Identifier les arˆ etes issues de ESR1 qui ne sont pr´ esentes que dans le r´ eseau ER+.

Question 8 : D´ eterminer si leur pr´ esence est stable en faisant du

sous-´ echantillonnage. Rep´ erer notamment la pr´ esence de FOXA1

et faire un recherche dans la base GeneCards ou Entrez.

6.2. DONN ´ EES R ´ EELLES 23

Question 9 : D´ eterminer la diff´ erence entre la corr´ elation d’ESR1 et

chacun des autres 100 g` enes s´ electionn´ es dans les deux condi-

tions. Regarder o` u se trouve FOXA1 dans la distribution de ces

diff´ erences et commenter.

Chapitre 7

R´ eseau de neurones - TP1

Un premier exemple de r´ eseau ` a entraˆıner

Donn´ ee x Sortie y b

Couche cach´ ee Couche

d’entr´ ee

Couche de sortie

Figure 7.1 – R´ eseau de neurones ` a deux couches et 3 neurones interm´ e- diaires.

On propose dans ce qui suit de cr´ eer et d’entraˆıner un r´ eseau tr` es simple

`

a deux couches (voir la Figure 7.1) et d = 3 neurones. Ce r´ eseau prend un scalaire x en entr´ ee et donne un scalaire y en sortie. La premi` ere couche du r´ eseau est repr´ esent´ ee par une matrice de poids W

de taille 3 × 1 et un vecteur d’offset b

` a 3 lignes. On utilise une fonction d’activation tanh. A la sortie de la premi` ere couche on observe donc

A

= tanh(Z

) avec Z

= W

x + b

La matrice de poids W

permettant de passer de la couche cach´ ee ` a la sortie y a donc 1 lignes et 3 colonnes, et le vecteur d’offset b

est un scalaire. La sortie y b est donc li´ ee ` a A

par la relation

b y = W

A

+ b

. I Question 1 :

25

1. Quelle est la dimension de A

, ` a la sortie de la premi` ere couche du r´ eseau ?

2. Ecrire la fonction compl` ete y(x, W b

, b

, W

, b

) repr´ esent´ ee par ce r´ eseau.

On souhaite utiliser ce r´ eseau pour faire de la r´ egression ` a partir de M observations {(x

, y

)}

. On chercher donc les param` etres (W

, b

, W

, b

) qui minimisent la fonction de perte quadratique

L(W

, b

, W

, b

) = 1 2

M

X

m=1

k y(x b

, W

, b

, W

, b

) − y

k

.

I Question 2 :

1. Quelle est la d´ eriv´ ee de L par rapport ` a b y ? 2. Quelle est la d´ eriv´ ee de L par rapport ` a W

? 3. Quelle est la d´ eriv´ ee de L par rapport ` a b

? 4. Quelle est la d´ eriv´ ee de L par rapport ` a A

? 5. Quelle est la d´ eriv´ ee de L par rapport ` a Z

? 6. Quelle est la d´ eriv´ ee de L par rapport ` a W

? 7. Quelle est la d´ eriv´ ee de L par rapport ` a b

?

Nous sommes maintenant en mesure d’impl´ ementer et d’entraˆıner le r´ e- seau. On commence par importer les diff´ erentes libraries n´ ecessaires au TP.

import numpy as np

import matplotlib.pyplot as plt import math

Pour cr´ eer la base des donn´ ees d’entraˆınement, on peut prendre par exemple, pour les x

, 30 points uniform´ ement r´ epartis sur l’intervalle [−1, 1] et y

= f (x

) avec f (x) = x

.

x = np.linspace(-1,1,30);

x=x[:,np.newaxis].T;

y = x**2

On initialise le r´ eseau avec des poids faibles mais al´ eatoires.

h = 3 # size of hidden layer W1 = 0.1*np.random.randn(h,1);

B1 = np.zeros((h,1));

W2 = 0.1*np.random.randn(1,h);

B2 = np.zeros((1,1));

27 Pour entraˆıner le r´ eseau, on utilise dans un premier temps un pas de 0.01.

learning_rate = 0.01 for t in range(10000):

# Forward pass: compute predicted y z = np.dot(W1,x)+B1

a = np.tanh(z)

y_pred = np.dot(W2,a)+B2

# Compute and print loss

loss = np.square(y_pred - y).sum()

# Backprop to compute gradients of W1, W2, B1 and B2 with respect to loss grad_y_pred = 2.0 * (y_pred - y)

grad_W2 = ...

grad_B2 = ...

grad_a = ...

grad_z = ...

grad_W1 = ...

grad_B1 = grad_z.sum(axis=1,keepdims=True)

# Update weights

W1 -= learning_rate * grad_W1 W2 -= learning_rate * grad_W2 B1 -= learning_rate * grad_B1 B2 -= learning_rate * grad_B2

On peut maintenant comparer la fonction apprise par notre r´ eseau avec la fonction f utilis´ ee pour cr´ eer les donn´ ees.

xt = np.linspace(-1,1,200); xt=xt[:,np.newaxis].T;

yt = np.dot(W2,np.tanh(np.dot(W1,xt)+B1))+B2;

plt.plot(x.flatten(),y.flatten()) plt.plot(xt.flatten(),yt.flatten()) plt.show()

I Question 3 :

1. Utiliser le mˆ eme r´ eseau pour les fonctions f (x) = cos(x) et f (x) = H(x) (Heaviside) sur le mˆ eme intervalle. La fonction apprise par le r´ eseau est-elle une bonne approximation de la fonction f en dehors de l’intervalle [−1, 1] ?

2. Tenter de remplacer la fonction d’activation tanh par une autre fonc-

tion propos´ ee dans le cours. Quelles lignes du code doivent changer ?

Qu’observez-vous ?

Chapitre 8

R´ eseaux de neurones - TP2

On commence par importer les diff´ erentes libraries n´ ecessaires au TP.

import numpy as np

import matplotlib.pyplot as plt import math

Dans ce TP, on s’int´ eresse ` a un probl` eme de classification supervis´ ee dans R

. Etant donn´ ee une base d’apprentissage de points du plan, class´ es en deux classes C

et C

, on souhaite apprendre une fonction permettant de pr´ edire la classe de n’importe quel point du plan (cette fonction segmente donc R

en deux).

Donn´ ees d’apprentissage. On cr´ ee dans ce qui suit un exemple simple de donn´ ees du plan R

divis´ ees en deux classes bien distinctes mais pas lin´ eairement s´ eparables (voir le Figure 8.1).

N = 100 # number of points per class p = 2 # dimensionality of data K = 2 # number of classes

X = np.zeros((N*K,p)) # data matrix (each row = single example) y = np.zeros(N*K) # class labels

ix = range(0,N) r = 0.5 # radius

t = np.random.rand(N)*math.pi-math.pi/2 # theta

X[ix] = np.c_[-0.3+2*r*np.cos(t), r*np.sin(t)] + np.random.randn(N,p)*0.02 y[ix] = 0

ix2 = range(N,2*N)

t = np.random.rand(N)*math.pi+math.pi/2 # theta

X[ix2] = np.c_[+0.3+2*r*np.cos(t), -0.5+r*np.sin(t)] + np.random.randn(N,2)*0.02 y[ix2] = 1

29

On visualise ensuite les donn´ ees fig = plt.figure()

plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.cool) plt.show()

I Question 4 :

1. Expliquez comment les donn´ ees sont cr´ e´ ees.

Figure 8.1 – Donn´ ees d’apprentissage ` a gauche. Segmentation du plan ap- prise par le r´ eseau de neurones ` a droite.

Un r´ eseau ` a deux couches pour la classification ` a entraˆıner

Structure du r´ eseau. Pour apprendre notre fonction de classification,

on propose d’entraˆıner un r´ eseau de neurones ` a deux couches et d neurones

sur la couche interm´ ediaire. Ce r´ eseau prend un point x = (x

, x

) de R

en

entr´ ee et donne un scalaire y entre 0 et 1 en sortie, repr´ esentant la probabilit´ e

que le point x appartienne ` a la classe C

.

31 La premi` ere couche du r´ eseau est repr´ esent´ ee par une matrice de poids W

de taille d×2 et un vecteur d’offset b

` a d lignes. On utilise une fonction d’activation g (par exemple tanh ou ReLU). A la sortie de la premi` ere couche on observe donc

A

= g(Z

) avec Z

= W

x + b

La matrice de poids W

permettant de passer de la couche cach´ ee ` a la couche de sortie a 1 lignes et d colonnes, et le vecteur d’offset b

est un scalaire. On applique sur la couche de sortie une fonction d’activation

σ(z) = 1 1 + e

pour obtenir une valeur entre 0 et 1. La sortie b y est donc li´ ee ` a A

par la relation

y b = σ(Z

) avec Z

= W

A

+ b

.

Pour simplifier les notations, on note dans ce qui suit θ = (W

, b

, W

, b

) l’ensemble des param` etres du r´ eseau.

I Question 5 :

1. Ecrire la fonction compl` ete b y(x, θ) repr´ esent´ ee par ce r´ eseau.

On souhaite utiliser ce r´ eseau pour faire de la r´ egression ` a partir de M observations {(x

, y

)}

. Les x

sont des points de R

et les y

valent 0 ou 1 selon que x

appartienne ` a la classe C

ou C

. On cherche les param` etres θ = (W

, b

, W

, b

) qui minimisent la fonction de perte d’entropie crois´ ee

L(θ) = X

m

− y

log y(x b

, θ) − (1 − y

) log(1 − y(x b

, θ)) .

Pour calculer le gradient de L par rapport aux diff´ erents param` etres de θ, on raisonne par backpropagation (on pourra s’inspirer fortement des r´ eponses du TP1 pour faire cette partie).

I Question 6 :

1. Quelle est la d´ eriv´ ee de L par rapport ` a y b ?

2. Quelle est la d´ eriv´ ee de L par rapport ` a Z

?

3. Quelle est la d´ eriv´ ee de L par rapport ` a W

?

4. Quelle est la d´ eriv´ ee de L par rapport ` a b

?

5. Quelle est la d´ eriv´ ee de L par rapport ` a A

?

6. Quelle est la d´ eriv´ ee de L par rapport ` a Z

?

7. Quelle est la d´ eriv´ ee de L par rapport ` a W

?

8. Quelle est la d´ eriv´ ee de L par rapport ` a b

?

Nous sommes maintenant en mesure d’impl´ ementer et d’entraˆıner le r´ e- seau. On commence par mettre les donn´ ees au bon format et par initialiser les param` etres du r´ eseau al´ eatoirement.

x = X.T

y = np.reshape(y,(1,2*N))

d = 10 # essayer avec 10 neurones pour commencer W1 = 0.01 * np.random.randn(d,p)

B1 = np.zeros((d,1))

W2 = 0.01 * np.random.randn(1,d) B2 = np.zeros((1,1))

Pour entraˆıner le r´ eseau, on utilise dans un premier temps un pas de 0.01.

learning_rate = 0.01

On entraˆıne ensuite le r´ eseau (cette partie est tr` es semblable ` a ce que l’on a fait dans le TP pr´ ec´ edent.

for t in range(2000):

# Forward pass: compute predicted y z = np.dot(W1,x)+B1

a = np.tanh(z) z2 = ...

y_pred = 1/(1+np.exp(-z2)) # Sigmoid Activation funtion

# Compute and print loss

loss= (-np.log(y_pred)*y-np.log(1-y_pred)*(1-y)).sum()

# Backprop to compute gradients of W1, W2, B1 and B2 with respect to loss grad_y_pred = ...

grad_z2 = ...

grad_W2 = ...

grad_B2 = ...

grad_a = ...

grad_z = ...

grad_W1 = np.dot(grad_z,x.T)

grad_B1 = grad_z.sum(axis=1,keepdims=True)

# Update weights

W1 -= learning_rate * grad_W1

W2 -= learning_rate * grad_W2

B1 -= learning_rate * grad_B1

B2 -= learning_rate * grad_B2

33 On peut maintenant calculer la pr´ ecision de la fonction de classification apprise sur la base d’apprentissage.

predicted_class = (y_pred > 0.5)

print("training accuracy: %.2f",np.mean(predicted_class == y)) Puis visualiser la segmentation du plan r´ esultante.

h = 0.02

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1 y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1 xx, yy = np.meshgrid(np.arange(x_min, x_max, h),

np.arange(y_min, y_max, h))

Z = np.dot(np.tanh(np.dot(np.c_[xx.ravel(), yy.ravel()], W1.T) + B1.T), W2.T) + B2.T Z = (1/(1+np.exp(-Z))>0.5)

Z = Z.reshape(xx.shape) fig = plt.figure()

plt.contourf(xx, yy, Z, cmap=plt.cm.winter, alpha=0.8)

plt.scatter(X[:, 0], X[:, 1], c=np.reshape(y,[y.size]), s=40, cmap=plt.cm.cool) plt.xlim(xx.min(), xx.max())

plt.ylim(yy.min(), yy.max()) plt.show()

I Question 7 :

1. Entraˆıner plusieurs fois le r´ eseau, ` a partir d’initialisations diff´ erentes.

Qu’observez-vous ?

2. Ajouter une ligne dans le code permettant d’afficher la valeur de la fonction d’erreur toutes les 100 it´ erations. Commentez les r´ esultats.

3. Tenter de remplacer la fonction d’activation tanh par la fonction ReLU(x) = max(x, 0). Quelles lignes du code doivent changer (attention de chan- ger ´ egalement le code pour visualiser le r´ esultat) ? Qu’observez-vous ?

Initiation ` a Pytorch

On a cod´ e le r´ eseau pr´ ec´ edent ` a la main, en utilisant seulement le package numpy de Python. Pour faciliter cette tˆ ache, il existe plusieurs packages sp´ ecialis´ es sous Python : Tensorflow, Theano, Keras, Pytorch (voir https:

//developer.nvidia.com/deep-learning-frameworks pour une liste de librairies sp´ ecialis´ ees en deep learning). On se propose d’utiliser Pytorch pour recoder le r´ eseau pr´ ec´ edent.

On commence par importer la librairie (il faut pour cela qu’elle soit install´ ee sur votre ordinateur).

import torch

from torch.autograd import Variable

On garde les donn´ ees d’apprentissage d´ ej` a cr´ e´ ees au d´ ebut du TP et on les met au bon format pour les utiliser avec Pytorch (cette librarie n’utilise pas des tableaux de valeurs comme numpy, il faut donc transformer tous les tableaux numpy dans un format appropri´ e).

x = X

y = np.reshape(y,(2*N,1))

xvar = Variable(torch.from_numpy(x)).type(torch.FloatTensor) yvar = Variable(torch.from_numpy(y)).type(torch.FloatTensor)

On d´ efinit ensuite le r´ eseau avec les lignes suivantes.

D_in, d, D_out = p, 10, 1 model = torch.nn.Sequential(

torch.nn.Linear(D_in, d), torch.nn.Tanh(),

torch.nn.Linear(d, D_out), torch.nn.Sigmoid(),

)

On d´ efinit la fonction de perte loss_fn = torch.nn.BCELoss()

Puis on entraˆıne le r´ eseau.

learning_rate = 1 for t in range(1000):

y_pred = model(xvar)

loss = loss_fn(y_pred, yvar) if t % 100 == 0:

print(t, loss.data[0]) model.zero_grad()

loss.backward()

for param in model.parameters():

param.data -= learning_rate * param.grad.data

I Question 8 : Expliquer ligne par ligne ce que font les morceaux de code pr´ ec´ edents.

On peut ` a nouveau ´ evaluer le score du r´ eseau entraˆın´ e sur la base d’ap- prentissage et afficher le r´ esultat.

scores = y_pred.data.numpy() predicted_class = (scores>0.5)

print("training accuracy: %.2f",np.mean(predicted_class == y))

35

# plot the resulting classifier h = 0.02

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1 y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1

xx, yy = np.meshgrid(np.arange(x_min, x_max, h),np.arange(y_min, y_max, h))

#Z = np.dot(np.maximum(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W1.T) + B1.T), W2.T) + B2.T X2 = np.zeros((xx.size,2))

X2[:,0] = np.reshape(xx,[xx.size]) X2[:,1] = np.reshape(yy,[yy.size])

X3 = Variable(torch.from_numpy(X2)).type(torch.FloatTensor) scores = model(X3).data.numpy()

Z = (scores>0.5)

Z = Z.reshape(xx.shape) fig = plt.figure()

plt.contourf(xx, yy, Z, cmap=plt.cm.winter, alpha=0.8)

plt.scatter(X[:, 0], X[:, 1], c=np.reshape(y,[y.size]),s=40, cmap=plt.cm.cool) plt.xlim(xx.min(), xx.max())

plt.ylim(yy.min(), yy.max()) plt.show()

Classification ` a 3 classes

On s’int´ eresse maintenant ` a un cas ` a 3 classes. On cr´ e´ e les donn´ ees d’apprentissage (x

, y

) avec y

∈ {0, 1, 2} de la mani` ere suivante : N = 100 # number of points per class

D = 2 # dimensionality K = 3 # number of classes

X = np.zeros((N*K,D)) # data matrix (each row = single example) y = np.zeros(N*K, dtype='uint8') # class labels

for j in range(0,K,1):

ix = range(N*j,N*(j+1))

r = np.linspace(0.0,1,N) # radius

t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]

y[ix] = j

# lets visualize the data:

plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral) plt.show()

I Question 9 : Cr´ eer ` a la main ou ` a l’aide de Pytorch un r´ eseau de

neurones ` a deux couches, d neurones sur la couche interm´ ediaire (prendre d

entre 10 et 30 par exemple) et 3 neurones de sortie pour apprendre une fonc- tion de classification ` a partir de ces donn´ ees. Comme fonction d’activation sur la couche interm´ ediaire, on pourra utiliser tanh. On d´ efinit la fonction de perte de la mani` ere suivante. Si y b = ( y b

. . . , y b

) est la sortie du r´ eseau de neurones :

L( b y, y) =

M

X

m=1

− log e

e

+ · · · + e

!

.

Chapitre 9

Remerciements

Merci ` a Julie Delon (intro et r´ eseaux de neurones) et Julien Chiquet (inf´ erence de r´ eseau) qui m’ont permis de reprendre des TPs qu’ils ont ´ ecrit.

37