IFT 6561 Simulation et mod`eles

(1)

IFT 6561

Simulation et mod `eles

Fabian Bastin DIRO

Universit ´e de Montr ´eal

Automne 2013

(2)

G én érateur r écursif multiple (MRG)

Nous pouvons g én éraliser la r écurrence du GCL par x_n= (a₁xn−1+· · ·+a_kx_n−k) mod m, u_n =x_n/m.

En pratique, on prendra plut ˆotu_n= (x_n+1)/(m+1), ou encore u_n=x_n/(m+1)six_n>0 etu_n=m/(m+1)sinon, mais la structure demeure essentiellement la m ˆeme.

Sik =1, nous retrouvons le g én érateur à congruence lin éaire classique, avecc =0.

L’ état à l’ étapenests_n=x_n = (x_n−k+1, . . . ,x_n)^T. Espace d’ états:Z_m^k, de cardinalit ém^k.

La p ´eriode maximale estρ=m^k−1, pourmpremier.

Fabian Bastin IFT3245

(3)

Polyn ˆome caract ´eristique

On associe au MRG le polyn ˆome caract ´eristique:

P(z) =z^k −a₁z^k−1− · · · −a_k =−

k

X

j=0

a_jz^k−j,

o `ua₀=−1.

Pourk >1, pour avoir une p ériode maximale, il est possible de montrer qu’il suffit d’avoir au moins deux coefficients non nuls, donta_k. Ainsi, la r écurrence la plus économique a la forme:

xn= (arxn−r +a_kxn−k) modm, avec 0<r <k.

(4)

m = 2

^e

Une erreur fr ´equente, commise en particulier par les

informaticiens peu au fait des statistiques, est de consid ´erer m=2^e.

Utiliser une puissance de 2 pourmpermet en effet de facilement calculer le produitax modm, et est parfois d ´ecrit comme efficace, ce qui est vrai du point de la rapidit ´e

d’ex ´ecution.

Les effets sur la p ´eriode sont pourtant dommageables, vu que pourk =1 ete≥4, on aρ≤2^e−2;

pourk >1, on aρ≤(2^k−1)2^e−1.

(5)

m = 2

^e

: exemple

Sik =7 etm=2³¹−1, la p ´eriode maximale est (2³¹−1)⁷−1≈2²¹⁷. Mais pourm=2³¹ on a ρ≤(2⁷−1)2³¹⁻¹<2³⁷, i.e. 2¹⁸⁰fois plus petit!

Pire, si nous nous int éressons auith bit le moins significatif, pourk =1, la p ériode dexn mod 2ⁱ ne peut pas d épasser max(1,2ⁱ⁻²). Pourk >1, la p ériode dex_n mod 2ⁱ ne peut pas d épasser(2^k−1)2ⁱ⁻¹.

(6)

m = 2

^e

: exemple

R ´ecurrencex_n=10205x_n−1 mod 2¹⁵:

x₀ = 12345 = 011000000111001₂ x₁ = 20533 = 101000000110101₂ x2 = 20673 = 1010000110000012

x₃ = 7581 = 001110110011101₂ x₄ = 31625 = 111101110001001₂ x₅ = 1093 = 000010001000101₂ x₆ = 12945 = 011001010010001₂ x7 = 15917 = 011111000101101₂.

(7)

m = 2

^e

De tels g én érateurs restent populaires, mais sont à proscrire dans des simulations dignes de ce nom. Ainsi, la fonction ran48reste pr ésente dans les librairies C standards BSD.

m a c Source

2²⁴ 1140671485 12820163 early MS VisualBasic

2³¹ 65539 0 RANDU (IBM)

2³¹ 134775813 1 early Turbo Pascal

2³¹ 1103515245 12345 rand()in BSD ANSI C

2³² 69069 1 VAX/VMS systems

2³² 2147001325 715136305 BCLP language

2³⁵ 5¹⁵ 7261067085 Knuth (1998)

2⁴⁸ 68909602460261 0 Fishman (1990)

2⁴⁸ 25214903917 11 Unix’srand48()

2⁴⁸ 44485709377909 0 CRAY system

2⁵⁹ 13¹³ 0 NAG Fortran/C library

(8)

Variables al ´eatoires communes (VAC)

Comparaisonde syst `emes semblables avec valeurs al ´eatoires communes.

On simule un r éseau de communication, ou un centre d’appels t él éphoniques, ou un r éseau de distribution de biens, ou une usine, ou le trafic automobile dans une ville, ou la gestion dynamique d’un portefeuille d’investissements (finance), etc.

On veut comparer deux configurations (ou politiques de

gestion) semblables du syst ème. Une partie de la diff érence de performance sera due à la diff érence de configuration, et une autre partie sera due au bruit stochastique. On veut minimiser cette seconde partie.

(9)

Variables al ´eatoires communes

