IUP SID Ann ee 2011-2012 Techniques avanc ees de Data ... · plot(suit$nbappt,suit$revenu) # It eration du tirage de l’ echantillon bootstrap et des estimations des r egressions

IUP SID Annee 2011-2012

Techniques avancees de Data-Miningappliquees a la regression et a la discrimination

Prevision du pic d’ozone

Helene Milhem

Merci a Philippe Besse et Olivier Mestre pour leur partiticipation a la realisation de ce document.

2 Apprentissage Statistique Annee 2011-2012

Chapitre 1

Introduction

1.1 Presentation

Le travail propose dans ce document est le complement indispensable au cours sur l’apprentissage statistique. Son objectifest double :

1. illustrer l’emploi de chacune des methodes du cours sur un exemple en vraie grandeur,

2. mettre en œuvre une procedure systematique de comparaison des erreurs de previsions des differentes methodes sur unechantillon test.

Ce document est divise en deux parties (chapitres). La premiere experimente avec R les outils de simulations, echantillonnage,bootstrap, validation croisee, tandis que la deuxieme aborde des donnees plus realistes mais aussi plus complexes avec uneutilisation systematique de R pour apprendre differents modeles (regression, discrimination, reseaux de neurones, arbres,SVM, agregation de modeles).

1.2 Rapport

1.2.1 Contenu

Le rapport portera sur la deuxieme partie afin d’en faire un compte rendu synthetique tout en precisant et interpretantles resultats obtenus au cours des seances. L’objectif central est la comparaison des methodes afin de conseiller l’emploi dela plus pertinente sur le probleme considere.

Point important : La taille de l’echantillon test est relativement modeste et donc l’estimation des erreurs sujette a caution.On se propose d’ameliorer la precision par une procedure de validation croisee simplifiee. Elle est en effet facile a mettre enœuvre dans R. Il suffit de mettre une boucle autour des programmes precedemment realises afin de faire varier l’initialisationdu generateur de nombres aleatoires et donc d’obtenir, pour chaque methode et pour chaque initialisation, une estimationde l’erreur sur un echantillon test different.

Comparer les distributions des taux d’erreur obtenues pour chaque methode : boıtes a moustaches paralleles, analyse devariance pour tester l’effet du facteur “methode”.

1.2.2 Organisation

Comme tout rapport (de stage ou autre) le document (word avec feuille de style ou LATEX) doit etre succinct et contenir• couverture,• court resume incluant probleme et principaux resultats,• sommaire (automatique) incluant les annexes numerotees,• table des illustrations (facultative mais automatique)• introduction presentant les donnees, la problematique, l’objectif, le deroulement du travail,• developpement pas necessairement chronologique ni exhaustif du travail en insistant sur les points directement lies a

l’objectif. Illustrer chaque point par un graphique ou un tableau comparatif de resultats (erreurs de prevision).• conclusion,• bibliographie,• annexes (programmes realises).

3


Chapitre 2

Simulations, echantillonnnage, bootstrap,validation croisee

2.1 Introduction

Cette sceance propose une introduction aux outils de simulation avec R et a leur application en statistique : sondage,bootstrap, validation croisee pour l’estimation d’une erreur.

2.2 Simulation de lois

La base de toute simulation est un generateur de nombres pseudo-aleatoires supposes distribues selon une loi discreteuniforme sur l’intervalle [0, 1]. Connaissant une valeur initiale (seed ou semence), une formule de recurrence a base decongruence (prime modulus multiplicative generator) est plus generalement utilisee a cette fin. Divers procedes permettentensuite de generer une variable pseudo-aleatoire suivant une autre loi (binomiale, multinomiale, poisson, exponentielle,gamma, Cauchy, gaussienne...). C’est immediat lorsque l’expression analytique de l’inverse de la fonction de repartition estconnue. La methode dite de Box et Muller est utilisee pour simuler une loi normale.

L’etude de differentes distributions, de leur estimation est abordee par des simulations et des outils non-parametriques.

2.2.1 Quelques lois discretes

Bernoulli

Commencons par un tirage de pile ou face :

n=100

# Tirage avec remise

x=sample(c(-1,1), n, replace=T)

plot(x, type=’h’, main="Variable de Bernoulli")

Le generateur est pseudo-aleatoire et depend de l’initialisation. Faire plusieurs tirages et representations dans le casprecedent puis plusieurs tirages en initialisant prelablement le generateur a chaque fois. Remarque : utiliser la touche duclavier (fleche vers le haut) pour rappeler une commande precedente.

set.seed(123)

x=sample(c(-1,1), n, replace=T)

plot(x, type=’h’, main="Variable de Bernoulli")

Cela permet de retrouver la meme sequence de nombres pseudo-aleatoires et donc de reproduire, si necessaire, dessimulations identiques.

Avec des probabilites differentes :

x=sample(c(-1,1), n, replace=T, prob=c(.2,.8))

plot(x, type=’h’,main="Bernoulli, cas general")

5


Binomiale et estimation de densite

On peut “programmer” une distribution binomiale B(n, p) comme la somme de n variables de Bernoulli mais il existeaussi une fonction ad’hoc :

# Generation de 1000 valeurs suivant une $B(10,0.5)$

x=rbinom(1000,10,0.5)

# Trace de l’histogramme

hist(x,xlim=c(min(x),max(x)), probability=T, col=’blue’,nclass=max(x)-min(x),main="B(10,0.5)")

# Ajouter une estimation nom-parametrique de la densite

lines(density(x), col=’red’, lwd=2)

Un noyau gaussien est utilise par defaut pour cette estimation avec une optimisation du parametre de lissage (largeur defenetre).

Loi de Poisson

Les memes instructions sont reprises avec la generation d’une variable de Poisson de parametre 1.

x=rpois(1000,1)

hist(x,xlim=c(min(x),max(x)), probability=T, col=’blue’,nclass=max(x)-min(x),main="P(1)")

# Changer le parametre de la loi :

x=rpois(1000,20)

hist(x,xlim=c(min(x),max(x)), probability=T, col=’blue’,nclass=max(x)-min(x),main="P(20)")

D’autres lois sont disponibles : geometrique, hypergeometrique, negative binomiale, multinomiale.

2.2.2 Lois continues

Loi uniforme, de Cauchy

Quelques tirages suivant une loi uniforme :

round(runif(10), digits=3)

Estimation des densites dans le cas d’une loi uniforme

x=runif(1000)

hist(x, probability=T, col=’blue’,main="unif([0,1])")


Puis de celle d’un loi de Cauchy qui n’admet pas de moment.

x=rcauchy(1000)

hist(x, probability=T, col=’blue’,main="cauchy(1)")


Autres lois

De nombreuses autres fonctions de simulation sont prevues pour des lois, gaussienne, exponentielle, du Chi2, de Student,de Fisher, lognormale, de Weibul, Gamma, Beta, de Derichlet. En essayer quelques unes :

# Loi exponentielle

x=rexp(1000)

hist(x, probability=T, col=’blue’,main="exponentielle(1)")


# Loi normale

x=rnorm(1000)

hist(x, probability=T, col=’blue’,main="N(0,1)")


curve(dnorm(x,mean=0,sd=1), add=T, col=’green’, lwd=2)

Apprentissage Statistique Annee 2011-2012 7

Lois theoriques

Les expressions theoriques des densites sont aussi connues de R. Voici les traces des fonctions pour des lois du Chi2 avecdifferentes valeurs du parametre :

curve(dchisq(x,1), xlim=c(0,10), ylim=c(0,.6), col=’red’, lwd=3,main="chi2 1, 2, 3, 5")

curve(dchisq(x,2), add=T, col=’green’, lwd=3)

curve(dchisq(x,3), add=T, col=’blue’, lwd=3)

curve(dchisq(x,5), add=T, col=’orange’, lwd=3)

abline(h=0,lty=3)

abline(v=0,lty=3)

text(x=4,y=0.4,"chi2(1)",col="red",cex=1,pos=1)

text(x=4,y=0.4,"chi2(2)",col="green",cex=1,pos=2)

text(x=4,y=0.4,"chi2(3)",col="blue",cex=1,pos=3)

text(x=4,y=0.4,"chi2(4)",col="orange",cex=1,pos=4)

Loi des grands nombres

La moyenne empirique de n variables suivant une loi uniforme est calculee. Comparer la precision obtenue a traversplusieurs executions de

mean(runif(10))

mean(runif(1000))

Meme chose avec la loi de Cauchy “pathologique” :

mean(rcauchy(10))

mean(rcauchy(1000))

mean(rcauchy(100000))

2.2.3 Limite centrale et loi gaussienne

Estimer par un histogramme la densite d’une variable aleatoire, somme de 12 variables uniformes sur [0, 1].

x=rep(0,1000)

for (i in 1:1000) x[i]=sum(runif(12))

hist(x, col=’blue’, probability=T)

# Ajouter une estimation non parametrique de la densite


Comparer avec la densite theorique d’une loi N (6, 1).

curve(dnorm(x,mean=6,sd=1), add=T, col=’green’, lwd=2)

Commentaire sur la vitesse de convergence en loi de la moyenne empirique de n variables aleatoires i.i.d. d’esperance m etde variance σ2 vers une gaussienne de moyenne m et de variance σ2/n.

2.3 Echantillonnage

2.3.1 Aleatoire simple

L’etude de grandes bases de donnees necessite d’extraire un sous-ensemble par un echantillonnage aletoire simple dans labase afin de realiser des analyses ou mettre au point des programmes sur un echantillon representatif de taille raisonnable.Ce sondage est tres simple a realiser en R ; il est utilise pour diviser l’echantillon en deux parts aleatoires : echantillond’apprentissage et echantillon test. Le generateur est initialisee avec une semence specifique a chaque etudiant pour construiredes echantillons differents.


# Utiliser les trois derniers chiffre de son code INSEE

# comme initialisation du generateur

set.seed(xx)

npop=1000

# tirage de 200 indices sans remise

testi=sample(1:npop,200)

# Liste des indices restant qui n’ont pas ete tires

appri=setdiff(1:npop,testi)

Ces listes d’indices seront utilisees dans les prochains TPs pour extraire des echantillons d’apprentissage et de test afin decomparer entre elles les performances des differentes methodes dans leur capacite de prediction.

2.3.2 Avec remise ou bootstrap

Principe

Le bootstrap est une technique de reechantillonnage permettant de simuler la distribution d’un estimateur quelconquepour en apprecier le biais, la variance donc le risque quadratique ou encore pour en estimer un intervalle de confiance meme sila loi theorique est inconnue. Le principe consiste a estimer iterativement ce meme estimateur sur des realisations differentesde l’echantillon obtenus aleatoirement par n tirages avec remise dans l’echantillon initial.

