IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Cours complet pour débutants pour apprendre la programmation en R


précédentsommairesuivant

8. Générateurs de nombres aléatoires

Objectifs du chapitre

  • Générer des nombres aléatoires uniformes avec la fonction runif.
  • Générer des nombres aléatoires non uniformes provenant de lois de probabilité discrètes et continues.
  • Générer des nombres aléatoires provenant d'une distribution discrète quelconque.
  • Tirer profit de la nature vectorielle des fonctions de simulation de R.

Avant d'utiliser pour quelque tâche de simulation moindrement importante un générateur de nombres aléatoires inclus dans un logiciel, il importe de s'assurer de la qualité de cet outil. On trouvera en général relativement facilement de l'information dans Internet.

On présente ici, sans entrer dans les détails, les générateurs de nombres uniformes utilisés dans R ainsi que la liste des différentes fonctions de simulation de variables aléatoires.

8-1. Générateurs de nombres aléatoires

On obtient des nombres uniformes sur un intervalle quelconque avec la fonction runif dans R. La fonction set.seed permet de spécifier la valeur de l'amorce du générateur aléatoire, ce qui est utile si on veut répéter une simulation absolument à l'identique.

R offre la possibilité de choisir entre plusieurs générateurs de nombres aléatoires différents, ou encore de spécifier son propre générateur. Par défaut, R utilise le générateur Marsenne-Twister, considéré comme le plus avancé en ce moment. La période de ce générateur est 219 937 − 1 (rien de moins !) et la distribution des nombres est uniforme dans 623 dimensions consécutives sur toute la période.

Pour de plus amples détails et les dernières informations sur les générateurs disponibles et la procédure de réglage de l'amorce, consulter les rubriques d'aide des fonctions .Random.seed et set.seed.

8-2. Fonctions de simulation de variables aléatoires non uniformes

Un large éventail de fonctions donnent directement accès aux caractéristiques de plusieurs lois de probabilité dans R. Pour chaque racine loi, il existe quatre fonctions différentes :

  1. dloi calcule la fonction de densité de probabilité (loi continue) ou la fonction de masse de probabilité (loi discrète) ;
  2. ploi calcule la fonction de répartition ;
  3. qloi calcule la fonction de quantile ;
  4. rloi simule des observations de cette loi.

Les différentes lois de probabilité disponibles dans le système R de base, leur racine et le nom de leurs paramètres sont rassemblés au tableau 8.1. Des packages fournissent des fonctions pour d'autres lois dont, entre autres, actuar (Dutang et collab., 2008) et SuppDists (Wheeler, 2013).

Tab. 8.1 - Lois de probabilité pour lesquelles il existe des fonctions dans le système R de base

Loi de probabilité

Racine dans R

Noms des paramètres

Bêta

beta

shape1, shape2

Binomiale

binom

size, prob

Binomiale négative

nbinom

size, prob ou mu

Cauchy

cauchy

location, scale

Exponentielle

exp

rate

F (Fisher)

f

df1, df2

Gamma

gamma

shape, rate ou scale

Géométrique

geom

prob

Hypergéométrique

hyper

m, n, k

Khi carré

chisq

df

Logistique

logis

location, scale

Log-normale

lnorm

meanlog, sdlog

Normale

norm

mean, sd

Poisson

pois

lambda

t (Student)

t

df

Uniforme

unif

min, max

Weibull

weibull

shape, scale

Wilcoxon

wilcox

m, n

Toutes les fonctions du tableau 8.1 sont vectorielles, c'est-à-dire qu'elles acceptent en argument un vecteur de points où la fonction (de densité, de répartition ou de quantile) doit être évaluée et même un vecteur de paramètres. Par exemple,

 
Sélectionnez
> dpois(c(3, 0, 8), lambda = c(1, 4, 10))
[1] 0.06131324 0.01831564 0.11259903

retourne la probabilité que des lois de Poisson de paramètre 1, 4 et 10 prennent les valeurs 3, 0 et 8, dans l'ordre.

Le premier argument de toutes les fonctions de simulation est la quantité de nombres aléatoires désirée. Ainsi,

 
Sélectionnez
> rpois(3, lambda = c(1, 4, 10))
[1] 2 6 10

retourne trois nombres aléatoires issus de distributions de Poisson de paramètre 1, 4 et 10, respectivement. Évidemment, passer un vecteur comme premier argument n'a pas tellement de sens, mais, si c'est fait, R retournera une quantité de nombres aléatoires égale à la longueur du vecteur (sans égard aux valeurs contenues dans le vecteur).

La fonction sample permet de simuler des nombres d'une distribution discrète quelconque. Sa syntaxe est

 
Sélectionnez
sample(x, size, replace = FALSE, prob = NULL)

x est un vecteur des valeurs possibles de l'échantillon à simuler (le support de la distribution), size est la quantité de nombres à simuler et prob est un vecteur de probabilités associées à chaque valeur de x (1/length(x) par défaut). Enfin, si replace est TRUE, l'échantillonnage se fait avec remise.

8-3. Exemples

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
###
### GÉNÉRATEURS DE NOMBRES ALÉATOIRES
###

