Devoir libre 1

BIDAOUI MOUHSSINE
2eme année Actuariat-Finance
N:7

Exercice 1 :

Résumé :
Afin de modéliser notre base de données des montants des sinistres, on va
proposer des modèles mathématiques pertinents. Puis, on va essayer de
calibrer ces modèles, en estimant ses paramètres. Ainsi, il faut valider les
modèles à l’aide des tests statistiques et finalement choisir le meilleur modèle
selon les critères établis en cours.
1ere étape : Importer la base de données.
> montant=read.csv("montantssinistre7.csv",sep=';',stringsAsFactors
= FALSE);
> montant$x=sub(",",".",montant$x)
> montant$x=as.numeric(as.character(montant$x))

On affecte les montants à un vecteur qu’on va appeler x :

> x=montant$x
[1] 5.981294 2.803468 4.549282 2.735749 6.542756 3.701204

On trace la fonction de répartition empirique :

> plot(ecdf(x))
3eme étape : Estimer les paramètres des lois qui peut modéliser cette base de
données, et représenter graphiquement ces modèles.
En fait, j’ai estimé les paramètres des lois suivantes : La loi exponentiel, la loi
log normale, et la loi gamma. Voici les résultats obtenus.
> library(MASS)
> fitlognormal=fitdistr(x,"lognormal")$estimate
> fitlognormal
meanlog sdlog
1.336189 0.827281
> fitexpo=fitdistr(x,"exponential")$estimate;
> fitexpo;
rate
0.1986632
> fitgamma=fitdistr(x,"gamma")$estimate;
Warning messages:
1: In densfun(x, parm[1], parm[2], ...) : production de NaN
2: In densfun(x, parm[1], parm[2], ...) : production de NaN
3: In densfun(x, parm[1], parm[2], ...) : production de NaN
4: In densfun(x, parm[1], parm[2], ...) : production de NaN
5: In densfun(x, parm[1], parm[2], ...) : production de NaN
> fitgamma;
shape rate
1.9360648 0.3846249

Ainsi, on représente graphiquement les fonctions de réparations de chaque loi.