Un echantillon bootstrap est facilement obtenu avec l’option replace=TRUE de la commande sample. Comparer :

sample(1:20,20)

sample(1:20, 20, replace=TRUE)

Regression simple

L’exemple elementaire ci-dessous genere une enveloppe pouvant s’interpreter comme une region de confiance de la droitede regression du revenu en fonction du nombre d’appartements.

#Lire les donnees si necessaire :

suit=read.table("suitincom.dat")

names(suit)=c("revenu","nbappt")

# Trace du nuage de points

plot(suit$nbappt,suit$revenu)

# Iteration du tirage de l’echantillon bootstrap et des estimations des regressions

for (i in 1:100){

suit.b=suit[sample(47,47,replace=TRUE),]

reg=lm(revenu~nbappt,data=suit.b)

abline(reg)}

La meme chose est obtenue pour l’autre modele :

lsuit=data.frame(log(suit$nbappt),log(suit$revenu))

names(lsuit)=c("Lnbappt","Lnb")

plot(lsuit$Lnbappt,lsuit$Lnrevenu)

for (i in 1:100){

suit.b=lsuit[sample(47,47,replace=TRUE),]

reg=lm(Lnrevenu~Lnbappt,data=suit.b)

abline(reg)}

Ou encore pour des regressions non-parametriques :

plot(lsuit$Lnbappt,lsuit$Lrevenu)

for (i in 1:100) {

suit.b=lsuit[sample(47,47,replace=TRUE),]

lsuit.spl=smooth.spline(suit.b$Lnbappt,suit.b$Lrevenu,df=4)

lines(lsuit.spl, col = "blue")}


Regression lineaire multiple

Cet outil permet d’obtenir des informations sur les distributions des parametres.Les donnees (Jobson, 1991) decrivent les resultats comptables de 80 entreprises du Royaume Uni.RETCAP est la variable a predire. Les entreprises sont reparties aleatoirement en deux groupes de 40 entreprises.

Descriptif des 13 variables :

RETCAP Return on capital employedWCFTDT Ratio of working capital flow to total debtLOGSALE Log to base 10 of total salesLOGASST Log to base 10 of total assetsCURRAT Current ratioQUIKRAT Quick ratioNFATAST Ratio of net fixed assets to total assetsFATTOT Gross sixed assets to total assetsPAYOUT Payout ratioWCFTCL Ratio of working capital flow to total current liabilitiesGEARRAT Gearing ratio (debt-equity ratio)CAPINT Capital intensity (ratio of total sales to total assets)INVTAST Ratio of total inventories to total assets

# Lecture des donnees

ukcomp1=read.table(’ukcomp1.datr’, header=TRUE)

Le bootstrap construit ”a la main” :

# Initialisation de la matrice qui contiendra les differentes #estimations

stock=data.frame(matrix(0,100,5))

names(stock)=c("CST","CFTDT","LOGSALE","NFATAST","CURRAT")

# Iteration des tirages des echantillons et des estimations

for (i in 1:100) {

Ib=sample(40,40,replace=TRUE)

stock[i,]=coef(lm(RETCAP~WCFTDT+LOGSALE+NFATAST+CURRAT,data=ukcomp1[Ib,])) }

# Dispersion des estimations des parametres}

boxplot(stock,horizontal=TRUE)

Meme chose pour le modele optimal au sens du R2 ajuste.

stock=data.frame(matrix(0,100,9))

names(stock)=c("CST","WCFTDT","LOGSALE","LOGASST","NFATAST",

"FATTOT","INVTAST","QUIKRAT","CURRAT")

for (i in 1:100) {

Ib=sample(40,40,replace=TRUE)

stock[i,]=coef(lm(RETCAP~WCFTDT+LOGSALE+LOGASST+NFATAST+FATTOT+

INVTAST+QUIKRAT+CURRAT,data=ukcomp1[Ib,]))}

boxplot(stock,horizontal=TRUE)

Comparer les dispersions des parametres.

Librairie specifique

Des fonctions sont prevues dans le package boot pour simplifier le travail et qui s’appliquenta toute statistique. Ainsi, pour estimer les biais et ecarts-types ”bootstrap” des parametres enregression :

# Chargement de la librairie

library(boot)

# Definition de la fonction qui calcule la statistique d’interet a bootstraper

# Celle-ci comporte deux parametres : les donnees et les indices d’un echantillon

uk1.fun=function(d,i) coef(lm(RETCAP~WCFTDT+LOGSALE+NFATAST+CURRAT,data=d[i,]))

# lancement du bootstrap

uk1.b=boot(ukcomp1,uk1.fun,R=999)

# Parametres, biais et ecart-type bootstrap desparametres

uk1.b

boxplot(data.frame(uk1.b$t),horizontal=TRUE)


Meme chose pour l’autre modele.

uk2.fun=function(d,i) coef(lm(RETCAP~WCFTDT+LOGSALE+LOGASST+

NFATAST+FATTOT+INVTAST+QUIKRAT+CURRAT,data=d[i,]))

uk2.b=boot(ukcomp1,uk2.fun,R=999)

uk2.b

boxplot(data.frame(uk2.b$t),horizontal=TRUE)

2.4 Validation croisee

2.4.1 Principe

La validation croisee permet d’estimer, avec un biais reduit, un risque quadratique ou un taux de mal classes selonl’objectif de la methode utilisee. Le principe consiste a estimer le modele sur une partie de l’echantillon puis de calculer l’erreurcommise sur une autre partie de l’echantillon qui n’a pas participe a l’estimation des parametres de ce modele. Ce calculest itere sur plusieurs echantillons de validation afin d’ameliorer par moyennage la precision. Differentes facons de constituerdes echantillons de validation peuvent etre considerees. La validation croisee originale (PRESS de Allen) ou leave-one-outconsidere n echantillons d’apprentissage de taille n − 1 obtenus en eliminant tour a tour chaque observation qui constituel’echantillon test. La deuxieme decoupe aleatoirement l’echantillon en k (par defaut, k = 10) parties approximativement dememe taille. Apres k iterations, chaque groupe a joue le role d’echantillon de validation. Enfin la derniere propose d’iterer Bfois le tirage aleatoire simple d’un echantillon de validation avec un taux fixe. Chaque algorithme estime respectivement n,k, B fois le modele sur la partie apprentissage de l’echantillon, predit la part validation, puis estime l’erreur en moyennantles erreurs de predictions.

Le choix de l’algorithme de validation croisee depend principalement de la taille de l’echantillon : le premier si n est petit,le deuxieme en situation intermediaire en choisissant k, le dernier si n est grand.

Dans R, comme pour le bootstrap, des fonctions generiques ont ete definies pour etre appliquees a toute methode demodelisation : fonction crossval du package bootstrap ou cv.glm du package boot adaptee au modele lineaire general(gaussien, binomial...).

La validation est tres largement utilisee comme estimation de l’erreur de prediction a minimiser pour optimiser un choixde modele parmi une famille definie par un parametre de complexite.

2.4.2 Application au modele lineaire

L’utilisation de la validation croisee ne s’impose pas pour cette technique de modelisation car d’autres criteres basesegalement sur une estimation de l’erreur de prediction sont diponibles a moindre cout. Elle est mise en œuvre a titreillustratif sur les donnees precedentes.

# Estimation du modele}

uk1.glm = glm(RETCAP~WCFTDT+LOGSALE+NFATAST+CURRAT,family=gaussian,data=ukcomp1)

# Estimation de l’erreur leave-one-out

cv.err = cv.glm(ukcomp1,uk1.glm)

# Estimation sur 5 echantillons de taille 8

cv.err.5 = cv.glm(ukcomp1,uk1.glm, K=5)

cv.err$delta[1]

cv.err.5$delta[1]

Meme chose sur l’autre modele.

uk1.glm = glm(RETCAP~WCFTDT+LOGSALE+LOGASST+NFATAST+FATTOT+

INVTAST+QUIKRAT+CURRAT,family=gaussian,data=ukcomp1)

cv.err = cv.glm(ukcomp1,uk1.glm)

cv.err.5 = cv.glm(ukcomp1,uk1.glm, K=5)

cv.err$delta[1]

cv.err.5$delta[1]

Verifier que les choix du TP precedent sont confirmes.Pour memoire, rappelons que dans le cas de la regression multiple, l’erreur leave-one-out est obtenue directement sans

estimation iterative du modele :

muhat=uk1.glm$fitted

uk1.diag= glm.diag(uk1.glm)

mean((uk1.glm$y-muhat)^2/(1-uk1.diag$h)^2)

Chapitre 3

Apprentissage et prevision statistique dupic d’ozone

3.1 Introduction

L’objectif, sur ces donnees, est d’ameliorer la prevision calculee par les services de MeteoFrance (MOCAGE) de la concen-tration d’ozone dans certaines stations de prelevement a partir de cette prevision et en s’aidant d’autre variables egalementprevues par MeteoFrance. Il s’agit d’un probleme dit d’adaptation statistique d’une prevision deterministe pour une ame-lioration locale de modeles a trop grande echelle. Plus precisement, deux variables peuvent etre predites : soit la concentrationquantitative d’ozone, soit le depassement (qualitatif) d’un certain seuil fixe a 150µg. 1 Dans chaque cas, deux approches sontconsiderees : soit prevoir la concentration quantitative puis en deduire l’eventuel depassement ou bien prevoir directement ledepassement. Dans le premier cas, il s’agit d’abord d’une regression tandis que dans le deuxieme il s’agit d’un probleme dediscrimination.

On se propose de tester differentes methodes : regression logistique, analyse discriminante, arbre de decision, reseau deneurones, agregation d’arbres, SVM. L’objectif final, a ne pas perdre de vue, est la comparaison de ces methodes afin dedeterminer la plus efficace pour repondre au probleme de prevision. Ceci passe par la mise en place d’un protocole tres strictafin de s’assurer d’un minimum d’objectivite pour cette comparaison.

Penser a conserver dans des fichiers les commandes successives utilisees ainsi que les principaux resultats tableaux etgraphes.

Toutes les operations sont realisees dans R avec l’appui de bibliotheques complementaires eventuellement a telecharger(mlbench, MASS, boot, class, e1071, rpart, nnet, ipred, gbm, randomForest). D’autres logiciels sont bien evidem-ment utilisables (Splus, SAS, SPSS...). Neanmoins, dans le cas de SAS, cela necessiterait l’acces au module Enterprise Minerpour certaines methodes (arbres, neurones) encore peu diffuse car tres cher. De plus certaines procedures du module classiqueSAS/Stat ne comportent pas d’option de selection automatique de variables quantitatives et qualitatives.

3.2 Extraction des echantillons apprentissage et test

3.2.1 Rappel : protocole de comparaison