## La fonction de base pour simuler des nombres uniformes est
## 'runif'.
runif(10) # sur (0, 1) par défaut
runif(10, 2, 5) # sur un autre intervalle
2 + 3 * runif(10) # équivalent, moins lisible

## R est livré avec plusieurs générateurs de nombres
## aléatoires. On peut en changer avec la fonction 'RNGkind'.
RNGkind("Wichmann-Hill")    # générateur de Excel
runif(10)                   # rien de particulier à voir
RNGkind("default")          # retour au générateur par défaut

## La fonction 'set.seed' est très utile pour spécifier
## l'amorce d'un générateur. Si deux simulations sont
## effectuées avec la même amorce, on obtiendra exactement les
## mêmes nombres aléatoires et, donc, les mêmes résultats.
## Très utile pour répéter une simulation à l'identique.
set.seed(1)                 # valeur sans importance
runif(5)                    # 5 nombres aléatoires
runif(5)                    # 5 autres nombres
set.seed(1)                 # réinitialisation de l'amorce
runif(5)                    # les mêmes 5 nombres que ci-dessus

###
### FONCTIONS POUR LA SIMULATION DE VARIABLES ALÉATOIRES NON
### UNIFORMES
###

## Plutôt que de devoir utiliser la méthode de l'inverse ou un
## autre algorithme de simulation pour obtenir des nombres
## aléatoires d'une loi de probabilité non uniforme, R fournit
## des fonctions de simulation pour bon nombre de lois. Toutes
## ces fonctions sont vectorielles. Ci-dessous, P == Poisson
## et G == Gamma pour économiser sur la notation.
n <- 10 # taille des échantillons
rbinom(n, 5, 0.3)           # Binomiale(5, 0,3)
rbinom(n, 1, 0.3)           # Bernoulli(0,3)
rnorm(n)                    # Normale(0, 1)
rnorm(n, 2, 5)              # Normale(2, 25)
rpois(n, c(2, 5))           # P(2), P(5), P(2), ... , P(5)
rgamma(n, 3, 2:11)          # G(3, 2), G(3, 3), ... , G(3, 11)
rgamma(n, 11:2, 2:11)       # G(11, 2), G(10, 3), ... , G(2, 11)

## La fonction 'sample' sert pour simuler d'une distribution
## discrète quelconque. Le premier argument est le support de
## la distribution et le second, la taille de l'échantillon
## désirée. Par défaut, l'échantillonnage se fait avec remise
## et avec des probabilités égales sur tout le support.
sample(1:49, 7)             # numéros pour le 7/49
sample(1:10, 10)            # mélange des nombres de 1 à 10

## On peut échantillonner avec remise.
sample(1:10, 10, replace = TRUE)

## On peut aussi spécifier une distribution de probabilités
## non uniforme.
x <- sample(c(0, 2, 5), 1000, replace = TRUE,
            prob = c(0.2, 0.5, 0.3))
table(x)                    # tableau de fréquences

8-4. Exercices

8.1 (solution) La loi log-normale est obtenue par transformation de la loi normale : si la distribution de la variable aléatoire kitxmlcodeinlinelatexdvpXfinkitxmlcodeinlinelatexdvp est une normale de paramètres kitxmlcodeinlinelatexdvp\mufinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp\sigma^2finkitxmlcodeinlinelatexdvp, alors la distribution de kitxmlcodeinlinelatexdvpe^Xfinkitxmlcodeinlinelatexdvp est une log-normale. Simuler 1000 observations d'une loi log-normale de paramètres kitxmlcodeinlinelatexdvp\mu=\ln 5000-\frac{1}{2}finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp\sigma^2=1finkitxmlcodeinlinelatexdvp, puis tracer l'histogramme de l'échantillon aléatoire obtenu.

8.2 (solution) Simuler 10 000 observations d'un mélange continu Poisson/gamma où les paramètres de la loi gamma sont kitxmlcodeinlinelatexdvp\alpha=5finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp\lambda=4finkitxmlcodeinlinelatexdvp, puis tracer la distribution de fréquence de l'échantillon aléatoire obtenu à l'aide des fonctions plot et table. Superposer à ce graphique la fonction de probabilité d'une binomiale négative de paramètres kitxmlcodeinlinelatexdvpr=5finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp\theta=0.8finkitxmlcodeinlinelatexdvp.

8.3 (solution) Simuler 10 000 observations d'un mélange discret de deux distributions log-normales, l'une de paramètres (kitxmlcodeinlinelatexdvp\mufinkitxmlcodeinlinelatexdvp = 3 ,5 , kitxmlcodeinlinelatexdvp\sigma^2finkitxmlcodeinlinelatexdvp = 0 ,6) et l'autre de paramètres (kitxmlcodeinlinelatexdvp\mu=3.5,\ \sigma^2=0.6finkitxmlcodeinlinelatexdvp) . Utiliser un paramètre de mélange kitxmlcodeinlinelatexdvpp = 0.55finkitxmlcodeinlinelatexdvp. Tracer ensuite l'histogramme de l'échantillon aléatoire obtenu.


précédentsommairesuivant

Licence Creative Commons
Le contenu de cet article est rédigé par Vincent Goulet et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2018 Developpez.com.