Category Archives: Stochastic Processes

Actuarial science, Computer, Stochastic Processes

Generating a non-homogeneous Poisson process

21/12/2012 Arthur Charpentier 3 Comments

Consider a Poisson process $gif.latex (54×20)$ , with non-homogeneous intensity $\lambda(t)$ . Here, we consider a deterministic function, not a stochastic intensity. Define the cumulated intensity

$\Lambda(t)=\int_0^t\lambda(s)ds$

in the sense that the number of events that occurred between time $gif.latex (8×13)$ and $gif.latex (6×12)$ is a random variable that is Poisson distributed with parameter $\Lambda(t)$ .

For example, consider here a cyclical Poisson process, with intensity

   lambda=function(x) 100*(sin(x*pi)+1)

To compute the cumulated intensity, consider a very general function

   Lambda=function(t) integrate(f=lambda,lower=0,upper=t)$value

The idea is to generate a Poisson process on a finite interval $[0,T]$ .

The first code is based on a proposition from Çinlar (1975),

start with $https://latex.codecogs.com/gif.latex?s=0$
generate $gif.latex (96×19)$
set $gif.latex (112×19)$
set $gif.latex (6×12)$ denote $gif.latex (124×19)$
deliver $t$
go to step 2.

In order to get the infinimum of $gif.latex (12×13)$ , consider a code as

   v=seq(0,Tmax,length=1000)
   t=min(v[which(Vectorize(Lambda)(v)>=s)])

(it might not be very efficient…. but it should work). Here, the code to generate that Poisson process is

   s=0; v=seq(0,Tmax,length=1000)
   X=numeric(0)
   while(X[length(X)]<=Tmax){
     u=runif(1)
     s=s-log(u)
     t=min(v[which(Vectorize(Lambda)(v)>=s)])
     X=c(X,t)
   }

Here, we get the following histogram,

   hist(X,breaks=seq(0,max(X)+1,by=.1),col="yellow")
   u=seq(0,max(X),by=.02)
   lines(u,lambda(u)/10,lwd=2,col="red")

Consider now another strategy. The idea is to use the conditional distribution before the next event, given that one occurred at time $t$ ,

$F_t(x)=1-\exp\left(\Lambda(x)-\Lambda(x+t)\right)=1-\exp\left(-\int_t^{t+x}\lambda(s)ds\right)$

start with $t=0$
generate $gif.latex (51×16)$
set $gif.latex (74×14)$
deliver $t$
go to step 2.

Here the algorithm is simple. For the computational side, at each step, we have to compute $F_t$ and then $http://www.forkosh.com/cgi-bin/mathtex.cgi?formdata=F_t%5E%7B-1%7D$ . To do so, since $F_t$ is increasing with values in $[0,1]$ , we can use a dichotomic algorithm,

   Ft=function(x) 1-exp(-Lambda(t+x)+Lambda(t))
   Ftinv=function(u){
     a=0
     b=Tmax
     for(j in 1:20){
       if(Ft((a+b)/2)<=u){binf=(a+b)/2;bsup=b}
       if(Ft((a+b)/2)>=u){bsup=(a+b)/2;binf=a}
       a=binf
       b=bsup
     }
   return((a+b)/2)
   }

Here the code is the following

   t=0; X=t
   while(X[length(X)]<=Tmax){
     Ft=function(x) 1-exp(-Lambda(t+x)+Lambda(t))
     Ftinv=function(u){
      a=0
      b=Tmax
      for(j in 1:20){
        if(Ft((a+b)/2)<=u){binf=(a+b)/2;bsup=b}
        if(Ft((a+b)/2)>=u){bsup=(a+b)/2;binf=a}
        a=binf
        b=bsup
      }
      return((a+b)/2)
     }
     x=Ftinv(runif(1))
     t=t+x
     X=c(X,t)
   }

The third code is based on a classical algorithm to generate an homogeneous Poisson process on a finite interval: first, we generate the number of events, then, we draw uniform variates, and we sort them. Here, the strategy is closed, except that is won’t be uniform any longer.

generate the number of events on the time interval $gif.latex (101×19)$
generate independently $gif.latex (114×17)$ where $F(t)=\Lambda(t)/\Lambda(T)$
set $gif.latex (60×15)$ i.e. the ordered values $gif.latex (136×16)$
deliver $http://www.forkosh.com/cgi-bin/mathtex.cgi?formdata=t_i$ ‘s

This algorithm is extremely simple, and also very fast. This is one function to inverse, and it is not in the loop,

   n=rpois(1,Lambda(Tmax))
   Ft=function(x) Lambda(x)/Lambda(Tmax)
   Ftinv=function(u){
     a=0
     b=Tmax
     for(j in 1:20){
       if(Ft((a+b)/2)<=u){binf=(a+b)/2;bsup=b}
       if(Ft((a+b)/2)>=u){bsup=(a+b)/2;binf=a}
       a=binf
       b=bsup
     }
     return((a+b)/2)
     }
   X0=rep(NA,n)
   for(i in 1:n){
     X0[i]=Ftinv(runif(1))
    }
   X=sort(X0)

Here is the associated histogram,

An alternative is based on a rejection technique. Actually, it was the algorithm mentioned a few years ago on this blog (well, the previous one). Here, we need an upper bound for the intensity, so that computations might be much faster. Here, consider