La demarche mise en œuvre enchaıne les etapes suivantes :

1. Effectuer une eventuelle premiere etape descriptive uni ou multidimensionnelle visant a reperer les incoherences, lesvariables non significatives ou de distribution exotique, les individus non concernes. . . et a etudier les structures desdonnees.

2. Proceder a un tirage aleatoire d’un echantillon test qui ne sera utilise que lors de la derniere etape.

3. Sur la partie restante qui sera decoupee en echantillon d’apprentissage (des parametres dumodele) et echantillon de validation (pour estimation sans biais du taux de mauvais classes), optimiser les choix afferentsa chacune des methodes de discrimination :• variables et interactions a prendre en compte dans la regression logistique,• variables et methode pour l’analyse discriminante,• nombre de nœuds dans l’arbre de classification,• algorithme d’agregation,

1. Le seuil legal a ete porte a 180µg mais celui-ci est bien trop rarement depasse par les observations et serait trop difficile a prevoir parestimation d’un modele.

11


• noyau et complexite des SVMs.Remarque : Il faut rappeler qu’en cas d’echantillon petit face au nombre des variables, c’est le cas de ces donnees, ilest recommande d’iterer la procedure de decoupage par validation croisee, afin de reduire la variance des estimationsdes erreurs de classement.

4. Comparaison finale des qualites de prevision sur la base du taux de mal classes pour le seul echantillon test qui estreste a l’ecart de tout effort ou ”acharnement” pour l’optimisation des modeles.

• Attention, ne pas “tricher” en modifiant le modele obtenu lors de l’etape precedente afin d’ameliorer le resultat surl’echantillon test !

• Le critere utilise (taux de mauvais classement) peut etre remplace par tout type d’erreur en fonction du problemetraite : risque quadratique en regression, cout de mauvais classement, AUC (aire sous la courbe ROC)...

3.2.2 Prise en charge des donnees

Les donnees ont ete extraites et mises en forme par le service concerne de MeteoFrance. Elles sont contenues dans lefichier ozone.dat et decrites par les variables suivantes :

JOUR Le type de jour ; ferie (1) ou pas (0) ;

O3obs La concentration d’ozone effectivement observee le lendemain a 17h locales correspondant souvent au maximum depollution observee ;

MOCAGE Prevision de cette pollution obtenue par un modele deterministe de mecanique des fluides (equation de Navieret Stockes) ;

TEMPE Temperature prevue par MeteoFrance pour le lendemain 17h ;

RMH2O Rapport d’humidite ;

NO2 Concentration en dioxyde d’azote ;

NO Concentration en monoxyde d’azote ;

STATION Lieu de l’observation : Aix-en-Provence, Rambouillet, Munchhausen, Cadarache et Plan de Cuques ;

VentMOD Force du vent ;

VentANG Orientation du vent.

# Lecture des donnees

ozone=read.table("ozone.dat",header=T)

# Verification du contenu

summary(ozone)

dim(ozone)

# Changement du type de la variable jour

ozone[,"JOUR"]=as.factor(ozone[,"JOUR"])

Remarquer le type des variables. Il est necessaire d’en etudier la distribution.

par(mfrow=c(2,4))

hist(ozone[,"O3obs"]);hist(ozone[,"MOCAGE"]);hist(ozone[,"TEMPE"]);hist(ozone[,"RMH2O"]);

hist(ozone[,"NO2"]);hist(ozone[,"NO"]);hist(ozone[,"VentMOD"]);hist(ozone[,"VentANG"]);

Des transformations sont proposees pour rendre certaines distributions plus symetriques et ainsi plus ”gaussiennes”.

ozone[,"SRMH2O"]=sqrt(ozone[,"RMH2O"])

ozone[,"LNO2"]=log(ozone[,"NO2"])

ozone[,"LNO"]=log(ozone[,"NO"])

par(mfrow=c(2,4))

hist(ozone[,"O3obs"]);hist(ozone[,"MOCAGE"]);hist(ozone[,"TEMPE"]);hist(ozone[,"SRMH2O"]);

hist(ozone[,"LNO2"]);hist(ozone[,"LNO"]);hist(ozone[,"VentMOD"]);hist(ozone[,"VentANG"]);

Verifier de l’opportunite de ces transformations puis retirer les variables initiales et construire la variable ”depassement deseuil”. On retire egalement les variables concernant le vent.

ozone=ozone[,c(1:4,8,11:13)]

ozone[,"DepSeuil"]=as.factor(ozone[,"O3obs"]>150)

pour obtenir le fichier qui sera effectivement utilise.


3.2.3 Extraction des echantillons

Le programme ci-dessous realise l’extraction du sous-ensemble des donnees d’apprentissage et de test. Attention, chaqueetudiant ou binome tire un echantillon different ; il est donc ”normal” de ne pas obtenir les memes modeles.

Utiliser trois chiffres au hasard, en remplacement de ”111” ci-dessous, comme initialisation du generateur de nombresaleatoires.

set.seed(111) # initialisation du generateur

# Extraction des echantillons

test.ratio=.2 # part de l’echantillon test

npop=nrow(ozone) # nombre de lignes dans les donnees

nvar=ncol(ozone) # nombre de colonnes

ntest=ceiling(npop*test.ratio) # taille de l’echantillon test

testi=sample(1:npop,ntest) # indices de l’echantillon test

appri=setdiff(1:npop,testi) # indices complementaires de l’echantillon d’apprentissage

Construction des echantillons pour la regression (prevision de la concentration).

datappr=ozone[appri,-9] # construction de l’echantillon d’apprentissage

datestr=ozone[testi,-9] # construction de l’echantillon test

summary(datappr) # verifications

summary(datestr)

Construction des echantillons pour la discrimination (depassement du seuil).

datappq=ozone[appri,-2] # construction de l’echantillon d’apprentissage

datestq=ozone[testi,-2] # construction de l’echantillon test

summary(datappq) # verifications

summary(datestq)

Tracer un scaterplot de nos donnees afin de voir les correlations entre les differentes variables.

library(lattice)

type=datappq$DepSeuil

splom(~datappq,groups=type,pch="*")

plot(datappr)

Que constatez-vous ?

3.3 Regression lineaire

Le premier modele a tester est un simple modele de regression lineaire mais, comme certaines variables sont qualitatives,il s’agit d’une analyse de covariance. D’autre part, on s’interesse a savoir si des interactions sont a prendre en compte. Lemodele devient alors polynomiale d’ordre 2 ou quadratique.

3.3.1 Modele lineaire simple

Le modele de regression lineaire simple integrant des variables qualitatives correspondant est estime avec la fonction lm.

# estimation du modele sans interaction

reg.lm=lm(O3obs~.,data=datappr)

summary(reg.lm)

# Extraction des residus et des valeurs ajustees

res.lm=reg.lm$residuals

fit.lm=reg.lm$fitted.values

# Graphe des ajustees

plot.fit=function(x,y,titre="titre"){

plot(x,y,col="blue",xlim=c(0,400),ylim=c(0,400),

ylab="Ajustees",xlab="Observations O3",main=titre)

abline(0,1,col="green")

abline(150,0,col="pink")

abline(v=150,col="pink")}


plot.fit(datappr[,"O3obs"],fit.lm, "Ajustees modele lineaire")

# Definition d’une fonction pour un graphe colore et

# des echelles fixes sur les axes

plot.res=function(x,y,titre="titre")

{

plot(x,y,col="blue",xlim=c(0,300),ylim=c(-100,100),

ylab="Residus",xlab="Valeurs predites",main=titre)

abline(h=0,col="green")

}

plot.res(fit.lm,res.lm,"Residus modele lineaire")

# Graphe au modele MOCAGE

par(mfrow=c(1,2))

plot.fit(datappr[,"O3obs"],datappr[,"MOCAGE"],"Mocage")

plot.fit(datappr[,"O3obs"],fit.lm,"Modele lineaire")

Controler les graphes des residus, que conclure de ce modele ?L’etude suivante met en œuvre toutes les interactions d’ordre 2 pour ajuster le modele.

3.3.2 Modele quadratique

Le modele de regression quadratique est estime avec la fonction glm qui permet une selection automatique de modele. Lamethode descendante est utilisee mais celle pas-a-pas pourrait egalement l’etre.

# Estimation du modele de toute interaction d’ordre 2

reg.glm=glm(O3obs~(.)^2,data=datappr)

# Recherche du meilleur modele au sens du critere d’Akaıke

# par methode descendante

reg.glm.step=step(reg.glm,direction="backward")

anova(reg.glm.step,test="F")

# Extraction des valeurs ajustees et des residus

fit.glm=reg.glm.step$fitted.values

res.glm=reg.glm.step$residuals

# Graphe des residus

plot.res(fit.glm,res.glm,"")

#Graphe des ajustees en fonction des observations

par(mfrow=c(1,2))

plot.fit(datappr[,"O3obs"],fit.glm)

plot.fit(datappr[,"O3obs"],fit.lm)

dev.off()

On peut egalement comparer les R2 de ces 2 modeles.On remarque que la presence de certains interactions ou variables sont pertinentes au sens du critere d’Akaıke mais passignificative au sens du test de Fisher. Cette presence dans le modele peut etre plus finement analysee en considerant uneestimation de l’erreur par validation croisee. L’idee est de retirer une a une les variables ou interactions les moins significativeset de voir comment se comporte la validation croisee. D’autre part, si la procedure pas-a-pas conduit a un modele different,l’estimation de l’erreur par validation croisee permet egalement d’optimiser le choix.

L’estimation des erreurs par validation croisee est calculee en utilisant une fonction proposee dans la bibliotheque boot.

library(boot) # chargement de la bibliotheque

# validation croisee 10-plis

cv.glm(datappr, reg.glm, K=10)$delta[1] # modele complet

cv.glm(datappr, reg.glm.step, K=10)$delta[1] # modele "Akaıke"

La premiere commande suivante permet de recuperer le modele optimal avant de redefinir celui-ci en retirant l’interaction lamoins significative avant de re-estimer l’erreur par validation croisee.

reg.glm.step$formula # donne la liste des effets du modele optimal

cv.glm(datappr, glm(O3obs ~ JOUR + MOCAGE + TEMPE + STATION + VentMOD + SRMH2O +

LNO2 + LNO + JOUR:VentMOD + MOCAGE:STATION + MOCAGE:VentMOD +

MOCAGE:SRMH2O + MOCAGE:LNO2 + MOCAGE:LNO + TEMPE:STATION +

TEMPE:VentMOD + TEMPE:SRMH2O + TEMPE:LNO2 + TEMPE:LNO + STATION:VentMOD +


STATION:SRMH2O + STATION:LNO2 + STATION:LNO + VentMOD:LNO2 +

VentMOD:LNO + SRMH2O:LNO2 + SRMH2O:LNO,data=datappr),K=10)$delta[1]

