¿Cómo generar muestras uniformemente al azar a partir de múltiples variables discretas sujetas a restricciones?

Me gustaría generar un proceso de Monte Carlo para llenar una urna con N bolas de colores I, C [i]. Cada color C [i] tiene un número mínimo y máximo de bolas que deben colocarse en la urna.

Por ejemplo, estoy tratando de poner 100 bolas en la urna y puedo llenarla con cuatro colores:

• Rojo - Mínimo 0, Máximo 100 # NB, no se puede alcanzar el máximo real.
• Azul: mínimo 50, máximo 100
• Amarillo: mínimo 0, máximo 50
• Verde: mínimo 25, máximo 75

¿Cómo puedo generar N muestras que se distribuyan uniformemente entre los posibles resultados?

He visto soluciones a este problema donde las bolas no tienen mínimo o máximo, o alternativamente, tienen los mismos mínimos y máximos implícitos. Vea, por ejemplo, esta discusión sobre un tema ligeramente diferente:

¿Generar pesos distribuidos uniformemente que sumen a la unidad?

Pero tengo problemas para generalizar esta solución.

Dejar $n_i$ denotar la cantidad de bolas de color $C_i$. Además, deja$m_i$ y $M_i$ denota el número mínimo y máximo de bolas de color $C_i$, respectivamente. Queremos probar$(n_1, \dots, n_I)$ uniformemente al azar sujeto a las siguientes restricciones:

1. $m_i \leq n_i \leq M_i$
2. $\sum_{i=1}^I n_i = N$

En primer lugar, puede eliminar las restricciones de límite inferior (es decir, $m_i \leq n_i$) eligiendo $m_i$ bolas de color $C_i$inicialmente. Esto modifica las dos restricciones de la siguiente manera:

1. $0 \leq n_i \leq b_i = M_i - m_i$
2. $\sum_{i=1}^I n_i = B = N - \sum_{i=1}^I m_i$

Dejar $P(n_1, \dots, n_I \mid B, b_{1:I})$denotan la distribución uniforme que nos interesa. Podemos usar reglas de cadena y programación dinámica para tomar muestras de$P$eficientemente. Primero, usamos la regla de la cadena para escribir$P$ como sigue:

$$\begin{align} P(n_1, \dots, n_I \mid B, b_{1:I}) &= P(n_I \mid B, b_{1:I}) P(n_1, \dots, n_{I-1} \mid n_I, B, b_{1:I}) \\ &= P(n_I \mid B, b_{1:I}) P(n_1, \dots, n_{I-1} \mid B-n_I, b_{1:I-1}) \quad (1) \end{align}$$ dónde $P(n_I | B, b_{1:I}) = \sum_{n_1, \dots, n_{I-1}} P(n_1, \dots, n_I | B, b_{1:I})$ es la distribución marginal de $n_I$. Tenga en cuenta que$P(n_I | B, b_{1:I})$es una distribución discreta y se puede calcular de manera eficiente mediante programación dinámica. Además, tenga en cuenta que el segundo término en (1) se puede calcular de forma recursiva. Nosotros muestra$n_I$ en la primera ronda de la recursividad, actualice el número total de bolas a $B - n_I$ y recurse a la muestra $n_{I-1}$ en la siguiente ronda

La siguiente es una implementación de Matlab de la idea. La complejidad del algoritmo es$O(I \times B \times K)$ dónde $K = \max_{i=1}^I b_i$. El código utiliza s generados aleatoriamente en cada ejecución. Como resultado, algunos de los casos de prueba generados pueden no tener una solución válida, en cuyo caso el código imprime un mensaje de advertencia.$m_i$

global dpm b

I = 5; % number of colors
N = 300; % total number of balls

m = randi(50, 1, I)-1; % minimum number of balls from each from each color
M = 99*ones(1, I); % maximum number of balls from each color

% print original constraints
print_constraints(I, N, m, M, 'original constraints');

% remove the lower bound constraints
b = M - m;
B = N - sum(m);
m = zeros(size(m));

% print transformed constraints
print_constraints(I, B, zeros(1, I), b, 'transformed constraints');

