Question:
Comment générer des entiers aléatoires entre 1 et 4 qui ont une moyenne spécifique?
Fierce82
2020-01-06 04:34:06 UTC
view on stackexchange narkive permalink

Je dois générer 100 entiers aléatoires dans R , où chaque entier est compris entre 1 et 4 (d'où 1,2,3,4) et la moyenne est égale à une valeur spécifique.

Si je tire des nombres uniformes aléatoires entre 1 et 5 et que j'obtiens floor , j'ai une moyenne de 2,5.

  x = étage (runif (100, min = 1, max = 5))
 

J'ai besoin de fixer la moyenne à 1,9 ou 2,93 par exemple.

Je suppose que je peux générer des entiers aléatoires qui ajoutent à 100 * signifie, mais je ne sais pas comment limiter aux entiers aléatoires entre 1 et 4.

Ont-ils besoin d'être indépendants?
Je ne sais pas si la réponse est oui ou non, si vous pensez à quoi que ce soit quoi qu'il en soit, je suppose que cela suffira, à condition qu'ils satisfassent à mes contraintes, entiers, 1 à 4 et moyenne fixe.
Je pense que c'est un peu sous-déterminé ... On peut par exemple obtenir une moyenne de 1,9 avec `sample (size = n, x = 1: 4, prob = c (3.666,1,1,1), replace =TRUE) `mais aussi avec` sample (size = n, x = 1: 4, prob = c (3,1,1,0.715), replace = TRUE) `.
Vous demandez-vous comment contraindre la moyenne de la distribution sous-jacente ou la moyenne de l'échantillon?
-1
Les nombres entiers entre 1 et 4 n'autorisent que 2 et 3. Vous devez également spécifier la distribution dont ils sont tirés au hasard (ou en constituent une).
J'ai voté pour laisser cela * ouvert * parce qu'il y a une question algorithmique intéressante ici - la partie R est accessoire;vous pouvez tout aussi bien l'implémenter en Python ou avec un pad et quelques dés.
`floor (runif (100, min = 1, max = 5))` est juste une façon obscure de faire `sample (1: 4, ...)` avec des probabilités par défaut `... prob = rep (0.25,4) ».Vous voulez «sample (1: 4, prob)» avec des probabilités non uniformes.C'est sous-contraint, avez-vous d'autres contraintes?Vous vous souciez du stdev?Voulez-vous que la distribution soit aussi proche que possible de la normale?
Sept réponses:
#1
+41
whuber
2020-01-06 22:46:03 UTC
view on stackexchange narkive permalink

Je suis d'accord avec X'ian pour dire que le problème est sous-spécifié. Cependant, il existe une solution élégante, évolutive, efficace, efficace et polyvalente à considérer.

Étant donné que le produit de la moyenne de l'échantillon et de la taille de l'échantillon est égal à la somme de l'échantillon, le problème concerne la génération d'un échantillon aléatoire de valeurs $ n $ dans l'ensemble $ \ {1,2, \ ldots, k \} $ cette somme à $ s $ (en supposant $ n \ le s \ le kn, $ bien sûr).

Pour expliquer la solution proposée et, je l'espère, justifier la revendication d'elegance, je propose une interprétation graphique de ce schéma d'échantillonnage. Disposez une grille de $ k $ lignes et $ n $ colonnes. Sélectionnez chaque cellule de la première ligne. Sélectionnez au hasard (et uniformément) $ sn $ des cellules restantes dans les lignes $ 2 $ à $ k. $ La valeur de l'observation $ i $ dans l'échantillon est le nombre de cellules sélectionnées dans la colonne $ i: $

Figure

Cette grille $ 4 \ times 100 $ est représentée par des points noirs au niveau des cellules non sélectionnées et des patchs colorés au niveau des cellules sélectionnées. Il a été généré pour produire une valeur moyenne de 2 $, $ donc $ s = 200. $ Ainsi, 200-100 $ = 100 $ Les cellules ont été sélectionnées au hasard parmi les premières $ k-1 = 3 $ lignes. Les couleurs représentent le nombre de cellules sélectionnées dans chaque colonne. Il y en a 28 $ , 47 $ deux, 22 $ trois et 3 $ $ quatre. L'échantillon ordonné correspond à la séquence de couleurs de la colonne $ 1 $ à la colonne $ n = 100. $

Pour démontrer l'évolutivité et l'efficacité, voici une commande R pour générer un échantillon selon ce schéma. La question concerne le cas où $ k = 4, n = 100 $ et $ s $ est $ n $ fois la moyenne souhaitée de l'échantillon:

  tabuler (sample.int ((k-1) * n, s-n) %% n + 1, n) + 1
 

Parce que sample.int nécessite $ O (sn) $ temps et $ O ( (k-1) n) $ espace, et tabulate nécessite $ O (n) $ temps et espace, cet algorithme nécessite $ O (\ max (sn, n)) $ temps et $ O (kn) $ espace : c'est scalable. Avec $ k = 4 $ et $ n = 100 $ , mon poste de travail ne prend que 12 microsecondes pour effectuer ce calcul : c'est efficient.

(Voici une brève explication du code. Notez que les entiers $ x $ dans $ \ {1,2, \ ldots, (k-1) n \} $ peut être exprimé uniquement comme $ x = nj + i $ $ j \ in \ {0,1, \ ldots, k-2 \} $ et $ i \ in \ {1,2, \ ldots, n \}. $ Le code prend un échantillon de ces $ x, $ les convertit en leur $ ( i, j) $ coordonnées de la grille, compte le nombre de fois où chaque $ i $ apparaît (qui va de $ 0 $ à $ k-1 $ ) et ajoute $ 1 $ à chaque décompte.)

Pourquoi cela peut-il être considéré comme effective? L'une des raisons est que les propriétés de distribution de ce schéma d'échantillonnage sont simples à déterminer:

  • Il est échangeable: toutes les permutations de n'importe quel échantillon sont également probables.

  • La chance que la valeur $ x \ in \ {1,2, \ ldots, k \} $ apparaisse à la position $ i, $ que j'écrirai comme $ \ pi_i (x), $ est obtenu par un argument de comptage hypergéométrique de base comme $$ \ pi_i (x) = \ frac {\ binom {k-1} {x-1} \ binom {(n-1) (k-1)} {sn-x +1}} {\ binom {n (k-1)} {sn}}. $$ Par exemple, avec $ k = 4, $ $ n = 100, $ et une moyenne de 2,0 $ $ (de sorte que $ s = 200 $ ) les chances sont $ \ pi = (0.2948, 0.4467, 0.2222, 0.03630), $ d'être en accord étroit avec les fréquences dans l'échantillon précédent. Voici les graphiques de $ \ pi_1 (1), \ pi_1 (2), \ pi_1 (3), $ et $ \ pi_1 (4) $ en fonction de la somme:

    Figure 2

  • La probabilité que la valeur $ x $ apparaisse à la position $ i $ alors que le la valeur $ y $ apparaît à la position $ j $ se trouve de la même manière que $$ \ pi_ {ij} (x, y) = \ frac {\ binom {k-1} {x-1} \ binom {k-1} {y-1} \ binom {(n-1) (k-1)} {snx-y + 2}} {\ binom {n (k-1)} {sn}}. $$

Ces probabilités $ \ pi_i $ et $ \ pi_ {ij} $ permettent d'appliquer le L'estimateur Horvitz-Thompson à ce plan d'échantillonnage probabiliste ainsi que pour calculer les deux premiers moments des distributions de diverses statistiques.

Enfin, cette solution est versatile dans la mesure où elle permet des variations simples et facilement analysables pour contrôler la distribution d'échantillonnage.Par exemple, vous pouvez sélectionner des cellules de la grille avec des probabilités spécifiées mais inégales dans chaque ligne, ou avec un modèle de type urne pour modifier les probabilités au fur et à mesure de l'échantillonnage, contrôlant ainsi les fréquences des décomptes de colonnes.

(+1) Élégance ultime, en effet.
La réponse est trop difficile à suivre pour moi, je l'apprécie quand même
Quelle réponse élégante et joliment présentée.Si cela ne vous dérange pas mon humble suggestion en tant que lecteur, vous pourriez envisager de présenter d'abord la solution (les correctifs de comptage et le grand diagramme), puis de parler de la mise en œuvre et de la façon dont votre argument sur la façon dont cela correspond à l'intuition, et enfin pourquoic'est efficace.Cela pourrait le rendre un peu plus facile à suivre.
@Neil Merci pour votre suggestion.Je pense que c'est une bonne et je vais l'examiner attentivement.
C'est une réponse charmante et satisfaisante.Je voulais noter que les nombres sont suffisamment petits dans ce cas (100 nombres totalisant 190) pour que nous puissions calculer la distribution uniforme de toutes les valeurs qui satisfont.J'ai effectué quelques calculs pour comparer votre distribution à celle-ci et j'ai constaté que la vôtre est ** beaucoup plus susceptible (des milliards dans certains cas) de sélectionner de petites valeurs non-1 **.Par exemple, votre modèle ne donnera presque jamais de distributions avec> 45 "uns" (~ 0,002% de chance pour 46, disparaissant pour plus), mais cela comprend ~ 58% des valeurs uniformes du modèle.
#2
+15
Xi'an
2020-01-06 11:58:22 UTC
view on stackexchange narkive permalink

La question est sous-spécifiée dans la mesure où les contraintes sur les fréquences \ begin {align} n_1 + 2n_2 + 3n_3 + 4n_4& = 100M \\ n_1 + n_2 + n_3 + n_4& = 100 \ end {align} ne déterminez pas une distribution: «aléatoire» n'est pas associé à une distribution particulière, sauf si l'OP signifie «uniforme». Par exemple, s'il existe une solution $ (n_1 ^ 0, n_2 ^ 0, n_3 ^ 0, n_4 ^ 0) $ au système ci-dessus, alors la distribution a dégénéré à cette solution produit un tirage au sort qui est toujours $ (n_1 ^ 0, n_2 ^ 0, n_3 ^ 0, n_4 ^ 0) $ .

Dans le cas où la question concerne la simulation d'une distribution uniforme sur la grille \ begin {align} n_1 + 2n_2 + 3n_3 + 4n_4& = 100M \\ n_1 + n_2 + n_3 + n_4& = 100 \ end {align} on peut toujours utiliser un algorithme Metropolis-Hastings. À partir de $ (n_1 ^ 0, n_2 ^ 0, n_3 ^ 0, n_4 ^ 0) $ , créez une chaîne de Markov en proposant des perturbations aléatoires symétriques du vecteur $ (n_1 ^ t, n_2 ^ t, n_3 ^ t, n_4 ^ t) $ et acceptez si le résultat est dans $ \ {1,2,3,4 \} ^ 4 $ et satisfait les contraintes.

Par exemple, voici un rendu R brut:

  cenM = 293
# point de départ (n¹, n³, n⁴)
n<-sample (1: 100,3, rep = TRUE)
tandis que ((somme (n) >100) | (n [2] -n [1] + 2 * n [3]! = cenM-200))
    n<-sample (1: 100,3, rep = TRUE)
#Markov chaîne
pour (t dans 1: 1e6) {
  prop<-n + échantillon (-10: 10,3, rep = TRUE)
  if ((somme (prop) <101) &
      (prop [2] -prop [1] + 2 * prop [3] == cenM-200) &
      (min (prop) >0))
        n = accessoire}
c (n [1], somme de 100 (n), n [-1])
 

avec la distribution de $ (n_1, n_3, n_4) $ sur les 10⁶ itérations:

enter image description here

Si vous voulez dessiner les entiers eux-mêmes,

  échantillon (c (rep (1, n [1]), rep (2,100-sum (n)), rep (3, n [2]), rep (4, n [3])) )
 

est un moyen rapide & de produire un échantillon.

Merci.mais je ne comprends pas comment je peux utiliser cela pour obtenir les 4 entiers (entre 1 et 4)
Cela génère les nombres de 1,2,3,4 $ n_1, n_2, n_3, n_4) $ de sorte qu'il y en a 100 et la somme est cenM.L'entier lui-même est une permutation aléatoire de $ n_1 $ 1, ..., $ n_4 $ 4's.
#3
+9
John
2020-01-07 21:28:57 UTC
view on stackexchange narkive permalink

Je veux ... euh ... "atténuer" la réponse étonnante de @ whuber, que @TomZinger dit est trop difficile à suivre. Je veux dire par là que je veux le re-décrire en des termes que je pense que Tom Zinger comprendra, car c'est clairement la meilleure réponse ici. Et au fur et à mesure que Tom utilise progressivement la méthode et découvre qu'il a besoin, par exemple, de connaître la distribution des échantillons plutôt que simplement leur moyenne, la réponse de Whuber sera exactement ce qu'il recherche.

En bref: il n'y a pas d'idées originales ici, seulement une explication plus simple.

Vous souhaitez créer des $ n $ entiers de $ 1 $ à $ 4 $ avec une moyenne $ r $ . Je vais suggérer de calculer des $ n $ entiers de $ 0 $ à $ 3 $ avec la moyenne $ r-1 $ , puis en ajoutant un à chacun d'eux. Si vous pouvez faire cette dernière chose, vous pouvez résoudre le premier problème. Par exemple, si nous voulons 10 entiers entre $ 1 $ et $ 4 $ avec une moyenne 2,6 $ , nous pouvons noter ces entiers $ 10 $ entre $ 0 $ et 3 $ $ ...

0,3,2,1,3,1,2,1,3,0

dont la moyenne est 1,6 $ ; si nous augmentons chacun de $ 1 $ , nous obtenons

1,4,3,2,4,2,3,2,4,1

dont la moyenne est 2,6 $ . C'est si simple.

Pensons maintenant aux nombres $ 0 $ à $ 3 $ . Je vais les considérer comme "combien d'articles ai-je dans un 'petit' ensemble?" Je n'ai peut-être aucun élément, un élément, deux éléments ou trois éléments. Donc la liste

0,3,2,1,3,1,2,1,3,0

représente dix petits ensembles différents. Le premier est vide; le second a trois éléments, et ainsi de suite. Le nombre total d'éléments dans tous les ensembles est la somme des dix nombres, c'est-à-dire 16 $ $ . Et le nombre moyen d'éléments dans chaque ensemble est ce total, divisé par 10 $ , d'où 1,6 $ .

L'idée de whuber est la suivante: supposons que vous vous fabriquiez dix petits ensembles, le nombre total d'éléments étant $ 10t $ pour un certain nombre $ t $ . Alors la taille moyenne des ensembles sera exactement $ t $ . De la même manière, si vous créez vous-même des ensembles de $ n $ avec un nombre total d'éléments étant $ nt $ span >, le nombre moyen d'éléments dans un ensemble sera $ t $ . Vous dites que vous êtes intéressé par le cas $ n = 100 $ .

Rendons ceci concret pour votre exemple: vous voulez 100 éléments entre 1 et 4 dont la moyenne est 1,9 $ . En utilisant l'idée de mon premier paragraphe, je vais changer cela en "make $ 100 $ ints entre $ 0 $ span> et 3 $ $ dont la moyenne est de 0,9 $ ". Quand j'aurai terminé, j'ajouterai $ 1 $ à chacun de mes entiers pour obtenir une solution à votre problème. Donc ma moyenne cible est $ t = 0,9 $ .

Je souhaite créer des ensembles de 100 $ $ , chacun avec entre $ 0 $ et 3 $ $ éléments dedans, avec une taille d'ensemble moyenne de 0,9 $ .

Comme je l'ai observé ci-dessus, cela signifie qu'il doit y avoir un total d'éléments 100 $ \ cdot 0.9 = 90 $ dans les décors. À partir des nombres $ 1, 2, \ ldots, 300 $ , je vais sélectionner exactement 90 $ . Je peux indiquer ceux sélectionnés en faisant une liste de 300 points et X:

..X .... X ... XX ...

où la liste ci-dessus indique que j'ai sélectionné les nombres 3, 9, 13, 14, et puis beaucoup d'autres que je n'ai pas montrés parce que j'en ai eu marre de taper. :) Je peux prendre cette séquence de 300 points et X et la diviser en trois groupes de 100 points chacun, que j'arrange les uns sur les autres pour obtenir quelque chose qui ressemble à ceci:

  ... X .... X..X ..... X ...
.X ... X ..... X ... X .....
..X ... X.X..X ...... X ..
 

mais continue pour 100 éléments complets dans chaque ligne. Le nombre de X dans chaque ligne peut différer - il peut y en avoir 35 dans la première ligne, 24 dans la deuxième et 31 dans la troisième, par exemple, et c'est OK. [Merci à whuber d'avoir signalé que je me suis trompé dans un premier brouillon!]

Maintenant, regardez chaque colonne : chaque colonne peut être considérée comme un ensemble, et cet ensemble contient entre 0 et 3 "X". Je peux écrire les chiffres sous les lignes pour obtenir quelque chose comme ceci:

  ... X .... X..X ..... X ...
.X ... X ..... X ... X .....
..X ... X.X..X ...... X ..
011101102003000101100
 

C'est-à-dire que j'ai produit 100 nombres, chacun compris entre 1 et 3. Et la somme de ces 100 nombres doit être le nombre de X, total, dans les trois lignes, qui était de 90. La moyenne doit donc être $ 90/100 = 0.9 $ , comme vous le souhaitez.

Voici donc les étapes pour obtenir 100 entiers entre 1 et 4 dont la moyenne est exactement $ s $ .

  1. Soit $ t = s - 1 $ .
  2. Calculer $ k = 100 t $ ; c'est le nombre de X que nous placerons dans les lignes, au total.
  3. Faites une liste de 300 points ou X, dont $ k $ sont des X.
  4. Divisez-le en trois rangées de 100 points ou X, chacune contenant environ un tiers des X, plus ou moins.
  5. Organisez-les dans un tableau et calculez les sommes des colonnes, en obtenant 100 entiers entre $ 0 $ et $ 3 $ span >. Leur moyenne sera $ t $ .
  6. Ajoutez un à chaque somme de colonne pour obtenir 100 entiers entre 1 $ et 4 $ $ dont la moyenne est $ s $ .

Maintenant, la partie délicate de ceci est vraiment à l'étape 4: comment choisir des éléments $ 300 $ , $ k $ dont "X" et les autres 300-k $ dont "."? Eh bien, il s'avère que R a une fonction qui fait exactement cela.

Et puis whuber vous dit comment l'utiliser: vous écrivez

  tabuler (sample.int ((k-1) * n, s-n) %% n + 1, n)
 

Pour votre cas particulier, $ n = 100 $ , et $ s $ , le nombre total d'éléments dans tous les petits ensembles, est $ 100r $ , et vous voulez des nombres entre $ 1 $ et 4 $ $ , donc $ k = 4 $ , donc $ k -1 $ (la plus grande taille pour un 'petit ensemble') est 3, donc cela devient

  tabuler (sample.int (3 * 100, 100r-100) %% 100 + 1, n)
 

ou

  tabuler (sample.int (3 * 100, 100 * (r-1)) %% 100 + 1, 100)
 

ou, en utilisant mon nom $ t $ pour $ r - 1 $ , il devient

  tabuler (sample.int (3 * 100, 100 * t) %% 100 + 1, 100)
 

Le "+1" à la fin de sa formule originale est exactement l'étape nécessaire pour convertir des "nombres entre $ 0 $ et $ 3 $ " à "nombres entre $ 1 $ et $ 4 $ ".

Travaillons de l'intérieur et simplifions à $ n = 10 $ pour que je puisse montrer des exemples de résultats:

  tabuler (sample.int (3 * 10, 10 * t) %% 10 + 1, 10)
 

Et visons $ t = 1.9 $ , donc cela devient

  tabuler (sample.int (3 * 10, 10 * 1.9) %% 10 + 1, 10)
 

Commençant par sample.int (3 * 10, 10 * 1.9) : cela produit une liste d'entiers 19 $ entre $ 1 $ et 30 $ . (c'est-à-dire que cela a résolu le problème de la sélection de $ k $ nombres sur votre total - 300 $ dans votre vrai problème, $ 30 $ dans mon petit exemple).

Comme vous vous en souviendrez, nous voulons produire trois lignes de dix points et X chacune, quelque chose comme

  X.X.XX.XX.
 XXXX.XXX ..
 XX.X.XXX ..
 

Nous pouvons lire ceci de gauche à droite de haut en bas (c'est-à-dire dans l'ordre de lecture normal) pour produire une liste d'emplacements pour Xs: le premier élément est un point; les deuxième et troisième sont des X, et ainsi de suite, donc notre liste d'emplacements commence par $ 1, 3, 5, 6, \ ldots $ . Quand nous arrivons à la fin d'une ligne, nous continuons à compter, donc pour l'image ci-dessus, les emplacements X seraient $ 1, 3, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 21, 22, 24, 26, 27, 28 $ . Est-ce clair?

Eh bien, le code whubers produit exactement cette liste d'emplacements avec sa section la plus interne.

L'élément suivant est %% 10 ; cela prend un nombre et produit son reste par dix. Notre liste devient donc $ 1, 3, 5, 6, 8, 9, 1, 2, 3, 4, 6, 7, 8, 1, 2, 4, 6, 7, 8 $ . Si nous divisons cela en trois groupes - ceux qui proviennent de nombres compris entre $ 1 $ et 10 $ , ceux qui proviennent de nombres de 11 $ à 20 $ , et ceux qui proviennent de nombres 21 $ à 30 $ , nous obtenons 1, 3, 5, 6 $, 8, 9 $ , puis $ 1, 2, 3, 4, 6, 7, 8, $ et enfin 1, 2, 4, 6, 7, 8 $ . Ceux-ci vous indiquent où se trouvent les X dans chacune des trois lignes. Il y a un problème subtil ici: s'il y avait eu un X en position 10 dans la première ligne, la première de nos trois listes aurait été $ 1, 3, 5, 6, 8, 9 , 0 $ , et la fonction tabuler n'aime pas "0". Ainsi, whuber ajoute 1 à chaque élément de la liste pour obtenir 2 $, 4, 6, 7, 9, 10, 1 $ . Passons au calcul global:

  tabuler (sample.int (3 * 10, 10 * 1.9) %% 10 + 1, 10)
 

Ceci demande "pour ces 30 $ $ nombres, chacun indiquant s'il y a un X dans une colonne, dites-moi combien de fois chaque colonne (à partir de $ 1 $ à $ 10 $ --- c'est ce que le" 10 "final vous dit) apparaît, c'est-à-dire, dites-moi combien de X sont dans chaque colonne. Le résultat est 0 3 2 2 2 1 3 2 3 1 que (à cause du décalage de un), vous devez lire comme "il n'y a pas de X dans la 10e colonne; il y a 3 X dans la première colonne; il y a 2 X dans la deuxième colonne", et ainsi de suite à "il y a un X dans la 9ème colonne".

Cela vous donne dix entiers entre $ 0 $ et 3 $ $ dont la somme est 19 $ , d'où une moyenne de 1,9 $ . Si vous augmentez chacun d'eux de 1, vous obtenez dix entiers entre 1 $ et 4 $ $ dont la somme est 29 $ , d'où une valeur moyenne de 2,9 $ .

Vous pouvez généraliser à $ n = 100 $ , j'espère.

+1 Bienvenue sur notre site, John.J'apprécie vos efforts pour expliquer et clarifier ces idées.À un moment donné, votre description s'écarte de ce que fait le code: on ne divise pas les trois lignes en groupes de 30 chacune.Au lieu de cela, 90 cellules sur les 300 cellules de ces lignes sont sélectionnées.Habituellement, chaque ligne aura un nombre différent de cellules.
Merci ... En fait, je m'inquiétais un peu à ce sujet au moment où je l'écrivais, mais j'étais au milieu de la phrase, et le temps que j'aie terminé, l'idée s'était envolée.Je vais modifier pour essayer de le réparer.
#4
+4
Noah
2020-01-06 05:51:48 UTC
view on stackexchange narkive permalink

Vous pouvez utiliser sample () et sélectionner des probabilités spécifiques pour chaque entier. Si vous additionnez le produit des probabilités et des nombres entiers, vous obtenez la valeur attendue de la distribution. Donc, si vous avez une valeur moyenne en tête, disons $ k $ , vous pouvez résoudre l'équation suivante: $$ k = 1 \ fois P (1) + 2 \ fois P (2) + 3 \ fois P (3) + 4 \ fois P (4) $$ span > Vous pouvez choisir arbitrairement deux des probabilités et résoudre pour la troisième, qui détermine la quatrième (car $ P (1) = 1- (P (2) + P (3) + P (4)) $ car les probabilités doivent totaliser $ 1 $ ). Par exemple, laissez $ k = 2,3 $ , $ P (4) =. 1 $ et $ P (3) =. 2 $ . Alors on a ça $$ k = 1 \ fois [1- (P (2) + P (3) + P (4)] + 2 \ fois P (2) + 3 \ fois P ( 3) + 4 \ fois P (4) $$ $$ 2,3 = [1 - (P (2) +. 1 + .2)] + 2 * P (2) + 3 \ times .2 + 4 \ times .1 $$ $$ 2,3 = .7 + P (2) + .6 + .4 $$ $$ P (2) =. 6 $$ $$ P (1) = 1- (P (2) + P (3) + P (4) = 1 - (.6 + .1 + .2) =. 1 $$

Vous pouvez donc exécuter x <- sample (c (1, 2, 3, 4), 1e6, replace = TRUE, prob = c (.1, .6, .2, .1)) et mean (x) est d'environ 2,3 $ $

Ceci explique comment contraindre la moyenne de la * distribution *.Mais, l'OP a spécifié dans les commentaires qu'il voulait contraindre la * moyenne de l'échantillon * (qui ne correspondra pas à la moyenne de la distribution, sauf dans l'attente).D'un autre côté, il semble que le PO ait quand même accepté cette réponse, alors peut-être que ce n'est pas ce qu'ils voulaient après tout.
êtes-vous sû[email protected] pourquoi la moyenne de l'échantillon n'est pas contreint?c'est égal à la cible
Cette réponse ne permet pas de rendre la moyenne de l'échantillon égale à la valeur cible: la plupart du temps, la moyenne ne sera * pas * égale à la cible.
@TomZinger Oui.Cette réponse décrit bien comment échantillonner à partir d'une distribution avec la moyenne cible donnée.Mais, la moyenne d'un échantillon tiré d'une distribution ne sera généralement pas égale à la moyenne de la distribution.
J'ai écrit ma réponse avant de voir ce commentaire, mais j'ai pensé que ce serait utile de toute façon.J'imaginais qu'il faudrait un problème d'optimisation de la programmation entière pour obtenir une moyenne d'échantillon exactement égale à une valeur.
@user20160 Je ne suis pas sûr d'avoir bien compris, alors excuses si je n'ai pas répondu correctement plus tôt.Je pense que c'est le contraire, l'échantillon a une moyenne constante, en fonction de cela que je veux échantillonner.La moyenne de distribution est de 2,5 je suppose (uniforme).Je veux un échantillonnage biaisé.
#5
+1
gunes
2020-01-06 05:29:08 UTC
view on stackexchange narkive permalink

Voici un algorithme simple: Créez $ n-1 $ des entiers aléatoires dans la plage $ [1,4]$ et calculez l'entier $ n ^ {th} $ pour que la moyenne soit égale à la valeur spécifiée.Si ce nombre est inférieur à 1 $ ou supérieur à 4 $ $ , distribuez un par un le surplus /manque sur d'autres entiers, par exemplesi l'entier est 5 $ $ , nous avons un surplus de 1 $ ;et nous pouvons ajouter ceci au prochain entier si ce n'est pas $ 4 $ , sinon ajouter au suivant etc. Ensuite, mélangez tout le tableau.

Un gros problème avec cette proposition est qu'elle ne donne aucune indication sur les fréquences attendues des valeurs résultantes.
Bien qu'intéressant, je pensais que l'OP ne nécessitait qu'un algorithme pour générer le tableau d'entiers souhaité de manière non déterministe.
Je pense que cela évite l'essence de la question plutôt que de fournir une réponse satisfaisante.Une bonne réponse doit être capable de caractériser la distribution qu'elle propose de manière significative, par exemple en donnant une formule pour les probabilités ou au moins en donnant les premiers instants.
Un ajustement mineur des données simulées est probablement `` approprié '', cependant, l'examen de la conception d'expert dans les cas où un écart moyen plus important est requis, en fonction de l'objectif visé, pourrait être, du point de vue du test d'hypothèse, `` suspect '', enmon jugement.Le fait de surcharger ou de sous-charger un plan aléatoire pour justifier ou rejeter d'éventuels effets non aléatoires qui ont été réellement observés peut être une pratique discutable.Donc, toute méthode qui fait un très petit ajustement au dernier des 100 observations est probablement conforme aux bonnes pratiques, à mon avis.
#6
+1
N4v
2020-01-09 21:46:53 UTC
view on stackexchange narkive permalink

En complément de la réponse de whuber, j'ai écrit un script en Python qui parcourt chaque étape du schéma d'échantillonnage. Notez que ceci est destiné à des fins d'illustration et n'est pas nécessairement performant.

Exemple de sortie:

  n = 10, s = 20, k = 4

Grille de départ
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
X X X X X X X X X X

Rempli dans la grille
X X. . X . X . . X
. . X X X. . . . .
. . . . X X. . . .
X X X X X X X X X X

Grille finale
X X. . X . X . . X
. . X X X. . . . .
. . . . X X. . . .
X X X X X X X X X X
2 2 2 2 4 2 2 1 1 2
 

Le script:

  importer numpy comme np

# Définir les paramètres de départ
entiers = [1, 2, 3, 4]
n = 10
s = 20
k = len (entiers)


def print_grid (grille, titre):
    imprimer (f '\ n {titre}')
    pour la ligne dans la grille:
        print ('' .join ([str (élément) pour élément dans la ligne]))


# Créer la grille de départ
grille = []
pour i dans la plage (1, k + 1):
    si je < k:
        grid.append (['.' for j in range (n)])
    autre:
        grid.append (['X' pour j dans range (n)])

# Imprimer la grille de départ
print_grid (grille, 'Grille de départ')

# Remplissez aléatoirement et uniformément les lignes restantes
index = np.random.choice (range ((k - 1) * n), s - n, replace = False)
pour i dans les index:
    row = i // n
    col = i% n
    grid [row] [col] = 'X'

# Imprimer la grille remplie
print_grid (grille, 'Rempli dans la grille')

# Calculez le nombre de cellules sélectionnées dans chaque colonne
column_counts = []
pour col dans la plage (n):
    count = sum (1 for i in range (k) if grid [i] [col] == 'X')
    column_counts.append (nombre)
grid.append (colonnes_compte)

# Imprimez la grille finale et vérifiez que la colonne compte somme à s
print_grid (grille, 'Grille finale')
impression()
print (f'La colonne compte-t-elle une somme à {s}? {sum (column_counts) == s}. ')
 
#7
+1
gruvn
2020-04-07 18:56:31 UTC
view on stackexchange narkive permalink

J'ai transformé la réponse de Whuber en fonction r.J'espère que cela aide quelqu'un.

  • n est le nombre d'entiers que vous voulez;
  • t est le moyen que vous voulez;et
  • k est la limite supérieure que vous souhaitez pour vos valeurs renvoyées
  whubernator<-function (n = NULL, t = NULL, kMax = 5) {
  z = tabuler (sample.int (kMax * (n), (n) * (t), replace = F) %% (n) +1, (n))
  retour (z)
}
 

Cela semble fonctionner comme prévu:

  > w = whubernator (n = 10, t = 4,2)
> moyenne (w)
[1] 4,2
Longueur > (w)
[1] 10
> w
 [1] 3 5 3 5 5 3 4 5 5 4
 

Il peut renvoyer des 0, ce qui correspond à mes besoins.

  > whubernator (n = 2, t = 0,5)
[1] 1 0
 


Ce Q&R a été automatiquement traduit de la langue anglaise.Le contenu original est disponible sur stackexchange, que nous remercions pour la licence cc by-sa 4.0 sous laquelle il est distribué.
Loading...