3.3.3 Prevision de l’echantillon test

Quelques scores de prevision

On note A l’occurrence du phenomene d’interet et NA sa non-occurrence.

ObservePrevu A NAA a bNA c d

Le taux de succes global est defini par

a+ d

a+ b+ c+ d.

Ce n’est pas forcement un bon indicateur si A est rare.

Soient H le taux de bonnes previsions et F le taux de fausses alertes. Ces deux taux se calculent de la maniere suivante

H =a

a+ cet F =

b

b+ d.

Grace a ces deux taux, on peut determiner le score de Pierce

PSS = H − F ∈ [−1; 1].

Le cas PSS = 0 correspond a une prevision climatologique : prevision au hasard qui respecte les frequences des evenementsobserves.Si PSS > 0, alors le modele apporte de l’information. On peut creer une fonction permettant de calculer le score de Pierce.

pss=function(obs,prev)

{

table=table(prev,obs)

H=table[2,2]/(table[2,2]+table[1,2])

F=table[2,1]/(table[2,1]+table[1,1])

PSS=H-F

print(PSS)

}

Comparaison des qualites predictives sur l’echantillon test

Retenir le meilleur modele obtenu pour predire l’echantillon test et estimer ainsi sans biais une erreur de prevision. Deuxerreurs sont estimees ; la premiere est celle quadratique pour la regression tandis que la deuxieme est issue de la matrice deconfusion qui croise les depassements de seuils predits avec ceux effectivement observes.

# Calcul des previsions

pred.glm=predict(reg.glm.step,newdata=datestr)

pred.lm=predict(reg.lm,newdata=datestr)

# Erreur quadratique moyenne de prevision

sum((pred.glm-datestr[,"O3obs"])^2)/nrow(datestr)

sum((pred.lm-datestr[,"O3obs"])^2)/nrow(datestr)

sum((datestr[,"MOCAGE"]-datestr[,"O3obs"])^2)/nrow(datestr)

# Matrice de confusion pour la prevision du depassement de seuil

table(pred.glm>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.glm>150)

table(pred.lm>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.lm>150)

Calculer le score de Pierce. Noter ces erreurs pour les comparer avec celles obtenues par les autres methodes. Par exempleavec la prevision de MOCAGE.

# matrice de confusion du modele MOCAGE

table(datestr[,"MOCAGE"]>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,datestr[,"MOCAGE"]>150)


3.4 Regression logistique

Plutot que de prevoir la concentration puis le depassement, on peut se poser la question de savoir s’il ne serait paspertinent de prevoir directement la presence ou l’absence d’un depassement. La variable a modeliser etant binaire, c’est laregression logistique qui va etre employee. Comme pour la regression, differentes strategies de choix de modele peuvent etreutilisees et comparees avant d’estimer l’erreur de prevision sur l’echantillon test.

3.4.1 Regression logistique sans interaction

# estimation du modele complet

log.lm=glm(DepSeuil~.,data=datappq,family=binomial)

# significativite des parametres

anova(log.lm,test="Chisq")

log.lm$coefficients

# Recherche d’un modele optimal au sens d’Akaıke

log.lm.step=step(log.lm,direction="backward")

anova(log.lm.step,test="Chisq")

# matrice de confusion de l’echantillon d’apprentissage

# et erreur apparente

table(log.lm.step$fitted.values>0.5,datappq[,"DepSeuil"])

pss(datappq[,"DepSeuil"],log.lm.step$fitted.values>0.5)

3.4.2 Regression logistique avec interaction

# estimation du modele complet

log.qm=glm(DepSeuil~(.)^2,data=datappq,family=binomial)

Avec autant de parametres, l’algorithme de regression a quelques soucis car la regression ajuste trop bien les donnees. Onpropose alors une optimisation du modele par une methode pas-a-pas a comparer avec le modele fournit par l’algorithmedescendant.

# regression avec le modele minimum

log.qm=glm(DepSeuil~1,data=datappq,family=binomial)

# algorithme stepwise en precisant le plus grand modele possible

log.qm.step1=step(log.qm,direction="both",scope=list(lower=~1, upper=~(JOUR + MOCAGE + TEMPE +

STATION + LNO2 + LNO + SRMH2O)^2), family=binomial)


anova(log.qm.step1,test="Chisq")

log.qm.step1$coefficients

# algorithme backward

log.qm=glm(DepSeuil~(.)^2,data=datappq,family=binomial)

log.qm.step2=step(log.qm,direction="backward", family=binomial)


anova(log.qm.step2,test="Chisq")

log.qm.step2$coefficients

Trois modeles sont en concurrence, il s’agit de les comparer en minimisant l’erreur calculee par validation croisee. La procedureutilisee est la meme que pour le modele lineaire classique mais une autre fonction de cout adaptee a une variable binaire doitetre precisee. Elle est definie ci-dessous puis appliquee au calcul de l’erreur apparente de prevision.

cout = function(r, pi=0) mean(abs(r-pi)>0.5)

# Application de cette fonction pour l’erreur d’ajustement :

cout(as.integer(datappq$DepSeuil)-1,log.qm$fitted.values)

cout(as.integer(datappq$DepSeuil)-1,log.qm.step1$fitted.values)

cout(as.integer(datappq$DepSeuil)-1,log.qm.step2$fitted.values)

Estimation de l’erreur de prevision par validation croisee.

library(boot)

cv.glm(datappq, log.qm, cout,K=10)$delta[1]

cv.glm(datappq, log.qm.step1, cout,K=10)$delta[1]

cv.glm(datappq, log.qm.step2, cout,K=10)$delta[1]


Prevision de l’echantillon test

pred.log=predict(log.qm.step1,newdata=datestq)

# Matrice de confusion pour la prevision du depassement de seuil

table(pred.log>0.5,datestq[,"DepSeuil"])

pss(datestq[,"DepSeuil"],pred.log>0.5)

Comparer avec les autres methodes.

3.5 Analyse discriminante

L’objectif est de comparer les trois methodes d’analyses discriminantes disponibles dans R : lda parametrique lineaire(homoscedasticite), lqa parametrique quadratique (heteroscedasticite) sous hypothese gaussienne et celle non-parametriquedes k plus proches voisins.

Attention, ces techniques n’acceptent par principe que des variables explicatives ou predictives quantitatives. Neanmoins,une variable qualitative a deux modalites, par exemple le type de jour, peut etre consideree comme quantitative sous la formed’une fonction indicatrice prenant ses valeurs dans {0, 1} et, de facon plus ”abusive”, une variable ordinale est considereecomme ”reelle”. Dans ce dernier cas, il ne faut pas tenter d’interpreter les fonctions de discrimination, juste considerer deserreurs de prevision. La variable Station n’est pas prise en compte.

La bibliotheque standard de R (MASS) pour l’analyse discriminante ne propose pas de procedure automatique de choixde variable mais dans cet exemple, les variables sont peu nombreuses.

3.5.1 Estimations

library(MASS) # chargement des librairies

library(class) # pour kNN

disc.lda=lda(DepSeuil~.,data=datappq[,-4]) # analyse discriminante lineaire

disc.qda=qda(DepSeuil~.,data=datappq[,-4]) # analyse discriminante quadratique

disc.knn=knn(datappq[,c(-4,-8)],datappq[,c(-4,-8)],datappq$DepSeuil,k=10) # k plus proches voisins

# erreur apparente de prevision

table(predict(disc.lda,datappq)$class,datappq[,"DepSeuil"])

pss(datappq[,"DepSeuil"],predict(disc.lda,datappq)$class)

table(predict(disc.qda,datappq)$class,datappq[,"DepSeuil"])

pss(datappq[,"DepSeuil"],predict(disc.qda,datappq)$class)

table(disc.knn,datappq[,"DepSeuil"])

pss(datappq[,"DepSeuil"],disc.knn)

Noter le manque d’homogeneite des commandes de R issues de librairies differentes. L’indice de colonne negatif (−8) permetde retirer la colonne contenant la variable a predire de type facteur. Celle-ci est mentionnee en troisieme parametre pour lesdonnees d’apprentissage.

Estimation par validation croisee

Pour knn, le choix du nombre de voisins k peut etre optimise par validation croisee mais la procedure proposee parla bibliotheque class est celle du leave-one-out, donc trop couteuse en calcul pour des gros fichiers. Il serait simple dela programmer mais une autre bibliotheque (e1071) propose deja une batterie de fonctions de validation croisee pour denombreuses techniques de discrimination.

# erreur par validation croisee

disc.lda.cv=lda(DepSeuil~.,data=datappq[,-4],CV=T) # analyse discriminante lineaire

disc.qda.cv=qda(DepSeuil~.,data=datappq[,-4],CV=T) # analyse discriminante quadratique

table(disc.lda.cv$class,datappq[,"DepSeuil"])

pss(datappq[,"DepSeuil"],disc.lda.cv$class)

table(disc.qda.cv$class,datappq[,"DepSeuil"])

pss(datappq[,"DepSeuil"],disc.qda.cv$class)

library(e1071)

plot(tune.knn(as.matrix(datappq[,c(-4,-8)]),as.factor(datappq[,8]),k=2:20))


Remarquer que chaque execution de la commande precedente donne des resultats differents donc tres instables. Choisir unevaleur ”raisonnable” de k et l’utiliser pour predire l’echantillon test.

disc.knn.opt=knn(datappq[,c(-4,-8)],datestq[,c(-4,-8)],datappq$DepSeuil,k=15) # k plus proches voisins

table(disc.knn.opt,datestq[,"DepSeuil"])

pss(datestq[,"DepSeuil"],disc.knn.opt)

3.5.2 Taux d’erreur sur l’echantillon test

Les commandes suivantes calculent la matrice de confusion pour la ”meilleure” methode d’analyse discriminante au sensde la validation croisee.

table(predict(disc.lda,datestq[,-4])$class,datestq[,"DepSeuil"])

pss(datestq[,"DepSeuil"],predict(disc.lda,datestq[,-4])$class)

On fait de meme pour la methode des k plus proches voisins.

disc.knn.opt15=knn(datappq[,c(-4,-8)],datestq[,c(-4,-8)],datappq$DepSeuil,k=15)

table(disc.knn.opt15,datestq[,"DepSeuil"])

pss(datestq[,"DepSeuil"],disc.knn.opt15)

Noter ces taux d’erreur en vue d’une comparaison.

3.6 Arbre binaire de decision

3.6.1 Introduction

Deux librairies, tree et rpart, proposent les techniques CART avec des algorithmes analogues a ceux developpes dansSplus mais moins de fonctionnalites ; la librairie rpart fournissant des graphes plus explicites, des options plus detailleeset une procedure d’elagage plus performante est preferee. Cette fonction integre une procedure de validation croisee pourevaluer le parametre de penalisation de la complexite.