% initialize the dynamic programming matrix (dpm)
% if dpm(i, n) <> -1, it denotes the value of the following marginal probability
% \sum_{k=1}^{i-1} P(n_1, ..., n_i |
dpm = -ones(I, B);

% sample the number of balls of each color, one at a time, using chain rule
running_B = B;  % we change the value of "running_B" on the fly, as we sample balls of different colors
for i = I : -1 : 1
    % compute marginal distribution P(n_i)

    % instead of P(n_i) we compute q(n_i) which is un-normalized.
    q_ni = zeros(1, b(i) + 1); % possibilities for ni are 0, 1, ..., b(i)
    for ni = 0 : b(i)
        q_ni(ni+1) = dpfunc(i-1, running_B-ni);
    end
    if(sum(q_ni) == 0)
        fprintf('Impossible!!! constraints can not be satisfied!\n');
        return;
    end
    P_ni = q_ni / sum(q_ni);
    ni = discretesample(P_ni, 1) - 1;
    fprintf('n_%d=%d\n', i, ni);
    running_B = running_B - ni;
end

donde la función print_constraints es

function [] = print_constraints(I, N, m, M, note)
    fprintf('\n------ %s ------ \n', note);
    fprintf('%d <= n_%d <= %d\n', [m; [1:I]; M]);
    fprintf('========================\n');
    fprintf('sum_{i=1}^%d n_i = %d\n', I, N);
end

y la función dpfunc realiza el cálculo de programación dinámica de la siguiente manera:

function res = dpfunc(i, n)
    global dpm b

    % check boundary cases
    if(n == 0)
        res = 1;
        return;
    end
    if(i == 0) % gets here only if n <> 0
        res = 0;
        return;
    end

    if(n < 0)
        res = 0;
        return;
    end

    if(dpm(i, n) == -1) % if <> -1, it has been compute before, so, just use it!
        % compute the value of dpm(i, n) = \sum_{n_1, ..., n_i} valid(n, n_1, ..., n_i)
        % where "valid" return 1 if \sum_{j=1}^i n_i = n and 0 <= n_i <= b_i, for all i
        % and 0 otherwise.
        dpm(i, n) = 0;
        for ni = 0 : b(i)
            dpm(i, n) = dpm(i, n) + dpfunc(i-1, n-ni);
        end
    end
    res = dpm(i, n);
end

y finalmente, la función muestra discreta (p, 1) extrae una muestra aleatoria de la distribución discreta$p$. Puede encontrar una implementación de esta función aquí .

Consideremos una generalización de este problema. Existen$m=4$ latas de pintura de $m=4$ colores distintos y $n^{(0)}=100$pelotas. lata$i$ puede aguantar hasta $a^{(0)}_i = (100, 100, 50, 75)$pelotas. Desea generar configuraciones de bolas en las latas que tienen al menos$b_i = (0, 50, 0, 25)$ bolas en lata $i$ para cada $i$, cada configuración con igual probabilidad.

Dichas configuraciones están en correspondencia uno a uno con las configuraciones obtenidas después de eliminar $b_i$ bolas de lata $i$, limitando el $n = n^{(0)} - \sum_i b_i = 100 - (0+50+0+25)=25$ bolas restantes a lo sumo $a_i = a^{(0)}_i - b_i = (100, 50, 50, 50)$por lata. Por lo tanto, solo generaré estos y te dejaré ajustarlos después (poniendo$b_i$ bolas de vuelta en lata $i$ para cada $i$)

Para contar estas configuraciones, arregle todos menos dos de los índices, digamos $i$ y $j$. Supongamos que hay$s_k$ bolas ya en lata $k$ para cada $k$ diferente de $i$ y $j$. Eso deja$s_i+s_j$pelotas. Condicional a donde el otro$n - (s_i+s_j)$las bolas son, estas se distribuyen uniformemente dentro de latas$i$ y $j$. Las configuraciones posibles son$1 + \min(a_i + a_j - s_i - s_j, s_i+s_j)$ en número (ver los comentarios), que van desde colocar tantas bolas en la lata $i$ como sea posible a través de la colocación de tantas bolas en la lata $j$ como sea posible.

Si lo desea, puede contar el número total de configuraciones aplicando este argumento de forma recursiva al resto $m-2$latas Sin embargo, para obtener muestras ni siquiera necesitamos saber este recuento. Todo lo que necesitamos hacer es visitar repetidamente todos los pares desordenados posibles$\{i,j\}$de latas y al azar (y de manera uniforme) cambian la distribución de las bolas dentro de esas dos latas. Esta es una cadena de Markov con una distribución de probabilidad limitante que es uniforme en todos los estados posibles (como se muestra fácilmente usando métodos estándar). Por lo tanto, es suficiente comenzar en cualquier estado, ejecutar la cadena el tiempo suficiente para alcanzar la distribución limitante y luego realizar un seguimiento de los estados visitados por este procedimiento. Como de costumbre, para evitar la correlación en serie, esta secuencia de estados debe "diluirse" saltando a través de ellos (o revisada al azar). El adelgazamiento por un factor de aproximadamente la mitad del número de latas tiende a funcionar bien, porque después de eso, en promedio, muchos pasos se han visto afectados, produciendo una configuración realmente nueva.

Este algoritmo cuesta $O(m)$esfuerzo para generar cada configuración aleatoria en promedio. Aunque otro$O(m)$ existen algoritmos, este tiene la ventaja de no necesitar hacer cálculos combinatorios de antemano.

---

Como ejemplo, resolvamos una situación más pequeña manualmente. Dejar$a=(4,3,2,1)$ y $n=3$, por ejemplo. Hay 15 configuraciones válidas, que pueden escribirse como cadenas de números de ocupación. Por ejemplo, 0201coloca dos bolas en la segunda lata y una bola en la cuarta lata. Emulando el argumento, consideremos la ocupación total de las dos primeras latas. Cuando eso es$s_1+s_2=3$bolas, no quedan bolas para las dos últimas latas. Eso le da a los estados

30**, 21**, 12**, 03**

donde **representa a todos los posibles números de ocupación para las dos últimas latas: a saber, 00. Cuando$s_1+s_2=2$, los estados son

20**, 11**, 02**

donde ahora **puede ser cualquiera 10o 01. Eso da$3\times 2=6$más estados Cuando$s_1+s_2=1$, los estados son

10**, 01**

donde ahora **puede estar 20, 11pero no 02 (debido al límite de una bola en la última lata). Eso da$2\times 2=4$más estados Finalmente cuando$s_1+s_2=0$, todas las bolas están en las dos últimas latas, que deben estar llenas hasta el límite de $2$ y $1$. los$4+6+4+1=15$ estados igualmente probables por lo tanto son

3000, 2100, 1200, 0300; 2010, 2001, 1110, 1101, 0210, 0201; 1020, 1011, 0120, 0111; 0021.

Usando el siguiente código, una secuencia de $10,009$ tales configuraciones fueron generadas y reducidas a cada tercio, creando $3337$ configuraciones de la $15$estados. Sus frecuencias fueron las siguientes:

State: 3000 2100 1200 0300 2010 1110 0210 1020 0120 2001 1101 0201 1011 0111 0021 
Count:  202  227  232  218  216  208  238  227  237  209  239  222  243  211  208 

UNA $\chi^2$ prueba de uniformidad da un $\chi^2$ valor de $11.2$, $p=0.67$ ($14$ grados de libertad): es un hermoso acuerdo con la hipótesis de que este procedimiento produce estados igualmente probables.

---

Este Rcódigo está configurado para manejar la situación en la pregunta. Cambiar ay ntrabajar con otras situaciones. Establezca Nque sea lo suficientemente grande como para generar la cantidad de realizaciones que necesita después del adelgazamiento .

Este código engaña un poco al recorrer sistemáticamente todos $(i,j)$pares. Si quieres ser estrictos sobre la ejecución de la cadena de Markov, generar i, jy ijal azar, como se da en el código comentado.

#
# Gibbs-like sampler.
#
# `a` is an array of maximum numbers of balls of each type.  Its values should
#     all be integers greater than zero.
# `n` is the total number of balls.
#------------------------------------------------------------------------------#
g <- function(j, state, a) {
  #
  # `state` contains the occupancy numbers.
  # `a`     is the array of maximum occupancy numbers.
  # `j`     is a pair of indexes into `a` to "rotate".
  #
  k <- sum(state[j]) # Total occupancy.
  x <- floor(runif(1, max(0, k - a[j[2]]), min(k, a[j[1]]) + 1))
  state[j] <- c(x, k-x)
  return(state)
}
#
# Set up the problem.
#
a <- c(100, 50, 50, 50)
n <- 25

# a <- 4:1
# n <- 3
#
# Initialize the state.
#
state <- round(n * a / sum(a))
i <- 1
while (sum(state) < n) {
  if (state[i] < a[i]) state[i] <- state[i] + 1
  i <- i+1
}
while (sum(state) > n) {
  i <- i-1
  if (state[i] > 0) state[i] <- state[i] - 1
}
#
# Conduct a sequence of random changes.
#
set.seed(17)
N <- 1e5
sim <- matrix(state, ncol=1)
u <- ceiling(N / choose(length(state), 2) / 2)
i <- rep(rep(1:length(state), each=length(state)-1), u)
j <- rep(rep(length(state):1, length(state)-1), u)
ij <- rbind(i, j)
#
# Alternatively, generate `ij` randomly:
#   i <- sample.int(length(state), N, replace=TRUE)
#   j <- sample.int(length(state)-1, N, replace=TRUE)
#   ij <- rbind(i, ((i+j-1) %% length(state))+1)
#
sim <- cbind(sim, apply(ij, 2, function(j) {state <<- g(j, state, a); state}))
rownames(sim) <- paste("Can", 1:nrow(sim))
#
# Thin them for use.  Each column is a state.
#
thin <- function(x, stride=1, start=1) {
  i <- round(seq(start, ncol(x), by=stride))
  x[, i]
}
#
# Make a scatterplot of the results, to illustrate.
#
par(mfrow=c(1,1))
s <- thin(sim, stride=max(1, N/1e4))
pairs(t(s) + runif(length(s), -1/2, 1/2), cex=1/2, col="#00000005", pch=16)