Id ée de base: simuler les deux configurations avec les m êmes valeurs uniformesU_j, utilisees exactement aux m êmes

endroits. On verra plus tard des r ésultats th éoriques sur l’am élioration d’efficacit é (r éduction de variance) que cela apporte.

Mais l’implantation, avec synchronisation des v.a., peut être compliqu ée lorsque les deux configurations n’utilisent pas le m ême nombre deU_j(e.g., parfois on doit g én ërer une v.a. dans un cas et pas dans l’autre).

(10)

G én érateurs à sous-suites multiples

Afin de pouvoir ad équatement repr ésenter les diff érentes variables al éatoires, il peut être int éressants de pouvoir

instancier des g én érateurs de variables al éatoires à volont é, et faire évoluer ceux-ci en parall èle, plut ôt que d’utiliser un seul g én érateur et transformer les tirs dans les distributions voulues

`a la vol ´ee.

Nous voudrions pouvoir utiliser plusieurs fois un m ême g én érateur au sein d’un programme, mais en d ébutant avec des semences diff érentes afin de produire des suites al éatoires diff érentes.

(11)

G én érateurs à sous-suites multiples

Une premi ère approche consiste à cr éer plusieurs g én érateurs, en sp écifiant manuellement ces semences. Le danger majeur de cette approche est qu’il est difficile de pr évoir la position des ces semences dans la s équence al éatoire, ce qui peut conduire

à produire des s équences fortement corr él ées. Le risque est d’autant plus élev é que la p ériode du g én érateur est faible.

(12)

Exemple

SoitX,Y, deux variables al ´eatoires normalesN(0,1)

ind ´ependantes. Il est possible de montrer que le rapportX/Y suit une distribution de Cauchy.

G én érons ce rapport à l’aide du GCL Standard Minimal, avec 1 comme semence au num érateur, et 2 au d énominateur.

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

-4 -2 0 2 4

Cauchy distribution

(13)

G én érateurs à sous-suites multiples

Il est ainsi utile de pouvoir partitionner ces suites (ou “streams”) en sous-suites.

´etat

. . ⇓ . . . .

d ´ebut suite prochaine sous-suite prochaine suite

(14)

Sauts entre suites

Pour passer d’une suite à une autre, il est n écessaire de pouvoir calculer un point de la r écurrence sans devoir g én érer tous les points interm édiaires. Or, nous pouvons écrire

x_n=Ax_n−1 modm=







0 1 · · · 0 ... . .. ...

0 0 · · · 1 a_k ak−1 · · · a₁







x_n−1 mod m.

Ainsi

x_n+ν =A^νx_n modm= (A^ν mod m)x_n modm.

(15)

Sauts entre suites

Nous pouvons pr ´ecalculerA^ν mod mau moyen de la proc ´edure suivante:

A^ν modm=

((A^ν/2 modm)(A^ν/2 modm) modm siνest pair;

A(A^ν−1 modm) modm siνest impair.

(16)

Interface Java

p u b l i c i n t e r f a c e RandomStream { p u b l i c v o i d r e s e t S t a r t S t r e a m ( ) ; R éinitialise la suite à son état initial.

p u b l i c v o i d r e s e t S t a r t S u b s t r e a m ( ) ; R ´einitialise la suite au d ´ebut de sa sous-suite courante.

p u b l i c v o i d resetNextSubstream ( ) ; R ´einitialise la suite au d ´ebut de sa prochaine sous-suite.

p u b l i c double nextDouble ( ) ;

Retourne une v.a.U(0,1)de cette suite et avance d’un pas.

p u b l i c i n t n e x t I n t ( i n t i , i n t j ) ; Retourne une v.a. uniforme sur{i,i+1, . . . ,j−1}.

}

(17)

Interface Java

p u b l i c c l a s s RandMrg implements RandomStream { Une implantation particuli `ere:MRG32k3a.

p u b l i c RandMrg ( ) ;

Construit une nouvelle suite de cette classe.

p u b l i c s t a t i c v o i d setPackageSeed ( l o n g seed [ ] ) ; Fixe l’ état initial de la premi ère suite. Les autres sont calcul és

selon un espacement pr éd étermin é.

}

(18)

MRGs combin ´es

Consid érons deux [ou plusieurs...] MRGs évoluant en parall èle:

x_1,n = (a_1,1x_1,n−1+· · ·+a_1,kx_1,n−k) modm₁, x_2,n = (a_2,1x2,n−1+· · ·+a_2,kx_2,n−k) modm₂.

On d ´efinit les deux combinaisons:

zn := (x_1,n−x_2,n) modm₁; un := zn/m₁; w_n := (x_1,n/m₁−x_2,n/m₂) mod 1.