Differents parametres controlent l’execution : cp designe la complexite minimale pour la construction de l’arbre maximal,le nombre minimal d’observation par nœud, le nombre de validations croisees (par defaut 10)...(?rpart.control pour plus de details). En fait la documentation des fonctions concernees est un peu ”laconique” et ilest difficile d’en comprendre tous les details sans suivre leur evolution par les forums d’utilisateurs. C’est souvent un destravers des logiciels en acces libre mais la communaute est tres ”reactive” pour repondre aux questions a condition qu’ellesne soient pas trop ”naıves”. Il est en effet important de consulter les archives pour ne pas reposer des problemes deja resoluset abondamment commentes.

Enfin, deux types d’arbre peuvent etre estimer selon que l’on considere que la variable a modeliser est la concentrationd’ozone (arbre de regression) ou directement le depassement du seuil (arbre de discrimination).

3.6.2 Estimation et elagage de l’arbre de regression

library(rpart) # Chargement de la librairie

La premiere estimation favorise un arbre tres detaille c’est-a-dire avec un faible coefficient de penalisation de la complexitede l’arbre et donc du nombre de feuilles important.

tree.reg=rpart(O3obs~.,data=datappr,control=rpart.control(cp=0.001))

summary(tree.reg) # description de l’arbre et encore....

print(tree.reg)

plot(tree.reg) # Trace de l’arbre

text(tree.reg) # Ajout des legendes des noeuds

Il est probable que l’arbre presente trop de feuilles pour une bonne prevision. Il est donc necessaire d’en reduire le nombrepar elagage. C’est un travail delicat d’autant que la documentation n’est pas tres explicite et surtout les arbres des objetstres instables.

Une premiere facon d’estimer l’erreur par validation croisee consiste a utiliser les fonctionnalites de la fonction rpart quiintegre la construction et le calcul d’erreurs pour toute une sequence de coefficients de penalisation. Cela conduit au trace(plotcp) de la decroissance de l’estimation de l’erreur relative (erreur divisee par la variance de la variable a modeliser)en fonction du coefficient de complexite, c’est-a-dire plus ou moins aussi aussi en fonction de la taille de l’arbre ou nombrede feuilles. Attention, cette relation entre complexite et nombre de feuilles n’est pas directe car l’erreur est calculee sur des


arbres estimes a partir d’echantillons aleatoires (k−1 morceaux) differents et sont donc differents les uns des autres avec pasnecessairement le meme nombre de feuilles, ils partagent juste le meme parametre de complexite au sein de la meme famillede modeles emboıtes. Le choix optimal suggere dans l’aide est la valeur du cp la plus a gauche en dessous de la ligne.

printcp(tree.reg) # tableau des valeurs de cp et erreurs relatives

plotcp(tree.reg)

Comme la procedure integree de validation croisee est relativement ”frustre”, une autre fonction est proposee(xpred.rpart) permettant de mieux controler la decroissance de la complexite. La commande suivante calcule les predictionsobtenues par 10-fold validation croisee pour chaque arbre elague suivant les valeurs du coefficient de complexite. La sequencede ces valeurs est implicitement celle fournit par rpart ou peut etre precisee.

xmat=xpred.rpart(tree.reg)

xerr=(xmat-datappr[,"O3obs"])^2

taux=apply(xerr,2,sum)

plot(taux)

ind=1:length(taux)

indic=ind[taux==min(taux)]

taux[indic]

cp=as.numeric(names(taux))

cpopt=cp[indic]

La valeur de cp optimale est alors utilisee avant de tracer le graphe des residus qui prend une forme particuliere.

tree.reg=rpart(O3obs~.,data=datappr,control=rpart.control(cp=cpopt))

plot(tree.reg) # Trace de l’arbre

text(tree.reg) # Ajout des legendes des noeuds

# calcul et graphe des residus

fit.tree=predict(tree.reg)

res.tree=fit.tree-datappr[,"O3obs"]

plot.res(fit.tree,res.tree)

boxplot(res.tree~fit.tree)

plot.fit(datappr[,"O3obs"],fit.tree)

Le contenu de l’arbre n’est pas tres explicite ou alors il faudrait aller lire dans le summary les informations complementaires. Unarbre plus detaille est construit par l’intermediaire d’un fichier postscript. Ce fichier est cree dans le repertoire de lancementde R. Differentes options sont disponibles permettant de gerer le titre et autres aspects du graphique : ?post.

post(tree.reg)

3.6.3 Estimation et elagage d’un arbre de discrimination

Dans le cas d’une discrimination, le critere par defaut est l’indice de concentration de Gini ; il est possible de preciser lecritere d’entropie ainsi que des poids sur les observations, une matrice de couts ainsi que des probabilites a priori (?rpartpour plus de details).

tree.dis=rpart(DepSeuil~.,data=datappq, parms=list(split=’information’),cp=0.001)

plot(tree.dis)

text(tree.dis)

L’elagage fait appel a la meme procedure integree de validation croisee que pour la regression :

printcp(tree.dis)

plotcp(tree.dis)

ou par validation croisee explicite :

xmat = xpred.rpart(tree.dis,xval=10,cp=seq(0.1,0.001,length=30))

# Comparaison de la valeur predite avec la valeur observee

xerr=(datappq$DepSeuil!=(xmat==2))

# Calcul et affichage des estimations des taux d’erreur

taux=apply(xerr, 2, sum)/nrow(xerr)

plot(taux)


ind=1:length(taux)

indic=ind[taux==min(taux)]

taux[indic]

cp=as.numeric(names(taux))

cpopt=max(cp[indic])

Faire plusieurs executions en modifiant aussi la sequence de parametres... Les choix sont-ils confirmes ? Faire un choix depenalisation avant de re-estimer l’arbre.

tree.dis=rpart(DepSeuil~.,data=datappq, parms=list(split=’information’),cp=0.02)

plot(tree.dis)

text(tree.dis)

post(tree.dis)

Remarquer quelles sont les variables selectionnees par l’arbre, retrouve-t-on les memes que celles selectionnees par la regressionlogistique ?

Calculer l’erreur apparente ou par re-substitution mesurant la qualite de l’ajustement.

table(predict(tree.dis,data=datappq,type=’class’),datappq$DepSeuil) #matrice de confusion

pss(datappq$DepSeuil,predict(tree.dis,data=datappq,type=’class’))


Differentes previsions sont considerees assorties des erreurs estimees sur l’echantillon test. Prevision quantitative de laconcentration, prevision de depassement a partir de la prevision quantitative et directement la prevision de depassement apartir de l’arbre de decision.


pred.treer=predict(tree.reg,newdata=datestr)

pred.treeq=predict(tree.dis,newdata=datestq,type="class")


sum((pred.treer-datestr[,"O3obs"])^2)/nrow(datestr)

# Matrice de confusion pour la prevision du depassement de seuil (regression)

table(pred.treer>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.treer>150)

# Meme chose pour l’arbre de discrimination

table(pred.treeq,datestq[,"DepSeuil"])

pss(datestq[,"DepSeuil"],pred.treeq)

Noter les taux d’erreur. Attention, ne plus modifier le modele pour tenter de diminuer l’erreur sur l’echantillon test, celaconduirait a un biais et un sur-ajustement.

3.7 Reseaux de neurones

3.7.1 Introduction

Il s’agit d’estimer un modele de type perceptron multicouche avec en entree les variables qualitatives ou quantitativeset en sortie la variable binaire a prevoir. Des fonctions R pour l’apprentissage d’un perceptron elementaire ont ete realiseespar differents auteurs et sont accessibles sur le reseau. La librairie nnet de (Ripley, 1999), est limitee aux perceptrons aune couche. C’est theoriquement suffisant pour approcher d’aussi pres que l’on veut toute fonction a condition d’inserersuffisamment de neurones.

Comme pour les arbres, la variable a expliquer est soit quantitative soit binomiale ; la fonction de transfert du neuronede sortie d’un reseau doit etre adaptee en consequence. Elle est choisie lineaire dans le cas quantitatif et sigmoıdale (choixpar defaut) comme toutes celles de la couche cachee dans le cas qualitatif. Le parametre important a determiner est lenombre de neurones sur la couche cachee parallelement aux conditions d’apprentissage (temps ou nombre de boucles). Unealternative a la determination du nombre de neurones est celle du decay qui est un parametre de regularisation analogue acelui utilise en regression ridge. Il penalise la norme du vecteurs des parametres et contraint ainsi la flexibilite du modele.Tres approximativement il est d’usage de considerer, qu’en moyenne, il faut une taille d’echantillon d’apprentissage 10 foissuperieure au nombre de poids c’est-a-dire au nombre de parametres a estimer. On remarque qu’ici la taille de l’echantillond’apprentissage (832) est modeste pour une application raisonnable du perceptron. Seuls des nombres restreints de neuronespeuvent etre consideres et sur une seule couche cachee.


Attention, le nombre de parametres associes a des variables qualitatives depend du nombre de modalites. Ceci est impor-tant a considerer suivant que le reseau est construit sue les variables explicatives ordinales ou quantitatives. Le nombre deneurones ne peut etre le meme dans les deux cas.

3.7.2 Cas de la regression

library(MASS)

library(nnet)

nnet.reg=nnet(O3obs~.,data=datappr,size=5,decay=1,linout=TRUE,maxit=500) # apprentissage

summary(nnet.reg)

La commande donne la ”trace” de l’execution avec le comportement de la convergence mais le detail des poids de chaqueentree de chaque neurone ne constituent pas des resultats tres explicites ! Controler le nombre de poids estimes.

L’optimisation des parametres necessite encore le passage par la validation croisee. Il n’y a pas de fonction dans la librairiennet permettant de le faire mais la fonction tune.nnet de la librairie e1071 est adaptee a cette demarche.

library(e1071)

plot(tune.nnet(O3obs~.,data=datappr,size=c(2,3,4,5),decay=c(1,2,3),maxit=200,linout=TRUE))

Noter la taille et le “decay” optimaux. Il faudrait aussi faire varier le nombre total d’iterations. Cela risque de prendre unpeu de temps ! Noter egalement que chaque execution donne des resultats differents... il n’est donc pas tres utile d’y passerbeaucoup de temps !

Re-estimer le modele suppose optimal avant de tracer le graphe des residus.

nnet.reg=nnet(O3obs~.,data=datappr,size=5,decay=3,linout=TRUE,maxit=200)


fit.nnetr=predict(nnet.reg,data=datappr)

res.nnetr=fit.nnetr-datappr[,"O3obs"]

plot.res(fit.nnetr,res.nnetr)

