¿Funcionaría un método de muestreo de "importancia Gibbs"?

Sospecho que esta es una pregunta bastante inusual y exploratoria, así que por favor tengan paciencia conmigo.

Me pregunto si se podría aplicar la idea del muestreo de importancia al muestreo de Gibbs. Esto es lo que quiero decir: en el muestreo de Gibbs, cambiamos el valor de una variable (o bloque de variables) a la vez, tomando muestras de la probabilidad condicional dadas las variables restantes.

Sin embargo, puede no ser posible o fácil tomar muestras de la probabilidad condicional exacta. Entonces, en cambio, tomamos muestras de una distribución de propuesta y usamos, por ejemplo, Metropolis-Hastings (MH).$q$

Hasta aquí todo bien. Pero aquí hay un camino divergente: ¿qué sucede si, en lugar de usar MH, usamos la misma idea utilizada en el muestreo de importancia, es decir, tomamos muestras de y mantenemos un peso de importancia p / q de la muestra actual?$q$$p/q$

Más detalladamente: supongamos que tenemos variables $x_1,\dots,x_n$ y una distribución factorizada $\phi_1,\dots,\phi_m$ para que $p \propto \prod_{i=1}^m \phi_i$ . Mantenemos la probabilidad de propuesta $q_i$ utilizada para muestrear el valor actual de cada variable $x_i$ . En cada paso cambiamos un subconjunto de las variables y actualizamos $p(x)/q(x)$ (solo los factores de $p$ y $q$ que están afectados). Tomamos las muestras y su peso de importancia para calcular cualquier estadística que nos interese.

¿Sería correcto este algoritmo? Si no, ¿alguna razón clara por qué no? Intuitivamente tiene sentido para mí, ya que parece estar haciendo lo mismo que hace el muestreo importante, pero en cambio con muestras dependientes.

Implementé esto para un modelo de caminata aleatoria gaussiana y observé que los pesos se hacen cada vez más pequeños (pero no monotónicamente), por lo que las muestras iniciales terminan teniendo demasiada importancia y dominan la estadística. Estoy bastante seguro de que la implementación no tiene errores, porque en cada paso comparo el peso actualizado con un cálculo explícito de la fuerza bruta del mismo. Tenga en cuenta que los pesos no bajan indefinidamente a cero, porque son donde y son productos de un número finito de densidades, y cada muestra se obtiene de una distribución Normal que rara vez será cero.$p/q$$p$$q$

Así que estoy tratando de entender por qué los pesos bajan así, y si esto es una consecuencia de que este método no sea realmente correcto.

---

Aquí hay una definición más precisa del algoritmo, aplicada a una caminata aleatoria gaussiana en las variables . El código sigue a continuación.$X_1,\dots,X_n$

El modelo es simplemente , con fijado en .$X_i \sim \mathcal N(X_{i-1}, \sigma^2), i = 1,\dots,n$$X_0$$0$

El peso de la muestra actual es , donde son las densidades gaussianas son las distribuciones a partir de las cuales se han muestreado los valores actuales. Inicialmente, simplemente muestreamos los valores de manera directa, por lo que y el peso inicial es .$\frac{\prod_i p(x_i)}{\prod_i q(x_i)}$$p$$q$$q = p$$1$

Luego, en cada paso, elijo para cambiar. un nuevo valor para de , por lo que esta densidad se convierte en la nueva distribución propuesta propuesta para .$j \in \{1,\dots,n\}$$x'_j$$X_j$$\mathcal N(X_{j-1},\sigma^2)$$X_j$

Para actualizar el peso, lo por las densidades y del valor anterior acuerdo con y , y multiplique por las densidades y del nuevo valor acuerdo con y . Esto actualiza el numerador del peso.$p(x_j | x_{j-1})$$p(x_{j+1} | x_j)$$x_j$$x_{j-1}$$x_{j+1}$$p(x'_j | x_{j-1})$$p(x_{j+1} | x'_j)$$x'_j$$x_{j-1}$$x_{j+1}$$p$

