R Language
Randomisation

Introduction

Remarques

Tirages et permutations aléatoires

La commande sample peut être utilisée pour simuler des problèmes de probabilité classiques, comme dessiner à partir d'une urne avec et sans remplacement, ou créer des permutations aléatoires.

Notez que tout au long de cet exemple, set.seed est utilisé pour garantir que le code exemple est reproductible. Cependant, l' sample fonctionnera sans appeler explicitement set.seed .

Permutation aléatoire

Dans la forme la plus simple, sample crée une permutation aléatoire d'un vecteur d'entiers. Cela peut être accompli avec:

set.seed(1251)
sample(x = 10)

[1]  7  1  4  8  6  3 10  5  2  9

Lorsqu'il n'y a pas d'autres arguments, sample renvoie une permutation aléatoire du vecteur de 1 à x . Cela peut être utile lorsque vous essayez de randomiser l'ordre des lignes dans un bloc de données. C'est une tâche courante lors de la création de tables de randomisation pour les essais ou lors de la sélection d'un sous-ensemble aléatoire de lignes pour analyse.

library(datasets)
set.seed(1171)
iris_rand <- iris[sample(x = 1:nrow(iris)),]

> head(iris)
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa

> head(iris_rand)
    Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
145          6.7         3.3          5.7         2.5  virginica
5            5.0         3.6          1.4         0.2     setosa
85           5.4         3.0          4.5         1.5 versicolor
137          6.3         3.4          5.6         2.4  virginica
128          6.1         3.0          4.9         1.8  virginica
105          6.5         3.0          5.8         2.2  virginica

Dessine sans remplacement

En utilisant l' sample , nous pouvons également simuler un dessin à partir d'un jeu avec et sans remplacement. Pour échantillonner sans remplacement (valeur par défaut), vous devez fournir un échantillon avec un ensemble à extraire et le nombre de tirages. L'ensemble à dessiner est donné comme vecteur.

set.seed(7043)
sample(x = LETTERS,size = 7)

[1] "S" "P" "J" "F" "Z" "G" "R"

Notez que si l'argument de size est identique à la longueur de l'argument de x , vous créez une permutation aléatoire. Notez également que vous ne pouvez pas spécifier une taille supérieure à la longueur de x lors de l'échantillonnage sans remplacement.

set.seed(7305)
sample(x = letters,size = 26)

[1] "x" "z" "y" "i" "k" "f" "d" "s" "g" "v" "j" "o" "e" "c" "m" "n" "h" "u" "a" "b" "l" "r" "w" "t" "q" "p"

sample(x = letters,size = 30)
Error in sample.int(length(x), size, replace, prob) : 
  cannot take a sample larger than the population when 'replace = FALSE'

Cela nous amène à dessiner avec remplacement.

Dessine avec remplacement

Pour effectuer des tirages aléatoires à partir d'un ensemble avec remplacement, vous utilisez l'argument replace pour sample . Par défaut, replace est FALSE . Si vous le définissez sur TRUE , chaque élément de l'ensemble à partir duquel vous dessinez peut apparaître plus d'une fois dans le résultat final.

set.seed(5062)
sample(x = c("A","B","C","D"),size = 8,replace = TRUE)

[1] "D" "C" "D" "B" "A" "A" "A" "A"

Modification des probabilités de tirage

Par défaut, lorsque vous utilisez sample , cela suppose que la probabilité de choisir chaque élément est la même. Considérez cela comme un problème de base. Le code ci-dessous équivaut à dessiner un marbre de couleur à partir d'une urne 20 fois, en écrivant la couleur, puis en replaçant le marbre dans l'urne. L'urne contient un marbre rouge, un bleu et un vert, ce qui signifie que la probabilité de dessiner chaque couleur est de 1/3.

set.seed(6472)
sample(x = c("Red","Blue","Green"),
       size = 20,
       replace = TRUE)

Supposons que nous voulions effectuer la même tâche, mais notre urne contient 2 billes rouges, 1 marbre bleu et 1 marbre vert. Une option serait de changer l'argument que nous envoyons à x pour ajouter un Red supplémentaire. Cependant, un meilleur choix est d'utiliser l'argument prob pour sample .

L'argument prob accepte un vecteur avec la probabilité de dessiner chaque élément. Dans notre exemple ci-dessus, la probabilité de tirer un marbre rouge serait de 1/2, tandis que la probabilité de tirer un marbre bleu ou vert serait de 1/4.

set.seed(28432)
sample(x = c("Red","Blue","Green"),
       size = 20,
       replace = TRUE,
       prob = c(0.50,0.25,0.25))

Contre-intuitivement, l'argument donné à prob n'a pas besoin de résumer à 1. R transformera toujours les arguments donnés en probabilités totalisant 1. Par exemple, considérons notre exemple ci-dessus de 2 Rouge, 1 Bleu et 1 Vert. Vous pouvez obtenir les mêmes résultats que notre code précédent en utilisant ces chiffres:

set.seed(28432)
frac_prob_example <- sample(x = c("Red","Blue","Green"),
                            size = 200,
                            replace = TRUE,
                            prob = c(0.50,0.25,0.25))

set.seed(28432)
numeric_prob_example <- sample(x = c("Red","Blue","Green"),
                               size = 200,
                               replace = TRUE,
                               prob = c(2,1,1))

> identical(frac_prob_example,numeric_prob_example)
[1] TRUE

La principale restriction est que vous ne pouvez pas définir toutes les probabilités à zéro, et aucune ne peut être inférieure à zéro.

Vous pouvez également utiliser prob lorsque replace est défini sur FALSE . Dans cette situation, une fois chaque élément dessiné, les proportions des valeurs prob des éléments restants donnent la probabilité du tirage suivant. Dans cette situation, vous devez avoir suffisamment de probabilités non nulles pour atteindre la size de l'échantillon que vous dessinez. Par exemple:

set.seed(21741)
sample(x = c("Red","Blue","Green"),
       size = 2,
       replace = FALSE,
       prob = c(0.8,0.19,0.01))

Dans cet exemple, le rouge est dessiné dans le premier dessin (en tant que premier élément). Il y avait 80% de chances que le rouge soit tiré, 19% de chances que le bleu soit tiré et 1% de chances que le vert soit tiré.

Pour le tirage suivant, Red n'est plus dans l'urne. Le total des probabilités parmi les articles restants est de 20% (19% pour le bleu et 1% pour le vert). Pour ce tirage, il y a 95% de chances que l'objet soit bleu (19/20) et 5% de chances qu'il soit vert (1/20).

Mettre la graine

La fonction set.seed est utilisée pour définir la valeur de départ aléatoire pour toutes les fonctions de randomisation. Si vous utilisez R pour créer une randomisation que vous souhaitez pouvoir reproduire, vous set.seed abord utiliser set.seed .

set.seed(1643)
samp1 <- sample(x = 1:5,size = 200,replace = TRUE)

set.seed(1643)
samp2 <- sample(x = 1:5,size = 200,replace = TRUE)

> identical(x = samp1,y = samp2)
[1] TRUE

Notez que le traitement parallèle nécessite un traitement spécial de la graine aléatoire, décrit plus ailleurs.