3.7.3 Cas de la discrimination

nnet.dis=nnet(DepSeuil~.,data=datappq,size=7,decay=1,maxit=500) # apprentissage

summary(nnet.dis)


table(nnet.dis$fitted.values>0.5,datappq$DepSeuil) #matrice de confusion

La validation croisee est toujours necessaire afin de tenter d’optimiser les choix en presence : nombre de neurones,decay et eventuellement le nombre max d’iterations. Neanmoins, la fonction tune.nnet pose des problemes dans le cas dela discrimination. Voici donc, a titre pedagogique, le texte d’une fonction de k-validation croisee adaptee aux reseaux deneurones.

CVnn=function(formula, data, size, niter = 1, nplis = 10, decay = 0, maxit = 100)

{

n = nrow(data)

tmc <- 0

un <- rep(1, n)

ri <- sample(nplis, n, replace = T)

cat(" k= ")

for(i in sort(unique(ri))) {

cat(" ", i, sep = "")

for(rep in 1:niter) {

learn <- nnet(formula, data[ri != i, ], size = size,

trace = F, decay = decay, maxit = maxit)

tmc = tmc + sum(un[(data$DepSeuil[ri == i] == "TRUE") !=

(predict(learn, data[ri == i, ]) > 0.5)])

}

}

cat("\n", "Taux de mal classes")

tmc/(niter * length(unique(ri)) * n)

}


Le parametre niter permet de repliquer l’apprentissage du reseau et de moyenner les resultats afin de reduire la variancede l’estimation de l’erreur. Il est par defaut de 1 mais peut-etre augmente a condition de se montrer plus patient. R,langage interprete comme Matlab, n’est pas particulierement veloce lorsque plusieurs boucles sont imbriquees. Attention,cette fonction depend des donnees utilisees (code TRUE des modalites) mais elle pourrait etre facilement generalisee etadaptees a tout type de modelisation.

Tester la fonction ainsi obtenue et l’executer pour differentes valeurs de size comme (5, 6, 7) et decay (0, 1, 2).Attention, l’initialisation de l’apprentissage d’un reseau de neurone comme celle de l’estimation de l’erreur par validation

croisee sont aleatoires. Chaque execution donne donc des resultats differents. A ce niveau, il serait interessant de construireun plan d’experience a deux facteurs (ici, les parametres de taille et decay) de chacun trois niveaux. Plusieurs realisationspour chaque combinaison des niveaux suivies d’un test classique d’anova permettraient de se faire une idee plus juste del’influence de ces facteurs sur l’erreur.

CVnn(DepSeuil~.,data=datappq,size=5, decay=0)

...

# executer pour differents couples

nnet.dis=nnet(DepSeuil~.,data=datappq,size=6,decay=0.5,maxit=500) # apprentissage

summary(nnet.dis)

Noter la taille et le decay optimaux et re-estimer le modele pour ces valeurs.


Differentes previsions sont considerees assorties des erreurs estimees sur l’echantillon test. Prevision quantitative de laconcentration, prevision de depassement a partir de la prevision quantitative et directement la prevision de depassement apartir de l’arbre de decision.


pred.nnetr=predict(nnet.reg,newdata=datestr)

pred.nnetq=predict(nnet.dis,newdata=datestq)


sum((pred.nnetr-datestr[,"O3obs"])^2)/nrow(datestr)


table(pred.nnetr>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.nnetr>150)

# Meme chose pour la discrimination

table(pred.nnetq>0.5,datestq[,"DepSeuil"])

pss(datestq[,"DepSeuil"],pred.nnetq>0.5)

Noter les taux d’erreur.

3.8 Agregation de modeles

3.8.1 Introduction

Des sections precedentes ont permis d’experimenter les techniques maintenant classiques de construction d’un modele deprevision assorties du probleme recurrent lies a l’optimisation de la complexite du modele. Cette section aborde d’autresstrategies recemment developpees dont l’objectif est de s’affranchir de ce probleme de choix, par des methodes se montrantpas ou tres peu sensibles au sur-apprentissage ; c’est le cas des algorithmes d’agregation de modeles.

Sur le plan logiciel, R montre dans cette situation tout son interet. La plupart des techniques recentes sont en effetexperimentees avec cet outil et le plus souvent mises a disposition de la communaute scientifique sous la forme d’une librairieafin d’en assurer la “promotion”. Pour les techniques d’agregation de modeles, nous pouvons utiliser les librairies gbm etrandomForest respectivement realisees par Greg Ridgeway et Leo Breiman. Ce n’est pas systematique, ainsi J. Friedman aretire l’acces libre a ses fonctions (MART) et cree son entreprise (Salford).

Les objectifs de cette section sont de

1. tester le bagging et le choix des ensembles de variables ainsi que le nombre d’echantillons consideres,

2. etudier l’influence des parametres (profondeur d’arbre, nombre d’iterations, shrinkage) sur la qualite de la previsionpar boosting ;

3. meme chose pour les forets aleatoires (nb de variables tirees (mtrya, nodesize)).

4. Experimenter les criteres de Breiman qui permettent de mesurer l’influence des variables au sein d’une famille agregeede modeles. Les references bibliographiques sont accessibles sur le site de l’auteur :

www.stat.Berkeley.edu/users/breiman


3.8.2 Bagging

En utilisant la fonction sample de R, il est tres facile d’ecrire un algorithme de bagging. Il existe aussi une librairie quipropose des executions plus efficaces. Par defaut, l’algorithme construit une famille d’arbres complets (cp=0) et donc de faiblebiais mais de grande variance. L’erreur out-of-bag permet de controler le nombre d’arbres ; un nombre raisonnable semblesuffire ici.

Regression

L’utilisation est immediate :

library(ipred)

bagging(O3obs~., nbag=50, data=datappr,coob=TRUE)

bagging(O3obs~., nbag=25, data=datappr,coob=TRUE)

Les resultats sont aleatoires et differents pour chaque execution. Neanmoins, ceux-ci semblent relativement stables et peusensibles au nombre d’arbres. Enfin, il est possible de modifier certaines parametres de rpart pour juger de leur influence :ci-dessous, l’elagage de l’arbre.

bagging(O3obs~., nbag=50,control=rpart.control(cp=0.1), data=datappr,coob=TRUE)

Cela necessite une optimisation du choix du parametre. Remarquer neanmoins que le nombre d’arbres (nbag) n’est pas unparametre ”sensible” et qu’il suffit de se contenter d’arbres ”entiers”.

cp=seq(1,0,by=-0.01)

erroob=rep(0,length(cp))

for(i in 1:length(cp))

{

print(cp[i])

bag.cp=bagging(O3obs~., nbag=50,control=rpart.control(cp=cp[i]), data=datappr,coob=TRUE)

erroob[i]=bag.cp$err

}

indix=1:length(cp)

indic=indix[erroob==min(erroob)]

cpoptr=cp[indic]

erroob[indic]

Enfin, considerer le choix optimal de la regression au sens de l’erreur oob comme une estimation par validation croisee puistracer le graphe des residus.

bag.reg=bagging(O3obs~., nbag=50, control=rpart.control(cp=cpoptr),data=datappr,coob=TRUE)


fit.bagr=predict(bag.reg)

res.bagr=fit.bagr-datappr[,"O3obs"]

plot.res(fit.bagr,res.bagr)

plot.fit(datappr[,"O3obs"],fit.bagr)

Avec le choix optimal pour la discrimination, calculer l’erreur apparente ou par re-substitution mesurant la qualite del’ajustement.

Discrimination

bagging(DepSeuil~., nbag=50, data=datappq,coob=TRUE)

bagging(DepSeuil~., nbag=25, data=datappq,coob=TRUE)

cp=seq(1,0,by=-0.1)

erroobd=rep(0,length(cp))

for(i in 1:length(cp))

{

print(cp[i])

bag.cp=bagging(DepSeuil~., nbag=50,control=rpart.control(cp=cp[i]), data=datappq,coob=TRUE)

erroobd[i]=bag.cp$err

}


indix=1:length(cp)

indic=indix[erroob==min(erroob)]

cpoptd=cp[indic]

erroobd[indic]

bag.dis=bagging(DepSeuil~., nbag=50,control=rpart.control(cp=cpoptd), data=datappq,coob=TRUE)

fit.bagq=predict(bag.dis,type="class")

table(fit.bagq,datappq$DepSeuil) #matrice de confusion

pss(datappq$DepSeuil,fit.bagq)


Avec les meilleures combinaisons de parametres precedentes, estimer les erreurs sur l’echantillon test.

pred.bagr=predict(bag.reg,newdata=datestr)

pred.bagq=predict(bag.dis,newdata=datestq,type="class")


sum((pred.bagr-datestr[,"O3obs"])^2)/nrow(datestr)


table(pred.bagr>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.bagr>150)


table(pred.bagq,datestq[,"DepSeuil"])

pss(datestq[,"DepSeuil"],pred.bagq)

Noter les taux d’erreur.

3.8.3 Foret aleatoire

Le programme est disponible dans la librairie randomForest. Il est ecrit en fortran, donc efficace en terme de rapidited’execution, et facile a utiliser grace a une interface avec R. Les parametres et sorties sont explicites dans l’aide en ligne.

Regression

L’utilisation est encore immediate :

library(randomForest)

rf.reg=randomForest(O3obs~., data=datappr,xtest=datestr[,-2],ytest=datestr[,"O3obs"],

ntree=500,do.trace=50,importance=TRUE)

Discrimination

rf.dis=randomForest(DepSeuil~., data=datappq,xtest=datestq[,-8],ytest=datestq[,

"DepSeuil"],ntree=500,do.trace=50,importance=TRUE)

Il peut etre tente une optimisation des parametres mtry (nombre de variables tires a chaque nœud) mais cela n’apparaıt pascomme indispensable, la technique est suffisamment robuste.


fit.rfr=rf.reg$predicted

res.rfr=fit.rfr-datappr[,"O3obs"]

plot.res(fit.rfr,res.rfr)

plot.fit(datappr[,"O3obs"],fit.rfr)


fit.rfq=rf.dis$predicted

table(fit.rfq,datappq$DepSeuil) #matrice de confusion

pss(datappq$DepSeuil,fit.rfq)



Estimer les erreurs sur l’echantillon test.

pred.rfr=rf.reg$test$predicted

pred.rfq=rf.dis$test$predicted


sum((pred.rfr-datestr[,"O3obs"])^2)/nrow(datestr)


table(pred.rfr>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.rfr>150)


table(pred.rfq,datestq[,"DepSeuil"])

pss(datestq$DepSeuil,pred.rfq)

Comparer les erreurs.

Importances des variables

Le modele obtenu est ininterpretable mais des coefficients estiment les contributions des variables dans leur participationa la discrimination.