start with $t=0$
generate $gif.latex (96×19)$
set $gif.latex (137×19)$
generate $gif.latex (95×19)$ (independent of $http://www.forkosh.com/cgi-bin/mathtex.cgi?formdata=u$ )
if $gif.latex (90×19)$ then deliver $http://www.forkosh.com/cgi-bin/mathtex.cgi?formdata=t$
go to step 2.

Here, consider a constant upper bound,

   lambdau=function(t) 200
   Lambdau=function(t) lambdau(t)*t

The code to generate a Poisson process is

   t=0
   X=numeric(0)
   while(X[length(X)]<=Tmax){
     u=runif(1)
     t=t-log(u)/lambdau
     if(runif(1)<=lambda(t)/lambdau) X=c(X,t)
  }

The histogram is here

Finally, the last one is also based on a rejection technique, mixed with the second one. I.e. define

$gif.latex (433×20)$

The good thing is that this function can easily be inverted

$gif.latex (215×21)$

start (as usual) with $t=0$
generate $gif.latex (63×19)$
set $gif.latex (74×14)$
generate $gif.latex (96×19)$
if $gif.latex (124×19)$ then deliver $http://www.forkosh.com/cgi-bin/mathtex.cgi?formdata=t$
goto step 2.

Here, the algorithm is simply

   t=0
   while(X[length(X)]<=Tmax){
     Ftinvu=function(u) -log(1-x)/lambdau
     x=Ftinvu(runif(1))
     t=t+x
     if(runif(1)<=lambda(t+x)/lambdau(t+x)) X=c(X,t)
   }

Obviously those five codes work, the first one being much slower than the other three. But it might be because my strategy to seek the infimum is not great. And the latter worked well since there were not much rejection, I guess it can be worst…

All those algorithms were mentioned in a nice survey written by Raghu Pasupathy and can be downloaded from http://web.ics.purdue.edu/~pasupath/…. In the paper, non-homogeneous spatial Poisson processes are also mentioned…

Computer, Probability, Stochastic Processes

Ruin probability and infinite time

27/03/2012 Arthur Charpentier Leave a comment

A couple of weeks ago, I had a discussion with a practitioner, working in some financial company, about ruin, and infinite time. And it reminded me a weird result. Well, not a weird result, but a result I found disturbing, at first, when I was a student (that I rediscovered with the eyes of someone dealing with computational issues, seeing here a difficult theoretical question). Consider a simple ruin problem. A player has wealth . Then he flips a coin: tails he has a gain of 1, heads he experiences a loss of 1. At time , his wealth is where is associated to the th coin: is equal to 1 with probability (tails), and -1 with probability (heads). It is also possible to write

where can be interpreted as the net gain of the player. In order to get a good understanding of results that can be obtained. Assume to be given. Let denote the number of heads and the number of tails. Then , while . Let denote the number of paths to go from point A (wealth at time ) to point B (wealth at time ). Note that this is a Markovian problem, that can be modeled using Markov chains

But here, we will focus on combinatorial results. Hence,

In order to derive probabilities to reach , let denote the number of paths going from to . And let denote the number of paths going from to that do reach at some point between and . Using a simple reflexion property, then if and are positive,

Based on those reflexions, two results can be derived (focusing on probability, instead of counting paths). First, we can obtain that

(given that n and x have the same parity). The second result we can obtain is that

Based on those two expressions, if denotes the first time become null, given ,

then

This can be computed easily,

> x=10
> p=.55
> ProbN=function(n){
+ pb=0
+ if(abs(n-x) %% 2 == 0)
+ pb=x/n*choose(n,(n+x)/2)*(1-p)^((n+x)/2)*(p)^((n-x)/2)
+ return(pb)}
> plot(Vectorize(ProbN)(1:1000),type="s")

That looks nice… But if we look closer, we can wonder what

would be ? Since we have the distribution of a probabilty measure, we might expect one. But here

> sum(Vectorize(ProbN)(1:1000))
[1] 0.134385

And this is not due to calculation mistakes that we do not get 1 here. Actually, we should write

which might be interpreted as the probability of ruin, starting from , that we denote from now on. The term on the left can be approximated using monte-carlo simulations

> p=.55
> x=10
> m=1000
> simul=10000
> S=sample(c(-1,1),size=m*simul,replace=TRUE,prob=c(1-p,p))
> MS=matrix(S,simul,m)
> for(k in 2:m) MS[,k]=MS[,k]+MS[,k-1]
> T0=function(vm) which(vm<=(-x))[1]
> MTmin=apply(MS,1,T0)
> mean(is.na(MTmin)==FALSE)
[1] 0.1328

To check the validity of the relationship above, a simple (theoretical) recursive formula can be derived for the term on the right (ruin probability), namely

with a boundary conditions , and . Then is comes that

Note that it might be tricky to check using monte carlo simulation… since we cannot have an infinite number of runs. And we’re dealing precisely with things that do occur when time is infinite. Actually, we can still check convergence, considering an upper limit for the number of runs, and then letting go to infinity. Note that an explicit formula can then be derived (using additional border condition )

Using the following code, it is possible to calculate ruin probability, in order to estimate .

> MSmin=apply(MS,1,min)
> mean(MSmin<=(-x))
[1] 0.1328
> (((1-p)/p)^x-((1-p)/p)^m)/(1-((1-p)/p)^m)
[1] 0.1344306

The following graph shows the evolution of ruin probability as a function of initial wealth (with monte carlo simulation, with a fixed horizon – including a confidence interval – versus the analytical expression)

Hence, with stopping times, one should remember that

and that those two terms can be approximated simply using simulations or standard approximations.

ACT6420, Computer, Stochastic Processes, Time Series

La maudite constante des modèles ARIMA

21/03/2012 Arthur Charpentier 1 Comment

Dans les modèles ARIMA, autant le dire tout de suite, les constantes c’est pénible ! Pour comprendre un peu mieux ce qui se passe, considérons ici un modèle ARMA avec constante. Ou pour commencer, juste un AR(1)

Supposons que la série soit stationnaire, de moyenne . Alors en prenant l’espérance de part et d’autre dans l’expression précédente, , i.e. , ou . Plus généralement, avec un ARMA, , en prenant la encore l’espérance des deux cotés, on en déduit .

Simulons un processus AR(1),

Pour simuler des processus ARIMA, on pourrait utiliser la commande

> X=arima.sim(list(order=c(1,0,0),ar=1/3),n=1000)+2
> mean(X)
[1] 1.931767

mais comme le but est de comprendre ce qui se passe, autant faire les choses calmement,

> X=rep(NA,1010)
> X[1]=0
> for(t in 2:1010){X[t]=4/3+X[t-1]/3+rnorm(1)}
> X=X[-(1:10)]
> mean(X)
[1] 2.03397

I.e. ici le processus est de moyenne qui vaut 2.

Regardons maintenant ce que donnerait l’estimation du processus AR(1),

> arima(X, order = c(1, 0, 0))

Call:
arima(x = X, order = c(1, 0, 0))

Coefficients:
ar1  intercept
0.3738     2.0334
s.e.  0.0294     0.0487

sigma^2 estimated as 0.9318:  log likelihood = -1383.68

De manière un peu surprenante, le coefficient appelé intercept n’est pas la constante dans le modèle AR(1), mais la moyenne du processus. Autrement dit, R n’ajuste pas un processus

comme le laisserait penser l’intuition, mais un processus

Ces deux formes sont bien entendu équivalentes. Mais les coefficients estimés ne sont pas tout à fait ce que l’on attendait…
Plaçons nous maintenant dans le cas d’un processus non-stationnaire. L’extension naturelle serait de considérer un processus ARIMA(1,1,0), ou bien un processus tel que la différence soit un processus AR(1). Un processus ARIMA(1,1,0) avec une constante s’écrirait

en utilisant l’opérateur retard. Ceci fait penser à un modèle avec une tendance linéaire. Posons (afin de se débarrasser de cette tendance). Alors

i.e.

ou encore

On note que ou encore suit alors un processus ARIMA(1,1,0) sans constante cette fois.
Afin de visualiser ce que donnerait l’inférence, simulons le processus suivant, qui est un processus AR(1) avec constante que l’on intègre: avec

Peut-on retrouver les différents paramètres du processus avec R ?
Commençons (là encore) par simuler un tel processus,

> U=rep(NA,1010)
> U[1]=0
> for(t in 2:1010){U[t]=4/3+U[t-1]/3+rnorm(1)}
> U=U[-(1:10)]
> X=cumsum(U)

Sous R, on obtient l’estimation suivant si l’on tente de calibrer un modèle ARIMA(1,1,0)

> arima(X, order = c(1, 1, 0))

Call:
arima(x = X, order = c(1, 1, 0))

Coefficients:
ar1
0.8616
s.e.  0.0160

sigma^2 estimated as1.343:loglikelihood = -1565.63Ça ne convient pas du tout…. On peut tenter un processus AR(1) (avec constante) sur la série différenciée…

> arima(diff(X), order = c(1, 0, 0))

Call:
arima(x = diff(X), order = c(1, 0, 0))

Coefficients:
ar1  intercept
0.3564     2.0200
s.e.  0.0295     0.0486

sigma^2 estimated as 0.9782:  log likelihood = -1406.6

On progresse, sauf que comme auparavant, le terme qui est donne n’est pas la constante dans le modèle ARIMA, mais la moyenne du processus différencié. Mais cette fois, on a un interprétation, c’est que la constante est la pente de la tendance ! Si on estime la pente associée a , on récupère la même valeur:

> arima(X, order = c(1, 1, 0), xreg=1:length(X))

Call:
arima(x = X, order = c(1, 1, 0), xreg = 1:length(X))

Coefficients:
ar1  1:length(X)
0.3566       2.0519
s.e.  0.0296       0.0487

sigma^2 estimated as 0.9787:  log likelihood = -1406.82

Sur la figure ci-dessous, on retrouve le fait qu’en enlevant la tendance linéaire à donneune série intégrée, sans constante (qui fait penser à une marche aléatoire).

Autrement dit

dans le cas d’une série stationnaire, la constante estimée n’est pas du tout la constante, mais la moyenne de la série temporelle
dans le cas d’une série non-stationnaire, la constante estimée dans la série différenciée a du sens, au sens ou il s’agit de la pente de la tendance (linéaire) du processus

Avant de conclure, une petite remarque. Quid de la prévision ? Si on commencer par une révision à l’aide du premier processus ARIMA, on obtient une prédiction pour avec un énorme intervalle de confiance (sans aucun bon sens)

> ARIMA1=arima(X, order = c(1, 1, 0))
> ARIMA2=arima(X, order = c(1, 1, 0), xreg=1:length(X))
> Xp1=predict(ARIMA1,20)
> Xp2=predict(ARIMA2,20,newxreg=
+ (length(X)+1):(length(X)+20))
> plot(960:1000,X[960:1000],xlim=c(960,1020),type="l")
> polygon(c(1001:1020,rev(1001:1020)),
+ c(Xp1$pred+2*Xp1$se,rev(Xp1$pred-2*Xp1$se)),
+ col=CL[3],border=NA)
> lines(1001:1020,Xp1$pred,col="red",lwd=2)

intervalle qui se visualise sur le graphique ci-dessous,

Si on regarde pour l’autre modèle,

> lines(1001:1020,Xp2$pred,col="blue",lwd=2)

Tous ceux qui auront reconnu ici des problèmes qui se posent dans la modélisation de la série

http://freakonometrics.blog.free.fr/public/maths/viekt.png

dans le modèle de Lee & Carter (1992) auront compris qu’il existe une vraie application a tout ce que je viens de raconter (je pense au particulier au commentaire poste par @ClaudeT en début de semaine) car la série des

ressemble très fortement à ce genre de série, non-stationnaire avec une tendance linéaire. Et qu’un modèle mal spécifié laisse à penser que l’incertitude est beaucoup beaucoup plus grande que ce qu’elle est vraiment (en plus de donner une prédiction surprenante à long terme !). Donc avant de faire tourner rapidement les codes, il vaut mieux regarder attentivement ce qu’ils font réellement…

Computer, Stochastic Processes

Simulation d’un processus de Lévy, et discrétisation

19/03/2012 Arthur Charpentier 1 Comment

Avec @renaudjf, on discutait l’autre jour de la simulation d’un processus de Lévy. Et on se posait la question d’un algorithme optimal pour combiner un processus de Poisson (ou un process Poisson composé) avec un processus de Wiener (avec éventuellement un drift, voire une diffusion plus générale). En fait, pour générer des processus de Poisson, j’ai toujours eu l’habitude de simuler les durées entre sauts (avec des lois exponentielles, indépendantes, comme dans des vieux billets). Jean François me suggérait d’utiliser une propriété d’uniformité des sauts sur un intervalle de temps donné, conditionnellement aux nombres de sauts.

Commençons par la première piste. On peut générer un processus de Wiener, éventuellement avec un drift, et à coté, on peut générer les lois exponentielles (qui vont correspondre aux durées entre sauts), et éventuellement aussi des amplitudes de sauts (e.g. des pertes qui suivent des lois exponentielles). On a ici

où . On commence par générer en notant que

où les incréments sont Gaussiens (centrés et de variance ) et indépendants les uns des autres. Quant aux durées entre sauts, les , ce sont des lois exponentielles indépendantes, de moyenne . Voilà le code qui permet de générer les trois composantes,

n=1000
h=1/n
lambda=5
set.seed(2)
W=c(0,cumsum(rnorm(n,sd=sqrt(h))))
W=rexp(100,lambda)
N=sum(cumsum(W)<1)
T=cumsum(W[1:N])
X=-rexp(N)

Le hic est que pour le processus de Wiener, on a du discrétiser, alors que pour le processus de Poisson composé, non. Pourtant, il va bien se ramener sur une même échelle de temps. Une première piste est de créer vraiment la fonction

Lt=function(t){
W[trunc(n*t)+1]+sum(X[T<=t])+lambda*t
}

et pour faire un dessin ensuite, c’est un jeu d’enfant

L=Vectorize(Lt)
u=seq(0,1,length=n+1)
plot(u,L(u),type="l",col="blue")

Une autre possibilité est d’utiliser une propriété d’uniformité du processus de Poisson que j’évoquais en introduction. Car le processus de Poisson vérifie une propriété remarquable: si est la date où survient le ième saut, , alors conditionnellement au fait que , les variables correspondent aux statistiques d’ordres de variables indépendantes, uniformément distribuées sur , i.e.

Cette propriété se trouve dans Wolff (1982). L’idée de la démonstration est relativement simple. Commençons avec un (unique) saut, alors pour ,

i.e. on retrouve la fonction de répartition d’une loi uniforme sur . On itère ensuite avec 2 sauts, 3 sauts, etc.

La traduction en R de cette idée est tout simplement (car on se place sur )

N=rpois(1,lambda)
T=runif(N)
X=-rexp(N)

Ensuite, une stratégie est de discrétiser le processus de Poisson, avec le même pas de temps que le processus de Wiener,

indice=trunc(T*n)+1
saut=rep(0,n+1)
saut[indice]=X
processus=W+cumsum(saut)+lambda*u

On retrouve la même trajectoire qu’auparavant

plot(u,processus,type="l",col="red")

Sauf qu’on a eu de la chance. Avec cette procédure, il ne faut pas que l’on ait deux sauts dans le même intervalle de temps ! Bon, il est vrai qu’une caractérisation du processus de Poisson est que

et donc on doit avoir très peu de chance d’avoir deux sauts au même instant d’autant plus que le pas de temps est petit. Mais “peu de chance” ne veut pas dire nul, et si on génère des milliers de trajectoires, la probabilité d’avoir une fois un soucis n’est pas négligeable.

Jean-François a eu l’idée brillante de proposer de tirer non pas des lois uniformes sur , mais des lois uniformes discrètes, dans

T=c(0,sort(sample((1:(n-1)/n),size=N,replace=FALSE)))

sans remise afin d’éviter d’avoir deux sauts au même moment. L’idée était séduisante, mais il me restait à etre convaincu que les durées entre sauts… continuaient à être (presque) exponentielles.

Pour ça, on peut faire quelques tests. Par exemple, générer quelques simulations pour avoir une centaines de sauts (et donc une centaine de durées entre sauts), puis faire un test de loi exponentielle (de moyenne )

VT=0
for(ns in 1:20){
N=rpois(1,lambda)
if(N>0){
T=c(0,sort(sample((1:(n-1)/n),size=N,replace=FALSE)))
VT=c(VT,diff(T))
}}

On fait ici 20 boucles car on avait fixé

lambda=5

et j’avais dit que je voulais une centaine d’observations pour faire un test de loi (ce qui est purement arbitraire, on en conviendra). On peut ensuite faire un test d’ajustement de loi exponentielle,

ks.test(VT[-1],"pexp",lambda)$p.value

Si on répète un grand nombre de fois, en changeant le pas de temps (ou le nombre de subdivisons de l’intervalle de temps), on notera qu’effectivement, avec un grand pas de temps (à gauche ci-dessous) on rejette souvent, voire presque toujours, l’hypothèse de loi exponentielle. Mais qu’assez vite, c’est une hypothèse qui n’est pas invraisemblable,

Je ne sais pas entre ces deux fonctions ce qui serait le plus rapide, mais on a deux jolis algorithmes pour générer les processus de Lévy. Non ?

Computer, Finance, Stochastic Processes, Time Series

Gold price and fear

18/01/2012 Arthur Charpentier 1 Comment

Via @theEconomist, I understood that there might be connections between the price of Gold (which is said to be extremely high nowadays) and the VIX SP500 index (the option volatility index, i.e. the so-called “fear index“, as discussed – in French- a few months ago). This has been discussed also on several blogs, e.g. http://etfdailynews.com/ or http://blogs.marketwatch.com/. Via Yahoo quotes, it is possible to get also easily the

SP500 VIX index.

> library(tseries)
> X=get.hist.quote("^VIX")
> T=time(VIX)
> Y=as.POSIXlt(T)$year+1900
> X2011=X[Y==2011,]
> VIX=X2011[,4]
> VIX100=as.numeric(VIX)/VIX[1]*100
> T2011=T[Y==2011]
> plot(T2011,VIX100,lwd=2,col="red",type="l",
+ xlab="",ylab="",ylim=c(60,290))

And a huge xls file can give us the price of gold (on a daily basis). But we can extract only one series (with the price in USD, which is the series of interest here)

> goldprice=read.table(
+ "http://freakonometrics.blog.free.fr/
  public/data/goldpriceUSD.csv",
+ header=TRUE,sep=";",dec=",")
> T=as.Date(goldprice$Name,"%d/%m/%y")
> GP=goldprice$USdollar
> Y=as.POSIXlt(T)$year+1896
> GP2011=GP[Y==2011]
> GP100=GP2011/GP2011[1]*100
> T2011=T[Y==2011]
> lines(T2011-4*365.25,GP100,lwd=2,col="blue")

We can see that scales are quite different on those two series (starting at 100 at the beginning of January 2011),

An alternative might be not to consider the price of gold, but something more psychological, like Internet researches. It is possible to download the csv file for queries on gold price on Google, via google insight.

 
> google=read.table(
+ "http://freakonometrics.blog.free.fr/public/data/google.csv",
+ skip=4,header=TRUE,sep=",",nrows=51)
> W=as.Date(substr(as.character(google$Semaine),1,10))
> G=google$gold.price
> G100=G/G[1]*100
> lines(W,G100,lwd=2,col="blue")

which gives the following graph (again, starting at 100 at the beginning of January 2011),

Here, we can clearly observe that the two series are related, maybe cointegrated. Nice isn’t it ?

Computer, Maths, Probability, Stochastic Processes

Quel lancer de dé faire à Serpents et Échelles ?

21/12/2011 Arthur Charpentier 1 Comment

Hier soir , j’évoquais l’utilisation des chaînes de Markov au jeu Serpents et Échelles. Comme me le faisait remarquer Jean-Philippe, de manière assez étrange, les enfants sont toujours beaucoup plus content après avoir fait un 6 qu’après avoir fait un 1. Mais est-ce réellement la valeur optimale que le dé doit prendre ? Ça dépend bien sûr de la position. Par exemple, au premier lancer, on peut se demander ce que deviendrait le nombre de tours moyen nécessaires pour finir le jeu, conditionnellement aux 6 lancers possibles. On peut calculer, toujours conditionnellement aux 6 valeurs possibles de dés (et des positions où on va se retrouver), l’espérance du nombre de tours pour finir la partie,

esperance=function(h0){
INITIAL = as.numeric(which(M[h0+1,]>0))-1
ESPERANCE=rep(NA,length(INITIAL))
names(ESPERANCE)=INITIAL
for(k in 1:length(INITIAL)){
initial=rep(0,n+1); initial[INITIAL[k]]=1
distrib=initial%*%M
game=rep(NA,1000)
for(h in 1:length(game)){
game[h]=distrib[n+1]
distrib=distrib%*%M}
ESPERANCE[k]=sum(1-game)}
return(ESPERANCE)}

(à partir du code mis en ligne hier), e.g. pour le premier lancer,

> esperance(0)
1        2        3        5        6       14
32.16499 31.99947 31.82348 31.47954 31.36441 29.83020

où la valeur indiquée est la position où l’on pourrait se retrouver (la dernière correspond à un 4). On note que le meilleur premier lancer possible est celui qui nous amène sur la première échelle, i.e. la 4ème case,

Si on regarde case par case, on a les valeurs des “meilleurs” lancers de dés suivant (sans forcément l’unicité) en fonction de sa position sur le plateau

(avec en rouge les serpents et en bleu les échelles). Amusant non ?

Computer, Finance, Stochastic Processes, Time Series

Short selling, volatility and bubbles

18/10/2011 Arthur Charpentier 4 Comments

Yesterday, I wrote a post (in French) about short-selling in financial market since some journalists claimed that it was well-known that short -selling does increase volatility on financial market. Not only in French speaking journals actually, since we can read on http://www.forbes.com that « in a market with restrictions on short-selling, volatility is reduced ». But things are not that simple. For instancehttp://www.optionsatoz.com/ explains it from a theoretical point of view. But we can also look at the data. For instance, we can compare the stock price of Air China, exchanged in Shanghai in blue (where short-selling is forbidden) and in Hong Kong in rouge (where short-selling is allowed), since @Igor gave me the tickers of those stocks

library(tseries)
X<-get.hist.quote("0753.HK")
Y<-get.hist.quote("601111.SS")
plot(Y[,4],col="blue",ylim=c(0,30))
lines(X[,4],col="red")

But as @alea_ pointed out, one asset is expressed here in Yuans renminbi, and the other one in HK dollars. So I downloaded the exchange rate fromhttp://www.oanda.com/

Z=read.table("http://freakonometrics.blog.free.fr/public/
data/change-cny-hkd.csv",header=TRUE,sep=";",dec=",")
D=as.Date(as.character(Z$date),"%d/%m/%y")
z=as.numeric(Z$CNY.HKD)
plot(D,z,type="l")
X2=X[,4]
for(t in 1:length(X2)){ X2[t]=X2[t]*z[D==time(X2[t])]} 
X2=X[,4]
plot(Y[,4],col="blue",ylim=c(0,30))
lines(X2,col="red")

Now both stocks are expressed in the same currency. To compare returns volatility, a first idea can be to use GARCH models,

RX=diff(log(X2))
RY=diff(log(Y[,4]))
Xgarch = garch(as.numeric(RX))
SIGMAX=predict(Xgarch)
Ygarch = garch(as.numeric(RY))
SIGMAY=predict(Ygarch)
plot(time(Y)[-1],SIGMAY[,1],col="blue",type="l")
lines(time(X2)[-1],SIGMAX[,1],col="red")

But volatility is here too eratic. So an alternative can be to use exponentially-weighted moving averages, where simple recursive relationships are considered

$https://perso.univ-rennes1.fr/arthur.charpentier/latex/vol-04.png$

or equivalently

$https://perso.univ-rennes1.fr/arthur.charpentier/latex/vol-05.png$

The code is not great, but it is easy to understand,

moy.ew=function(x,r){ 
m=rep(NA,length(x)) 
for(i in 1:length(x)){ 
 m[i]=weighted.mean(x[1:i], 
         rev(r^(0:(i-1))))} 
    return(m)} 
 sd.ew=function(x,r,m){ 
sd=rep(NA,length(x)) 
for(i in 1:length(x)){
     sd[i]=weighted.mean((x[1:i]-m[i])^2,
          rev(r^(0:(i-1))))} 
    return(sd)} 
q=.97
MX=moy.ew(RX,q)
SX=sd.ew(RX,q,MX)
MY=moy.ew(RY,q)
SY=sd.ew(RY,q,MY)
plot(time(Y)[-1],SY,col="blue",type="l")
lines(time(X2)[-1],SX,col="red")

And now we have something less erratic, so we can focus now on the interpretation.
It is also possible to look on the difference between those two series of volatility, areas in blue means that in Shanghai (again, where short-selling is forbidden) returns are more volatile than in Hong Kong, and areas in red are periods where returns are more volatile in Hong Kong,

a=time(X2)[which(time(X2)%in%time(Y))]
b=SY[which(time(Y)%in%time(X2))]-
  SX[which(time(X2)%in%time(Y))]
n=length(a)
a=a[-n];b=b[-n]
plot(a,b,col="black",type="l")
polygon(c(a,rev(a)),c(pmax(b,0),rep(0,length(a))),
        col="blue",border=NA)
polygon(c(a,rev(a)),c(pmin(b,0),rep(0,length(a))),
        col="red",border=NA)

So clearly, there is nothing clear that can be said… Sometimes, volatility is higher in Hong Kong, and sometimes, it is higher in Shanghai. But if we look at the price, instead of looking at volatility,

a=time(X2)[which(time(X2)%in%time(Y))]
b=as.numeric(Y[which(time(Y)%in%time(X2)),4])- 
  as.numeric(X2[which(time(X2)%in%time(Y))])
n=length(a)
a=a[-n];b=b[-n]
plot(a,b,col="black",type="l")
polygon(c(a,rev(a)),c(pmax(b,0),rep(0,length(a))),
        col="blue",border=NA)
polygon(c(a,rev(a)),c(pmin(b,0),rep(0,length(a))),
        col="red",border=NA)

Here, it looks like bans on short-selling creates bubbles. Might not not be a goodthing.

Actuarial science, Catastrophes, Stochastic Processes

Encore une année record…

03/01/2011 Arthur Charpentier 4 Comments

Comme l’a noté la blogosphère ces dernières heures, il semble que des records aient (encore) été battus en terme de catastrophes naturelles: “catastrophes naturelles : une année 2010 exceptionnelle” (ici) ou “2010, année record des catastrophes naturelles” (là). Maintenant on peut remonter un peu dans le temps aussi: “catastrophes naturelles: 2008 bat des records” (ici) ou “2008 a battu des records de catastrophes naturelles” (là), “en 2007, les catastrophes naturelles ont atteint un nombre record” (ici), “catastrophes naturelles : 2005 bat des records en matière d’intensité et de coûts” (ici) ou “les catastrophes ont entraîné une facture record en 2005” (là), “déjà record, le bilan 2004 des catastrophes naturelles s’alourdit” (ici), “année 2000 : record de catastrophes naturelles” (ici) et “catastrophes naturelles : encore une année record” (en 2000, là) etc, etc.

Bon, en tant que statisticien, les rares résultats que je connaisse sur les records sont des théorèmes en log (i.e. en variation lente). Si est une suite de variables i.i.d. et que l’on définie les durées entre records,

http://freakonometrics.hypotheses.org/files/2015/12/records02.png

où , avec . Alfred Rényi a montré que

http://freakonometrics.hypotheses.org/files/2015/12/record08.png

alors que Marcel Neuts a montré que

http://freakonometrics.hypotheses.org/files/2015/12/record09.png

En particulier, on note que

http://freakonometrics.hypotheses.org/files/2015/12/record11.png

Autrement dit, plus le temps avance, plus les records doivent devenir rares.
Par exemple, regardons la simulation suivante. Considérons un processus Poissonnien homogène, , avec les dates des catastrophes, et leur coût.

On note

http://freakonometrics.hypotheses.org/files/2015/12/catnat04.png

le nombre annuel de catastrophes (éventuellement, on ne considère que les catastrophes dont le cout dépasse un seuil prédéfini, comme cela semble généralement être le cas).

On peut définir le processus de records,

http://freakonometrics.hypotheses.org/files/2015/12/catnat07.png

qui ressemble à ça

Bon, maintenant, si on a des records tous les ans (ou presque) c’est probablement que l’hypothèse i.i.d. n’était pas valide.
Supposons par exemple qu’il y ait de l’inflation, i.e. les coût sont .

Dans ce cas, le processus de nombre d’événements annuels est

et celui des records

Si on répète l’expérience un grand nombre de fois, le nombre moyen d’événements par année me cesse de croître (en rouge ci-dessous)

et le processus de records moyen (avec le cas i.i.d. en bleu),

Autrement dit, si l’inflation est trop importante, il est possible d’avoir régulièrement de nouveaux records.
Une autre possibilité est de supposer qu’il n’y a pas d’inflation, mais que le nombre de sinistres ne cesse de croître (ici un processus de Poisson à intensité linéaire), c’est à dire une fréquence plus importante des événements climatiques extrêmes

Le nombre annuel de catastrophes est alors

soit, si l’on considère le processus de records

Là encore, si l’on répète l’expérience un grand nombre de fois, le nombre moyen de catastrophes ne cesse de croître

alors que le processus de records a la moyenne suivante

Bref, il est possible d’avoir effectivement des records presque tous les ans. Cela signifie probablement que les sinistres coûtent de plus en plus cher (hausse de la valeur à risque), mais aussi probablement que les catastrophes sont de plus en plus fréquentes. On retrouve finalement ce que je disais il y a quelques mois maintenant (ici).

Actuarial science, Copulas, Premium principle, Stochastic Processes

Hypothèse d’indépendance en assurance

05/06/2009 Arthur Charpentier Leave a comment

Il y a deux semaines, j’ai reçu un mail dans ma boite à l’ensae (que je consulte rarement) qui posait une vraie question. “Pour le modèle de risque collectif : S=X1+X2+…+XN. On suppose que les Xi et N sont indépendants (montant de sinistres et nombre de sinistres). Question : Dans la pratique (par exemple : assurance automobile), comment peut-on expliquer cette indépendance.“

Sur la forme de la question, on mélange un peu théorie et pratique: c’est la théorie qui impose cette hypothèse, et effectivement, il convient de la confronter à la pratique afin d’utiliser les résultats qui découlent du modèle collectif (en particulier en terme de solvabilité, j’en parlerai à la fin). Mais cela pose toutefois une question très intéressante.

Pour rappels, cette hypothèse a été faite par Filip Lundberg quand il a proposé les premiers résultats en 1903 (voire plus tôt), à l’époque où l’étude des processus était assez peu développée… Charles Spearman n’a introduit sa mesure de corrélation qu’en 1904, par exemple (même si on peut trouver des choses chez Francis Galton en 1888, puis chez Karl Pearson en 1892¹). Autrement dit, le premier modèle reposait sur les hypothèses les plus simples possibles (pour l’époque). Depuis, l’étude des processus ponctuels s’est beaucoup développée, et énormément de résultats ont été obtenus. Autrement dit, il existe des résultats théoriques permettant de s’affranchir de cette indépendance.

Petite remarque en passant, dans les livres avec Michel Denuit, on avait insisté longuement sur cette hypothèse d’indépendance… et c’est précisément sur ce point que Claude Bébéar avait ouvert la préface (ici) et qu’Hans Bühlmann avait clôturé la postface (là). C’est d’ailleurs Hans Bühlmann qui notait en 1963 que “the independence hypothesis is so common to be made that many authors forget to mention it“.
Pour être un peu complet, il y a trois indépendances distinctes dans les hypothèses du modèle collectif:

d’indépendance entre les arrivées des sinistres, on parle plus proprement d’hypothèse d’un processus de Poisson homogène (les durées entre survenances suivent des lois exponentielles indépendantes),
d’indépendance entre les coûts (individuels) des sinistres,
d’indépendance entre les coûts de sinistres, et les arrivées.

C’est surtout la première hypothèse qui a été relâchée. On retrouvera des exemples dans les papiers suivants

Malinovskii, V.K. (1998). Non-Poissonian claims’ arrivals and calculation of the probability of ruin. Insurance: Mathematics and Economics, 22, 2, 123-138.
Gyllenberg, M. & Silvestrov, D.S. (2000). Cramer-Lundberg approximation for nonlinearly perturbed risk processes. Insurance: Mathematics and Economics, 26, 1, 75-90.

Sur les aspects pratiques, on peut retrouver ce phénomène en particulier sur les catastrophes naturelles qui sont très cycliques. L’exemple le plus connu et le plus étudié est les ouragans,

Parisi, F. & Lund, R. (2000). Seasonality and return periods of landfalling Atlantic basin hurricanes. Australian and New Zealand Journal of Statistics, 42, 3, 271-282.

Mais on a la même chose en assurance auto, à cause de la pluie et du brouillard (en France en tous cas²).
Pour la seconde, on peut trouver des choses dans les derniers papiers de Stéphane Loisel (ici).
Mais c’est le dernier point qui était évoqué, et seulement celui là… Avec la même dichotomie que tout à l’heure, on trouve des résultats théoriques, en particulier dans les papiers d’Hansjorg Albrecher

Albrecher, H. & Boxma, O.J. (2004). A ruin model with dependence between claim sizes and claim intervals. Insurance: Mathematics and Economics, 35, 2, 245-254.

Sur les aspects pratiques, l’exemple le plus classique et le plus étudié est celui des tremblements de terre. Pour faire très simple, un tremblement de terre est causé par une accumulation d’énergie: plus on attend, plus le tremblement de terre risque d’être important. Bref, d’un point de vue pratique, cette hypothèse peut être délicate à supposer. On avait utilisé un modèle ACD avec un processus marqué dans le cas des crues de rivières par exemple, dans un papier avec David Sibaï (ici). On modélisait un processus joint prenant en compte les durées des crues, les durées entre crue, et les importances des crues. Là aussi, intensités et durées ne sont pas indépendant.

Mais au delà de l’explication, il faut aussi – peut être – essayer de tester cette indépendance. Si quelqu’un a des données ou des résultats sur ce sujet, je suis preneur.

Pour conclure, je dirais que cette hypothèse d’indépendance est fondamentale. Si on la supprime, on peut perdre beaucoup de résultats classiques, sur la solvabilité par exemple. Pour reprendre une idée commune partagée par beaucoup de monde, dans l’Encyclopaedia of Financial Engineering and Risk Management, (ici) on apprend que “reinsurance is able to offer additional underwriting capacity for cedants, but also to reduce the probability of a direct insurer’s ruin“. En fait, ce résultat devient faux si l’on supprime cette hypothèse d’indépendance: on peut augmenter la probabilité de ruine en se réassurance ! La réassurance diminue alors la solvabilité de la compagnie d’assurance (ou tout du moins peut le faire). C’est dans un papier que j’ai soumis récemment, je garde donc tout ça pour un billet dans les mois à venir… à suivre donc.

¹ Sur la corrélation de Pearson – que j’ai beaucoup critiqué sur ce blog – je renvoie à un très beau papier que je viens (seulement) de découvrir, de Joseph Rodgers et Alan Nicewander, intitulé Thirteen Ways to Look at the Correlation Coefficient (ici)
² Si quelqu’un a des données pour illustrer ce point, je suis preneur !

Actuarial science, M1-actuariat, Probability, Ruin theory, Stochastic Processes

Simulation d’un processus de Poisson

28/02/2009 Arthur Charpentier 1 Comment

Le prochain cours reviendra sur la solvabilité des compagnies d’assurance, et en particulier sur la modélisation et le calcul de la probabilité de ruine. En particulier, nous passerons pas mal de temps sur le “processus de Poisson“.

Nous verrons en cours les notions de base sur les processus de Poisson $\{N_t\}$ . En particulier, nous verrons qu’ils se caractérisent soit par le processus d’arrivées $\{T_i\}$ , correspondant aux dates d’arrivée des sinistres, ou bien par, correspondants aux durées intersinistres. En effet, on peut obtenir des expressions de la forme $ N_t= .

Dans sa forme la plus simple, on s’intéresse aux processus homogènes. $\{N_t: t \ge 0 \}$ sera un processus de Poisson homogène d’intensité $\lambda > 0$ si les durées entre arrivées, $ W_i$ i.i.d. de loi exponentielle de paramètre $\lambda$ . L’algorithme naturel pour simuler les dates d’arrivées de sinistre $T_1,T_2,\ldots,T_n$ est alors

poser
pour on génère suivant une loi exponentielle de paramètre $\lambda$ , puis on pose

Les choses vont se compliquer si on suppose que le processus de Poisson n’est plus homogène. Cette hypothèse est peut être davantage réaliste pour l’assurance. Par exemple, les assureurs savent qu’il y a plus d’accidents automobiles les jours de brouillard, ou de pluie, ou de verglas. On peut donc supposer qu’il existe un cycle lié au climat.

On suppose ici que le processus de Poisson est d’intensité $\lambda(t)$ . La première idée pour simuler un tel processus est de supposer qu’il existe $\overline{\lambda}$ tel que $\lambda(t)\leq\overline{\lambda}$ pour tout . On note $T_1^* ,T_2^* , T_3^* ,\ldots$ des arrivées successives d’un processus de Poisson de paramètre $\overline{\lambda}$ . On met alors en place une stratégie acceptation/rejet, telle que l’on garde le ème sinistre avec probabilité $\lambda(T_i^* )/\overline{\lambda}$ . La suite $T_1, T_2, \ldots$ ainsi construite suit un processus de Poisson nonhomogène d’intensité $\lambda(t)$ . D’où l’algorithme

On pose et
on génère une variable exponentielle d’intensité $\overline{\lambda}$ .
On pose alors.
On génère une variable uniforme sur : si $U>\lambda(T^*)/\overline{\lambda}$ on rejette (et on retourne en 2.), et sinon on pose .

Une autre méthode consiste à noter que l’incrément

, , suit une loi de Poisson d’intensité $\widetilde{\lambda} = \int_s^t \lambda(u)du$ . Aussi, la fonction de répartition du temps d’attente est qui vaut

On peut utiliser la méthode suivante pour simuler le processus de Poisson

Poser
Générer suivant une loi uniforme sur
Poser

Pour aller plus loin, je renvoie à des bouquins sur la simulation de processus, ou pour les applications assurantielles au Statistical Tools for Finance and Insurance, chez Springer.

Freakonometrics