La suite{w_n,n≥0}est la sortie d’un autre MRG, de module m=m₁m₂, et{u_n,n≥0}est presque la m ˆeme suite sim₁et m₂sont proches. Peut atteindre la p ´eriode(m₁^k−1)(m^k₂−1)/2.

Permet d’implanter efficacement un MRG ayant un grandmet plusieurs grands coefficients non nuls.

(19)

MRGs combin ´es

Pour acc él érer la g én ération de point, il est possible de prendre tous lesa_j non nuls égaux àa(Deng et Xu 2002). Alors,

xn=a(x_n−i₁+· · ·+x_n−k) modm. Une seule multiplication.

Les meilleurs g én érateurs ne jouissent cependant pas de cette propri ét é.

Tableaux de param ´etres: L’Ecuyer (1999); L’Ecuyer et Touzin (2000).

(20)

MRG32K3a

J =2,k =3,

m₁=2³²−209,a₁₁ =0,a₁₂ =1403580,a₁₃=−810728, m₂=2³²−22853,a₂₁ =527612,a₂₂=0,a₂₃ =−1370589.

Combination: z_n= (x_1,n−x_2,n)modm₁.

Le g én érateur correspond à un MRG caract éris é park =3, m=m₁m₂=18446645023178547541, et les param étres a₁=18169668471252892557,a₂=3186860506199273833, a₃=8738613264398222622. Sa p ériodeρvaut

(m³₁−1)(m³₂−1)/2≈2¹⁹¹.

(21)

MRG32K3a

#define norm 2.328306549295728e-10 /* 1/(m1+1) */

#define m1 4294967087.0

#define m2 4294944443.0

#define a12 1403580.0

#define a13n 810728.0

#define a21 527612.0

#define a23n 1370589.0

double s10, s11, s12, s20, s21, s22;

double MRG32k3a () {

long k;

double p1, p2;

(22)

MRG32K3a

/* Component 1 */

p1 = a12 * s11 - a13n * s10;

k = p1 / m1; p1 -= k * m1; if (p1 < 0.0) p1 += m1;

s10 = s11; s11 = s12; s12 = p1;

/* Component 2 */

p2 = a21 * s22 - a23n * s20;

k = p2 / m2; p2 -= k * m2; if (p2 < 0.0) p2 += m2;

s20 = s21; s21 = s22; s22 = p2;

/* Combination */

if (p1 <= p2) return ((p1 - p2 + m1) * norm);

else return ((p1 - p2) * norm);

}

(23)

Illustration avec SSJ

i m p o r t u m o n t r e a l . i r o . l e c u y e r . rng .∗; i m p o r t u m o n t r e a l . i r o . l e c u y e r . s t a t .∗; p u b l i c c l a s s C o l l i s i o n {

i n t k ; / / Number o f l o c a t i o n s . i n t m; / / Number o f i t e m s .

double lambda ; / / T h e o r e t i c a l e x p e c t a t i o n o f C ( a s y m p t o t i c ) . boolean [ ] used ; / / L o c a t i o n s a l r e a d y used .

p u b l i c C o l l i s i o n ( i n t k , i n t m) { t h i s . k = k ;

t h i s .m = m;

lambda = ( double ) m ∗ m / ( 2 . 0 ∗ k ) ; used = new boolean [ k ] ;

}

(24)

Illustration avec SSJ

/ / Generates and r e t u r n s t h e number o f c o l l i s i o n s . p u b l i c i n t generateC ( RandomStream stream ) {

i n t C = 0 ;

f o r ( i n t i = 0 ; i < k ; i ++) used [ i ] = f a l s e ; f o r ( i n t j = 0 ; j < m; j ++) {

i n t l o c = stream . n e x t I n t ( 0 , k−1);

i f ( used [ l o c ] ) C++;

e l s e used [ l o c ] = t r u e ; }

r e t u r n C ; }

(25)

Illustration avec SSJ

/ / Performs n ind ep .

p u b l i c v o i d simulateRuns ( i n t n , RandomStream stream , T a l l y s t a t C ) {

s t a t C . i n i t ( ) ;

f o r ( i n t i = 0 ; i<n ; i ++)

s t a t C . add ( generateC ( stream ) ) ; s t a t C . s e t C o n f i d e n c e I n t e r v a l S t u d e n t ( ) ;

System . o u t . p r i n t l n ( s t a t C . r e p o r t ( 0 . 9 5 , 3 ) ) ; System . o u t . p r i n t l n ( ” T h e o r e t i c a l mean : ”

+ lambda ) ; }

p u b l i c s t a t i c v o i d main ( S t r i n g [ ] args ) { T a l l y s t a t C = new T a l l y

( ” S t a t i s t i c s on c o l l i s i o n s ” ) ;

C o l l i s i o n c o l = new C o l l i s i o n (10000 , 5 0 0 ) ;

c o l . simulateRuns (100000 , new MRG32k3a ( ) , s t a t C ) ; }