sort(round(importance(rf.reg), 2)[,1])

sort(round(importance(rf.dis), 2)[,4])

Comparer avec les variables selectionnees par les autres modeles.

3.8.4 Boosting

Deux librairies proposent des versions relativement sophistiquees des algorithmes de boosting dans R. La librairie boost

propose 4 approches : adaboost, bagboost et deux logitboost. Developpees pour une problematique particuliere : l’analysedes donnees d’expression genomique, elle n’est peut-etre pas completement adaptee aux donnees etudiees ; elles se limitent ades predicteurs quantitatifs et peut fournir des resultats etranges. La librairie gbm lui est preferee ; elle offre aussi plusieursversions dependant de la fonction cout choisie.

La variable a prevoir doit etre codee numeriquement (0,1) pour cette implementation. Le nombre d’iterations, ou nombred’arbres, est parametre ainsi qu’un coefficient de retrecissement (shrinkage) controlant le taux ou pas d’apprentissage. At-tention, par defaut, ce parametre a une valeur tres faible (0.001) et il faut un nombre important d’iterations (d’arbres)pour atteindre une estimation raisonnable. La qualite est visualisee par un graphe representant l’evolution de l’erreur d’ap-prentissage. D’autre part, une procedure de validation croisee est incorporee ; elle fournit un nombre optimal d’iterations aconsiderer. Des details sur cette procedures sont disponibles dans le fichier :

library(gbm)

Regression

boost.reg=gbm(O3obs~.,data=datappr,

distribution="gaussian",n.trees=500,

cv.folds=10,n.minobsinnode =5,

shrinkage=0.03,verbose=TRUE)

# fixer verbose a FALSE pour eviter trop de sorties

plot(boost.reg$cv.error)

# nombre optimal d’iterations

best.iter=gbm.perf(boost.reg,method="cv")

best.iter


fit.boostr=boost.reg$fit

res.boostr=fit.boostr-datappr[,"O3obs"]

plot.res(fit.boostr,res.boostr)


On peut s’assurer de l’absence d’un phenomene de sur-apprentissage critique en calculant puis tracant l’evolution de l’erreursur l’echantillon test en fonction du nombre d’arbre dans le modele :

test=numeric()

for (i in 10:500){

pred.test=predict(boost.reg,newdata=datestr,n.trees=i)

err=sum((pred.test-datestr[,"O3obs"])^2)/nrow(datestr)

test=c(test,err)}

plot(10:500,test,type="l")

abline(v=best.iter)

La ligne verticale precise le nombre d’iterations selectionne. Tester ces fonctions en faisant varier le coefficient de retrecissement.

Discrimination

Attention, la variable a modeliser doit etre codee (0, 1) et il fait preciser un autre parametre de distribution pour considererle bon terme d’erreur.

boost.dis=gbm(as.numeric(DepSeuil)-1~., data=datappq,

distribution="adaboost",n.trees=500, cv.folds=10,

n.minobsinnode = 5,shrinkage=0.03,verbose=FALSE)

plot(boost.dis$cv.error)

# nombre optimal d’iterations

best.ited=gbm.perf(boost.dis,method="cv")

best.ited

Comme pour la regression, il est possible de faire varier le coefficient de retrecissement en l’associant au nombre d’arbresdans le modele.


fit.boostq=boost.dis$fit>0.5

table(fit.boostq,datappq$DepSeuil) #matrice de confusion

pss(datappq$DepSeuil,fit.boostq)

Echantillon test

La prevision de l’echantillon test et de la matrice de confusion associee sont obtenus par les commandes :

boost.reg=gbm(O3obs~., data=datappr,

distribution="gaussian",n.trees=500, cv.folds=10,

n.minobsinnode = 5,shrinkage=0.03,verbose=FALSE)

best.iter=gbm.perf(boost.reg,method="cv")

pred.boostr=predict(boost.reg,newdata=datestr,n.trees=best.iter)


sum((pred.boostr-datestr[,"O3obs"])^2)/nrow(datestr)


table(pred.boostr>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.boostr>150)


pred.boostd=predict(boost.dis,newdata=datestq,n.trees=best.ited)

table(as.factor(sign(pred.boostd)),datestq[,"DepSeuil"])

pss(datestq[,"DepSeuil"],as.factor(sign(pred.boostd)))

Quelle strategie d’agregation de modeles vous semble fournir le meilleur resultat de prevision ? Est-elle, sur ce jeu dedonnees, plus efficace que les modeles classiques experimentes auparavant ?

3.9 Separateurs a Vaste Marge (SVM)

3.9.1 Introduction

Cette section propose d’aborder une nouvelle famille d’algorithmes : les SVM ou (Support Vector Machines traduit parSeparateurs a Vaste Marge ou machine a vecteurs support) dont le principe fondateur est d’integrer l’optimisation de la


complexite d’un modele a son estimation ou plus exactement une partie de cette complexite ; cela concerne le nombre devecteurs supports. Une bibliotheque de R, realisee par Chang, Chih-Chung et Lin Chih-Jen, est destinee a cette approche ;elle est integree au package e1071.

Au dela du principe fondateur de recherche de parcimonie (nombre de supports) incorpore a l’estimation, il n’en restepas moins que cette approche laisse, en pratique, un certain nombre de choix et reglages a l’utilisateur. Il est donc importantd’en tester l’influence sur la qualite des resultats.

1. choix du parametre de regularisation ou ponderation d’ajustement,

2. choix du noyau,

3. le cas echeant, choix du parametre associe au noyau : largeur d’un noyau gaussien, degre d’un noyau polynomial...

Notons la meme remarque qu’avec les techniques precedentes sur l’interet a mettre en œuvre une approche “pland’experience” voire meme “surface de reponse” afin d’optimiser le choix des parametres.

3.9.2 Exemple elementaire

Les donnees sont celles, triviales, des iris dits de Fisher afin d’illustrer la methode en explicitant graphiquement l’em-placement des vecteurs supports. Trois varietes (stosa, versicolor, viginica) d’iris doivent etre discriminees en fonction de 4mesures (longueur et largeur des sepales et des petales) realisees sur les fleurs. Il y a 50 fleurs par varietes.

library(e1071)

# declaration des donnees

data(iris)

# le modele est calcule avec les valeurs par defaut des parametres

# (noyau gaussien, penalisation a 1, gamma=0,25)

model = svm(Species ~ ., data = iris)

print(model)

summary(model)

# prevision de l’echantillon d’apprentissage

pred = predict(model, iris[,1:4])

# Matrice de confusion pour l’echantillon d’apprentissage

table(pred, iris$Species)

# Visualisation des classes (couleurs) et des vecteurs supports ("+")

plot(cmdscale(dist(iris[,-5])),

col = as.integer(iris[,5]),

pch = c("o","+")[1:150 %in% model$index + 1])

Noter la densite des vecteurs supports dans les zones plus difficiles a discriminer.Le reglage des parametres peut etre optimise automatiquement avec la fonction tune mais le graphique n’est pas toujours

simple a interpreter.

obj = tune.svm(Species~., data = iris, gamma = 2^(-7:0), cost = 2^(-2:3))

summary(obj)

plot(obj)

3.9.3 Concentration d’ozone

Malgre les assurances theoriques concernant ce type d’algorithme, les resultats dependant fortement du choix des pa-rametres. Nous nous limiterons d’abord au noyau gaussien (choix par defaut) ; la fonction tune.svm permet de tester facile-ment plusieurs situations en estimant la qualite de prevision par validation croisee sur une grille. Le temps d’execution estun peu long... en effet, contrairement a beaucoup d’algorithmes de modelisation, la complexite de l’algorithme de resolutiondes SVM croıt tres sensiblement avec le nombre d’observations mais moins avec le nombre de variables.

Regression

Bien qu’initialement developpes dans le cas d’une variable binaire, les SVM ont ete etendus aux problemes de regression.L’estimation et l’optimisation du coefficient de penalisation sont obtenues par les commandes suivantes.

svm.reg=svm(O3obs~.,data=datappr)

plot(tune.svm(O3obs~.,data=datappr,cost=c(1.5,2,2.5,3,3.5)))

Par defaut la penalisation (cost) vaut 1. Noter la penalisation optimale pour le noyau considere (gaussien). Re-estimer lemodele suppose optimal avant de tracer le graphe des residus afin de verifier le pouvoir d’apprentissage du modele.


svm.reg=svm(O3obs~.,data=datappr,cost=2)


fit.svmr=predict(svm.reg,data=datappr)

res.svmr=fit.svmr-datappr[,"O3obs"]

plot.res(fit.svmr,res.svmr)

plot.fit(datappr[,"O3obs"],fit.svmr)

table(fit.svmr>150,datappr$O3obs>150)

pss(datappr$O3obs>150,fit.svmr>150)

Observer l’effet ”couloir” sur les residus. Ceci est une consequence de la fonction d’erreur robuste utilisee pour l’estimationdes svm.

Nous pouvons egalement faire varier le parametre gamma du noyau gaussien et l’optimiser grace a la fonction tune.svm.

svm.reg=svm(O3obs~.,data=datappr)

plot(tune.svm(O3obs~.,data=datappr,cost=c(1.5,2,2.5,3,3.5),gamma=2^{-8:-5}))

Nous conservons alors la valeur du couple (gamma,cost) optimal.Pour finir, nous pouvons egalement essayer d’autres noyaux. Voici la syntaxe pour l’utilisation d’un noyau polynomial. Il

fautdrait tester d’autres valeurs des parametres.

svm.reg.pol=svm(O3obs~.,data=datappr,kernel="polynomial",gamma=0.02,cost=1,degree=3)

Meme chose pour un noyau sigmoıdal :

svm.reg.sig=svm(O3obs~.,data=datappr,kernel="sigmoid",gamma=0.02,cost=1)

Discrimination

plot(tune.svm(DepSeuil~.,data=datappq,cost=c(1,1.25,1.5,1.75,2))) #optimisation

svm.dis=svm(DepSeuil~.,data=datappq,cost=1.75) # apprentissage


#matrice de confusion

table(svm.dis$fitted,datappq$DepSeuil)

pss(datappq$DepSeuil,svm.dis$fitted)

Remarque : il faudrait aussi optimiser la valeur du parametre gamma du noyau gaussien ainsi que le choix du noyau...


Avec les meilleures combinaisons de parametres precedentes, estimer les erreurs sur l’echantillon test.

svm.reg=svm(O3obs~.,data=datappr,cost=2)

pred.svmr=predict(svm.reg,newdata=datestr)

pred.svm.pol=predict(svm.reg.pol,newdata=datestr)

pred.svm.sig=predict(svm.reg.sig,newdata=datestr)


sum((pred.svmr-datestr[,"O3obs"])^2)/nrow(datestr)