Para actualizar el denominador , multiplico el peso por la antigua propuesta (eliminándolo así del denominador) y lo por .$q$$q(x_j)$$q(x'_j)$

(Debido a que de la normal centrada en , siempre es igual a por lo que se cancelan y la implementación lo hace en realidad no los uso).$x'_j$$x_{j-1}$$q(x'_j)$$p(x'_j | x_{j-1})$

Como mencioné antes, en el código comparo este cálculo de peso incremental con el cálculo explícito real solo para estar seguro.

---

Aquí está el código de referencia.

println("Original sample: " + currentSample);
int flippedVariablesIndex = 1 + getRandom().nextInt(getVariables().size() - 1);
println("Flipping: " + flippedVariablesIndex);
double oldValue = getValue(currentSample, flippedVariablesIndex);
NormalDistribution normalFromBack = getNormalDistribution(getValue(currentSample, flippedVariablesIndex - 1));
double previousP = normalFromBack.density(oldValue);
double newValue = normalFromBack.sample();
currentSample.set(getVariable(flippedVariablesIndex), newValue);
double previousQ = fromVariableToQ.get(getVariable(flippedVariablesIndex));
fromVariableToQ.put(getVariable(flippedVariablesIndex), normalFromBack.density(newValue));
if (flippedVariablesIndex < length - 1) {
    NormalDistribution normal = getNormalDistribution(getValue(currentSample, flippedVariablesIndex + 1));
    double oldForwardPotential = normal.density(oldValue);
    double newForwardPotential = normal.density(newValue);
    // println("Removing old forward potential " + oldForwardPotential);
    currentSample.removePotential(new DoublePotential(oldForwardPotential));
    // println("Multiplying new forward potential " + newForwardPotential);
    currentSample.updatePotential(new DoublePotential(newForwardPotential));
}

// println("Removing old backward potential " + previousP);
currentSample.removePotential(new DoublePotential(previousP));
// println("Multiplying (removing from divisor) old q " + previousQ);
currentSample.updatePotential(new DoublePotential(previousQ));

println("Final sample: " + currentSample);
println();

// check by comparison to brute force calculation of weight:
double productOfPs = 1.0;
for (int i = 1; i != length; i++) {
    productOfPs *= getNormalDistribution(getValue(currentSample, i - 1)).density(getValue(currentSample, i));
}
double productOfQs = Util.fold(fromVariableToQ.values(), (p1, p2) -> p1*p2, 1.0);
double weight = productOfPs/productOfQs;
if (Math.abs(weight - currentSample.getPotential().doubleValue()) > 0.0000001) {
    println("Error in weight calculation");
    System.exit(0);
}

Esta es una idea interesante, pero veo varias dificultades con ella:

1. Contrariamente al muestreo de importancia estándar, o incluso al muestreo de importancia metropolitana, la propuesta no está actuando en el mismo espacio que la distribución objetivo, sino en un espacio de menor dimensión, por lo que la validación no está clara [y puede imponer mantener pesos en las iteraciones, por lo tanto, enfrenta la degeneración]
2. las constantes de normalización que faltan en los condicionales completos cambian en cada iteración pero no se tienen en cuenta [ver más abajo]
3. los pesos no están delimitados, ya que a lo largo de las iteraciones, eventualmente habrá simulaciones con un peso muy grande, a menos que uno haga un seguimiento de la última aparición de una actualización para el mismo índice , que puede chocar con la validación de Markovian de la muestra de Gibbs . Ejecutar un experimento modesto con y iteraciones muestra un rango de pesos desde hasta .$j$$n=2$$T=10^3$7.656397e-073.699364e+04

Para obtener más detalles, considere un objetivo bidimensional , incluida la constante de normalización adecuada, e implemente la muestra de Gibbs importante con las propuestas y . Los pesos correctos de importancia [en el sentido de producir la expectativa correcta, es decir, un estimador imparcial, para una función arbitraria de ] para simulaciones sucesivas son donde y son los marginales de . O equivalente $p(\cdot,\cdot)$$q_X(\cdot|y)$$q_Y(\cdot|x)$$(X,Y)$

$$\dfrac{p(x_t,y_{t-1})}{q_X(x_t|y_{t-1})m_Y(y_{t-1})}\qquad\text{or}\qquad\dfrac{p(x_{t-1},y_{t})}{q_Y(y_t|x_{t-1})m_X(x_{t-1})}$$ $m_X(\cdots)$$m_Y(\cdot)$$p(\cdot,\cdot)$ $$\dfrac{p_X(x_t|y_{t-1})}{q_X(x_t|y_{t-1})}\qquad\text{or}\qquad\dfrac{p_Y(y_{t}|x_{t-1})}{q_Y(y_t|x_{t-1})}$$ En cualquier caso, esto requiere las densidades marginales [intratables] de e debajo del objetivo .$X$$Y$$p(\cdot,\cdot)$

Vale la pena comparar lo que sucede aquí con el algoritmo de Metropolis ponderado de importancia paralela . (Ver, por ejemplo, Schuster und Klebanov, 2018. ) Si el objetivo es nuevamente y la propuesta es , la importancia pesa es correcto [para producir una estimación imparcial] y no actualiza el peso anterior, sino que comienza desde cero en cada iteración.$p(\cdot,\cdot)$$q(\cdot,\cdot|x,y)$

$$\dfrac{p(x',y')}{q(x',y'|x,y)}$$

(C.) Una corrección a la importancia original de la propuesta de Gibbs es proponer un nuevo valor para todo el vector, por ejemplo, , a partir de la propuesta de Gibbs , porque entonces el peso de importancia es correcto [falta una posible normalización constante que ahora es realmente constante y no lleva de iteraciones anteriores de Gibbs] .$(x,y)$$q_X(x_t|y_{t-1})q_Y(y_t|x_{t})$

$$\dfrac{p(x_t,y_t)}{q_X(x_t|y_{t-1})q_Y(y_t|x_{t})}$$

Una nota final: para el objetivo de caminata aleatorio considerado en el código, la simulación directa es factible en cascada: simule , luego dado , & tc.$X_1$$X_2$$X_1$