> curve(plnorm(x, fitlognormal[1], fitlognormal[2]), add=TRUE ,lwd=
2, col="blue");
> curve(pexp(x, fitexpo[1]), add=TRUE ,lwd=2, col="red");
 > curve(pgamma(x, fitgamma[1],fitgamma[2]), add=TRUE ,lwd=2, col="
green");

D’après ce que précède, on peut remarquer facilement que la loi gamma

modélise bien notre base de données.
3eme étape : Valider le modèle à l’aide d’un test statistique et choisir le
meilleur selon le Critère d’information de Akaike (aic).
En effet, on va utiliser le test de Kolmogorov–Smirnov et choisir le modèle
pertinent.
Ho : F = F0 (F0 modélise bien notre base de données)
H1 : F ≠ F0 (F0 ne modélise pas notre base de données)
F0 : est la fonction de répartition de la loi exponentielle, la loi gamma ou la loi
log normale.
F est la fonction de répartition empirique de la base de données.
Effectuons le test sur R :

> ks.test(x,pexp,fitexpo[1]);
One-sample Kolmogorov-Smirnov test
data: x
 D = 0.1392, p-value < 2.2e-16
alternative hypothesis: two-sided

> ks.test(x,pgamma,fitgamma[1],fitgamma[2]);
One-sample Kolmogorov-Smirnov test
data: x
D = 0.010794, p-value = 0.9515
alternative hypothesis: two-sided
> # p-value > 5% On accepte H0

> ks.test(x,plnorm,fitlognormal[1],fitlognormal[2]);

One-sample Kolmogorov-Smirnov test

data: x
D = 0.055246, p-value = 1.598e-06
alternative hypothesis: two-sided

Le seul modèle ou on a trouvé une p-value > 5% est effectivement celui de la loi
gamma. Donc, cette dernière est la seule loi qui modélise notre base de
données.
Utiliser le AIC dans ce cas n’a pas d’intérêt :
> aiclog=4-fitdistr(x,"lognormal")$loglik;
> aiclog;
[1] 5904.687
> aicgamma=4-fitdistr(x,"gamma")$loglik;
Warning messages:
1: In densfun(x, parm[1], parm[2], ...) : production de NaN
2: In densfun(x, parm[1], parm[2], ...) : production de NaN
3: In densfun(x, parm[1], parm[2], ...) : production de NaN
4: In densfun(x, parm[1], parm[2], ...) : production de NaN
5: In densfun(x, parm[1], parm[2], ...) : production de NaN
> aicgamma;
[1] 5775.839
> aicexp=2-fitdistr(x,"exponential")$loglik;
> aicexp;
[1] 6019.132
> #Si on a le choix entre plusieurs modèles on choisit celui qui a
Le plus petit AIC.

Exercice 2 :

Résumé :
La modélisation des nombres de sinistres n’est pas différente de la
modélisation précédente. En effet, on va procéder de la même manière.
Commençons par une analyse exploratoire des données et proposons quelques
modèles adéquats. Ensuite, on va estimer les paramètres de chaque modèle et
faire un ajustement. Et enfin valider ou non le modèle concerné à travers le
test de KHI DEUX.
1ere étape : Importer, visualiser et analyser la base de données :
> getwd()
[1] "C:/Users/By_the_way/Documents"
> library(MASS)
> Mouhssine=read.csv("nombresinistre7.csv",sep=";")
> x=Mouhssine$x
> y=table(x)

La base de données présente 5 modalités.

> mean(x)
[1] 3.23913
> var(x)
[1] 1.140704
> barplot(y,col="yellow",main="frequence des sinistres")

On remarque que la moyenne des nombres de sinistres est supérieure à la

variance. Ce qui nous donne une idée initiale sur la loi qui modélise cette base
de données. Il s’agit de la loi binomiale.
2eme étape : Estimer les paramètres de chaque modèle et faire les
ajustements nécessaires :
1. Loi de poisson :
A l’aide de la fonction goodfit on peut estimer les effectifs espérés, on estime
aussi le paramètre de la loi de poisson, et faire ainsi l’ajustement :
> goodfit(x,"pois")
Observed and fitted values for poisson distribution
with parameters estimated by `ML'

count observed fitted pearson residual

0 9 90.15532 -8.547150
1 130 292.02484 -9.481383
2 392 472.95328 -3.722420
3 806 510.65245 13.069852
4 697 413.51747 13.940532
5 266 267.88741 -11.161712
> parmpois=goodfit(x,"pois")$par
> parmpois$lambda
[1] 3.23913
> plot(goodfit(x,"pois"),main="ajustement loi poisson")
On peut facilement remarquer à partir de ce graphique, les grands écarts entre
les effectifs observés et celles estimés par le modèle de poisson.
2. Loi binomiale négative :
On procède de la même manière.
> goodfit(x,"nbinom",par=list(size=5))
Observed and fitted values for nbinomial distribution
with parameters estimated by `ML with size fixed'
count observed fitted pearson residual
0 9 189.3089 -13.104837
1 130 372.1243 -12.551463
2 392 438.8907 -2.238248
3 806 402.6059 20.104320
4 697 316.5609 21.382405
5 266 224.0148 -13.053559
> parmnbino=goodfit(x,"nbinom",par=list(size=5))$par;
> parmnbino;
$size
[1] 5
$prob
[1] 0.6068602
> plot(goodfit(x,"nbinom",par=list(size=5)),main="ajustement loi bino
miale négative")
Ainsi on voit que la loi binomiale négative ne modélise pas bien la base de
données.
Loi binomiale :
On a déjà trouvé que E(x) > Var(x) et on a anticipé que la loi binomiale est la loi
pertinente adéquate. Pour vérifier cela, on procède de la même manière.
> goodfit(x,"binom",par=list(size=5))
Observed and fitted values for binomial distribution
with parameters estimated by `ML'
count observed fitted pearson residual
0 9 12.45988 -0.9801753
1 130 114.60010 1.4385513
2 392 421.61519 -1.4423026
3 806 775.56374 1.0929051
4 697 713.32715 -0.6113163
5 266 262.43394 0.2201298
> parmbino=goodfit(x,"binom",par=list(size=5))$par;
> parmbino;
$prob
[1] 0.6478261
$size
[1] 5
> plot(goodfit(x,"binom",par=list(size=5)),main="ajustement loi binom
iale");
On constate que la loi binomiale modélise le nombre de sinistres.
3eme étape : Vérifier les résultats (TEST KHI DEUX) :
Soit k un vecteur des effectifs observés et pp un vecteur des effectifs estimés.
Loi de poisson :
> k=rep(0,length(y))
> k
[1] 0 0 0 0 0 0
> k[1:length(y)]=y[1:length(y)]
> k
[1] 9 130 392 806 697 266
> #k effectif observe
> length(x)*dpois(0:5,parmpois$lambda)<5
[1] FALSE FALSE FALSE FALSE FALSE FALSE
> #le nombre espéré de données dans chacune des
Classes est supérieur à 5
> pp=c(dpois(0:4,parmpois$lambda),1-sum(dpois(0:4,parmpois$lambda)))
> pp
[1] 0.03919797 0.12696732 0.20563186 0.22202281 0.17979021 0.22638984
> length(x)*pp
[1] 90.15532 292.02484 472.95328 510.65245 413.51747 520.69663
> chisq.test(k,p=pp)
Chi-squared test for given probabilities
data: k
X-squared = 666.55, df = 5, p-value < 2.2e-16
> qchisq(0.95,4)
[1] 9.487729
> pvalue=1-pchisq(chisq.test(k,p=pp)$statistic,4)
> pvalue
X-squared
0
On peut remarquer facilement que p-value < 5%, ce qui vérifie que le modèle
de poisson n’est pas valable pour cette base de données.
Loi binomiale négative :
> length(x)*dnbinom(0:5,size=parmnbino$size,prob=parmnbino$prob)<5
[1] FALSE FALSE FALSE FALSE FALSE FALSE
> k=rep(0,length(y))
> k[1:length(y)]=y[1:length(y)]
> k
[1] 9 130 392 806 697 266
> nn=c(dnbinom(0:4,size=parmnbino$size,prob=parmnbino$prob),1-sum(dnb
inom(0:4,size=parmnbino$size,prob=parmnbino$prob)))
> nn
[1] 0.0823082 0.1617932 0.1908220 0.1750461 0.1376352 0.2523954
> length(x)*nn
[1] 189.3089 372.1243 438.8907 402.6059 316.5609 580.5093
> chisq.test(k,p=nn)
Chi-squared test for given probabilities

data: k
X-squared = 1366.1, df = 5, p-value < 2.2e-16
> qchisq(0.95,4)
[1] 9.487729
> pvalue=1-pchisq(chisq.test(k,p=nn)$statistic,4)
> pvalue
X-squared
0

P-value < 5%, ce qui explique les résultats précédents (La loi binomiale négative
ne modélise la base de données).

Loi binomiale :
> length(x)*dbinom(0:5,size=parmbino$size,prob=parmbino$prob)<5;
[1] FALSE FALSE FALSE FALSE FALSE FALSE
> k=rep(0,length(y))
> k
[1] 0 0 0 0 0 0
> # k=0 0 0 0 0 0 0
> k[1:length(y)]=y[1:length(y)]
> k
[1] 9 130 392 806 697 266
> pp=c(dbinom(0:4,size=parmbino$size,prob=parmbino$prob),1-sum(dbinom
(0:4,size=parmbino$size,prob=parmbino$prob)));
> pp
[1] 0.005417338 0.049826131 0.183310952 0.337201628 0.310142238 0.114
101712
> length(x)*pp
[1] 12.45988 114.60010 421.61519 775.56374 713.32715 262.43394
> chisq.test(k,p=pp);

Chi-squared test for given probabilities

data: k
X-squared = 6.727, df = 5, p-value = 0.2417
> qchisq(0.95,4)
[1] 9.487729
> pvalue=1-pchisq(chisq.test(k,p=pp)$statistic,4)
> pvalue
 X-squared
0.1510368
On a pvalue > 5% .
Conclusion : Le modèle approprié à cette base de données et la loi binomiale.

Code R :
> #Exercice 2 : (nombres sinistres)
> x=montant$x >
plot(ecdf(x))
> library(MASS)
> fitlognormal=fitdistr(x,"lognormal")$estimate
> fitlognormal
> fitexpo=fitdistr(x,"exponential")$estimate;
> fitexpo
> fitgamma=fitdistr(x,"gamma")$estimate;
> fitgamma
> curve(plnorm(x, fitlognormal[1], fitlognormal[2]), add=TRUE ,lwd= 2, col
="blue")
>curve(pexp(x, fitexpo[1]), add=TRUE ,lwd=2, col="red")
> curve(pgamma(x, fitgamma[1],fitgamma[2]), add=TRUE ,lwd=2, col=" green"
);
> ks.test(x,pexp,fitexpo[1])
> ks.test(x,pgamma,fitgamma[1],fitgamma[2])
> # p-value > 5% On accepte H0
> ks.test(x,plnorm,fitlognormal[1],fitlognormal[2])
> aiclog=4-fitdistr(x,"lognormal")$loglik
> aiclog
> aicgamma=4-fitdistr(x,"gamma")$loglik
> aicgamma;
> aicexp=2-fitdistr(x,"exponential")$loglik
> aicexp
#Si on a le choix entre plusieurs modèles on choisit celui qui a Le plu
s petit AIC.

> #Exercice 2 : (nombres sinistres)

> #Loi de Poisson :
> getwd()
> library(MASS)
> Mouhssine=read.csv("nombresinistre7.csv",sep=";")
> head(Mouhssine)
> x=Mouhssine$x
> mean(x)
> var(x)
> y=table(x)
> y
> length(y)
> barplot(y,col="blue",main="frequence des sinistres")
> install.packages("vcd")
> library("vcd")
> install.packages("grid")
> goodfit(x,"pois")
> binpois=goodfit(x,"pois")$par
> parmpois=goodfit(x,"pois")$par
> parmpois$lambda;
> plot(goodfit(x,"pois"),main="ajustement loi poisson")
> k=rep(0,length(y))
> k[1:length(y)]=y[1:length(y)]
> length(x)*dpois(0:5,parmpois$lambda)<5
> pp=c(dpois(0:4,parmpois$lambda),1-sum(dpois(0:4,parmpois$lambda)))
> pp
> length(x)*pp
> chisq.test(k,p=pp)
> qchisq(0.95,4)
> pvalue=1-pchisq(chisq.test(k,p=pp)$statistic,4);
> pvalue;

> #Binomiale négative :

> goodfit(x,"nbinom",par=list(size=5))
> parmnbino=goodfit(x,"nbinom",par=list(size=5))$par
> parmnbino
> plot(goodfit(x,"nbinom",par=list(size=5)),main="ajustement loi binomiale
négative")
> length(x)*dnbinom(0:5,size=parmnbino$size,prob=parmnbino$prob)<5
> k=rep(0,length(y))
> k
> k[1:length(y)]=y[1:length(y)]
> k
> nn=c(dnbinom(0:4,size=parmnbino$size,prob=parmnbino$prob),1-sum(dnbinom(0
:4,size=parmnbino$size,prob=parmnbino$prob)));
> nn
> length(x)*nn
> chisq.test(k,p=nn)
> qchisq(0.95,4)
> pvalue=1-pchisq(chisq.test(k,p=nn)$statistic,4)
> pvalue

> #Binomiale :
> parmbino=goodfit(x,"binom",par=list(size=5))$par
> parmbino
> plot(goodfit(x,"binom",par=list(size=5)),main="ajustement loi binomiale")
> length(x)*dbinom(0:5,size=parmbino$size,prob=parmbino$prob)<5;> goodfit(x
,"binom",par=list(size=5))
> k=rep(0,length(y))
> k[1:length(y)]=y[1:length(y)]
> k
> pp=c(dbinom(0:4,size=parmbino$size,prob=parmbino$prob),1-sum(dbinom(0:4,s
ize=parmbino$size,prob=parmbino$prob)))
> pp
> length(x)*pp
> chisq.test(k,p=pp)
> qchisq(0.95,4)
> pvalue=1-pchisq(chisq.test(k,p=pp)$statistic,4)
> pvalue