sum((pred.svm.pol-datestr[,"O3obs"])^2)/nrow(datestr)

sum((pred.svm.sig-datestr[,"O3obs"])^2)/nrow(datestr)


table(pred.svmr>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.svmr>150)

table(pred.svm.pol>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.svm.pol>150)

table(pred.svm.sig>150,datestr[,"O3obs"]>150)

pss(datestr[,"O3obs"]>150,pred.svm.sig>150)



svm.dis=svm(DepSeuil~.,data=datappq,cost=2)

pred.svmq=predict(svm.dis,newdata=datestq)

table(pred.svmq,datestq[,"DepSeuil"])

pss(datestq[,"DepSeuil"],pred.svmq)

Noter, comparer les taux d’erreur.

3.10 Ecarts-types d’erreur de prediction estimes sur les fichiers tests

Pour estimer plus precisement la qualite des adaptations statistiques, l’ecart-type d’erreur de prevision est estime sur 50echantillons tests tires au hasard, a partir des modeles statistiques estimes sur 50 echantillons d’apprentissage independantsdes donnees test. On peut alors determiner les boıtes a moustaches des 50 ecart-types pour chacune des methodes statistiquesvues a la section precedente.

3.11 Representation des frontieres de discrimination

Afin de visualiser les les frontieres de discrimination, nous allons reprendre chaque modele precedent permettant dediscriminer la varaible depassement de seuil de la concentration en ozone en fonction seulement des variables mocage ettemperature. Cette restriction nous permet de realiser des graphes en 2 dimensions : l’axe des abscisses represente la variablemocage, celui des ordonnees la temperature. Enfin selon les valeurs des couples (mocage,temperature) une croix est attribuees’il n’y a pas depassement de seuil et un cercle dans le cas contraire.

set.seed(123) # initialisation du generateur de nombres aleatoires

ozone=read.table("ozone.dat",header=T)

ozone$DepSeuil=as.factor(ozone$O3obs>150) #creation variable qualitative de seuil

dat=ozone # toutes les donnees selectionnees

################################################################################

################# Regression lineaire glm() ###################################

################################################################################

reg.glm=glm(O3obs~ MOCAGE + TEMPE ,data=dat)

################# Representation graphique ###############################

tt=seq(10,38,by=0.1)

m=seq(45,285,by=5)

ind=1:length(m)

datest=dat[ind,]

datest$MOCAGE=m # probleme de parser , mais fonctionne en copie/colle

#plot

plot(dat$MOCAGE[dat$O3obs>150],dat$TEMPE[dat$O3obs>150],pch="o",xlim=c(45,285),ylim=c(10,38),

xlab="MOCAGE",ylab="T",

main="regression lineaire")

points(dat$MOCAGE[dat$O3obs<150],dat$TEMPE[dat$O3obs<150],pch="+")

for (i in 1:length(tt)) {

datest$TEMPE=tt[i]

pred=predict(reg.glm,newdata=datest)

points(datest$MOCAGE[pred<150],datest$TEMPE[pred<150],pch="+",col="blue",cex=0.3)

points(datest$MOCAGE[pred>150],datest$TEMPE[pred>150],pch="o",col="red",cex=0.3)

}


#######################################################################################

################# regression logistique avec glm() ##################################

log.glm=glm(DepSeuil~MOCAGE+TEMPE,data=dat,family=binomial) # family=binomial pour reg logistique

# plot



main="regression logistique")



datest$TEMPE=tt[i]

pred=predict(log.glm,newdata=datest,type="response")

points(datest$MOCAGE[pred<0.5],datest$TEMPE[pred<0.5],pch="+",col="blue",cex=0.3)

points(datest$MOCAGE[pred>=0.5],datest$TEMPE[pred>=0.5],pch="o",col="red",cex=0.3)

}

################################################################

# analyse disriminante lda + qda

################################################################

library(MASS) # lda + qda

library(class) # knn

disc.lda=lda(DepSeuil~MOCAGE+TEMPE,data=dat) # cas lineaire / f(x/mod)~N(g(mod),S)

disc.qda=qda(DepSeuil~MOCAGE+TEMPE,data=dat) # cas quadratique / f(x/mod)~N(g(mod),S(mod))

# plot lda



main="discrimination lineaire")



datest$TEMPE=tt[i]

pred=predict(disc.lda,newdata=datest)$class

points(datest$MOCAGE[pred=="FALSE"],datest$TEMPE[pred=="FALSE"],pch="+",col="blue",cex=0.3)

points(datest$MOCAGE[pred=="TRUE"],datest$TEMPE[pred=="TRUE"],pch="o",col="red",cex=0.3)

}

# plot qda



main="discrimination quadratique")



datest$TEMPE=tt[i]

pred=predict(disc.qda,newdata=datest)$class



}


################################################################

# analyse disriminante knn

################################################################

library(class) # knn

library(e1071) # tune.knn

#otimisation du nombre de voisins

tune=tune.knn(dat[,3:4],dat[,11],k=2:20) # knn(X,Y, k range)

plot(tune) # best k=9

# plot knn(9)



main="k plus proches voisins")



datest$TEMPE=tt[i]

pred=knn(dat[,3:4],datest[,3:4],dat[,11],k=9) # kn(xapp,xtest,yapp,k= nb+proches voisins)



}

################################################################

# arbre de classification

################################################################

library(rpart)

## split = gini

tree.dis=rpart(DepSeuil~MOCAGE+TEMPE,data=dat,control=rpart.control(cp=0.001))

# critere de separation: gini par defaut

# critere entropie: parms="information"

#validation croisee explicite

xmat=xpred.rpart(tree.dis) #validation croisee: //cp=seq(0.3,0.001,length=20) avec nouvelles valeurs de cp

# par defaut K=10

# par defaut reprend les cp values du fit et dont on calcule par cv les

# erreurs moyennes. donc abscisses sont a recuperer dans cptable !

xmat=xmat # les prevision de la vc: 1 ou 2 c.a.d n du facteur!

xerr=as.integer(dat$DepSeuil)!= xmat # calcul erreur prevision pour chaque intervalle de cp (colonnes)

mxerr=apply(xerr,2,mean) # somme xerr par colonne

cp.ind=which.min(mxerr) #selection du cp otimal (?)

tree1.dis=rpart(DepSeuil~MOCAGE+TEMPE,data=dat,control=rpart.control(cp=0.01)) # optimal tree

#plot(tree1.dis)

#text(tree1.dis,cex=0.6)

# plot tree



main="arbre de classification")




datest$TEMPE=tt[i]

pred=predict(tree1.dis,newdata=datest,type="class") # type =class renvoie la modalite prevue



}

###########################################################################

# bagging classification tree

###########################################################################

library(ipred)

### choix de nbag qui minimise err OOB

err=1:20

for (i in 1:20){

bag.dis= bagging(DepSeuil~MOCAGE+TEMPE,nbag=10+5*i,data=dat,coob=T)

err[i]=bag.dis[[6]]

}

plot(seq(10,length.out=20,by=5),err)

# ngab opt=70

bag.dis= bagging(DepSeuil~MOCAGE+TEMPE,nbag=70,data=dat,coob=T) # estimation erreur oob

# plot tree



main="bagging(70)")



datest$TEMPE=tt[i]

pred=predict(bag.dis,newdata=datest) # class par defaut



}

###########################################################################

# foret aleatoire

###########################################################################

library(randomForest)

rf.dis=randomForest(DepSeuil~MOCAGE+TEMPE,data=dat,ntree=500,do.trace=50,importance=T)

#optimisation ntree

err.OOB=rf.dis[["err.rate"]]

plot(err.OOB[,1])

ntree1=which.min(err.OOB[,1])

titre=paste("random forest",format(ntree1,dig=3))


# plot random forest



main=titre)



datest$TEMPE=tt[i]

rf.dis=randomForest(DepSeuil~MOCAGE+TEMPE,data=dat,ntree=ntree1,

importance=T,xtest=datest[,3:4],ytest=datest[,11])

pred=rf.dis$test$predicted



}

##############################################################

# SVM

##############################################################

library(e1071)

svm.tune=tune.svm(DepSeuil~MOCAGE+TEMPE,data=dat,

gamma= seq(0.05,by=0.05,length.out=4), # cost=1 par defaut

cost=seq(1,3,by=0.5)) # gamma = 1/p par defaut

plot(svm.tune)

# optimum :gamma=0.06 et cost=1.5

svm.reg=svm(DepSeuil~MOCAGE+TEMPE,data=dat,cost=1.5 ,gamma=0.06)

# plot SVM



main="SVM")



datest$TEMPE=tt[i]

pred=predict(svm.reg,newdata=datest)



}


Table des matieres

1 Introduction 31.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Rapport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2.1 Contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2.2 Organisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Simulations, echantillonnnage, bootstrap, validation croisee 52.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2 Simulation de lois . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.2.1 Quelques lois discretes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2.2 Lois continues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.2.3 Limite centrale et loi gaussienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.3 Echantillonnage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.3.1 Aleatoire simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.3.2 Avec remise ou bootstrap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.4 Validation croisee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.4.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.4.2 Application au modele lineaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3 Apprentissage et prevision statistique du pic d’ozone 113.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.2 Extraction des echantillons apprentissage et test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.2.1 Rappel : protocole de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.2.2 Prise en charge des donnees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.2.3 Extraction des echantillons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3.3 Regression lineaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.3.1 Modele lineaire simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.3.2 Modele quadratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.3.3 Prevision de l’echantillon test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3.4 Regression logistique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.4.1 Regression logistique sans interaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.4.2 Regression logistique avec interaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3.5 Analyse discriminante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.5.1 Estimations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.5.2 Taux d’erreur sur l’echantillon test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.6 Arbre binaire de decision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.6.2 Estimation et elagage de l’arbre de regression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.6.3 Estimation et elagage d’un arbre de discrimination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.6.4 Prevision de l’echantillon test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.7 Reseaux de neurones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.7.2 Cas de la regression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.7.3 Cas de la discrimination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.7.4 Prevision de l’echantillon test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.8 Agregation de modeles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223.8.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

35


3.8.2 Bagging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.8.3 Foret aleatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.8.4 Boosting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3.9 Separateurs a Vaste Marge (SVM) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.9.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.9.2 Exemple elementaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.9.3 Concentration d’ozone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.10 Ecarts-types d’erreur de prediction estimes sur les fichiers tests . . . . . . . . . . . . . . . . . . . . . . . . . . 293.11 Representation des frontieres de discrimination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Documents

IUP SID Ann ee 2011-2012 Techniques avanc ees de Data ... · plot(suit$nbappt,suit$revenu) # It eration du tirage de l’ echantillon bootstrap et des estimations des r egressions