Une méthode d'échantillonnage «d'importance Gibbs» fonctionnerait-elle?

Je soupçonne que c'est une question assez inhabituelle et exploratoire, alors soyez indulgent avec moi.

Je me demande si l'on pourrait appliquer l'idée de l'échantillonnage d'importance à l'échantillonnage de Gibbs. Voici ce que je veux dire: dans l'échantillonnage de Gibbs, nous modifions la valeur d'une variable (ou d'un bloc de variables) à la fois, en échantillonnant à partir de la probabilité conditionnelle étant donné les variables restantes.

Cependant, il peut ne pas être possible ou facile d'échantillonner à partir de la probabilité conditionnelle exacte. Au lieu de cela, nous échantillonnons à partir d'une distribution de proposition et utilisons, par exemple, Metropolis-Hastings (MH).$q$

Jusqu'ici tout va bien. Mais voici une voie divergente: que se passe-t-il si nous, au lieu d'utiliser MH, utilisons la même idée utilisée dans l'échantillonnage d'importance, à savoir que nous échantillonnons à partir de et gardons un poids d'importance de l'échantillon actuel?$q$$p/q$

Plus en détail: supposons que nous ayons des variables et une distribution factorisée sorte que . Nous conservons la probabilité de proposition utilisée pour échantillonner la valeur actuelle de chaque variable . À chaque étape, nous modifions un sous-ensemble des variables et mettons à jour (seuls les facteurs de et qui sont affectés). Nous prenons les échantillons et leur poids d'importance pour calculer les statistiques qui nous intéressent.$x_1,\dots,x_n$$\phi_1,\dots,\phi_m$$p \propto \prod_{i=1}^m \phi_i$$q_i$$x_i$$p(x)/q(x)$$p$$q$

Cet algorithme serait-il correct? Si non, des raisons claires pourquoi? Intuitivement, cela a du sens pour moi car il semble faire la même chose que l'échantillonnage d'importance, mais avec des échantillons dépendants à la place.

J'ai mis en œuvre cela pour un modèle de marche aléatoire gaussien et j'ai observé que les poids deviennent de plus en plus petits (mais pas monotones), de sorte que les échantillons initiaux finissent par avoir trop d'importance et dominent la statistique. Je suis assez certain que l'implémentation n'est pas boguée, car à chaque étape, je compare le poids mis à jour à un calcul explicite en force brute de celui-ci. Notez que les poids ne descendent pas indéfiniment à zéro, car ils sont où et sont tous deux des produits d'un nombre fini de densités, et chaque échantillon est obtenu à partir d'une distribution normale qui ne sera que rarement nulle.$p/q$$p$$q$

J'essaie donc de comprendre pourquoi les poids baissent comme ça, et si c'est une conséquence du fait que cette méthode n'est pas correcte.

Voici une définition plus précise de l'algorithme, appliqué à une marche aléatoire gaussienne sur les variables . Le code suit ci-dessous.$X_1,\dots,X_n$

Le modèle est simplement , avec fixé à .$X_i \sim \mathcal N(X_{i-1}, \sigma^2), i = 1,\dots,n$$X_0$$0$

Le poids de l'échantillon actuel est , où sont les densités gaussiennes et sont les distributions à partir desquelles les valeurs actuelles ont été échantillonnées. Initialement, nous échantillonnons simplement les valeurs de manière directe, donc et le poids initial est .$\frac{\prod_i p(x_i)}{\prod_i q(x_i)}$$p$$q$$q = p$$1$

Ensuite, à chaque étape, je choisis pour changer. une nouvelle valeur pour partir de , donc cette densité devient la nouvelle distribution de proposition utilisée pour .$j \in \{1,\dots,n\}$$x'_j$$X_j$$\mathcal N(X_{j-1},\sigma^2)$$X_j$

Pour mettre à jour le poids, je le divise par les densités et de l'ancienne valeur selon et , et multipliez par les densités et de nouvelle valeur selon et . Cela met à jour le numérateur du poids.$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$

Pour mettre à jour le dénominateur , je multiplie le poids par l'ancienne proposition (le supprimant ainsi du dénominateur) et je le divise par .$q$$q(x_j)$$q(x'_j)$

(Parce que partir de la normale centrée sur , est toujours égal à donc ils annulent et l'implémentation ne pas vraiment les utiliser).$x'_j$$x_{j-1}$$q(x'_j)$$p(x'_j | x_{j-1})$

Comme je l'ai mentionné précédemment, dans le code, je compare ce calcul de poids incrémentiel au calcul explicite réel juste pour être sûr.

Voici le code de référence.

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);
}

C'est une idée intéressante, mais j'y vois plusieurs difficultés:

1. contrairement à l'échantillonnage d'importance standard, ou même à l'échantillonnage d'importance métropolisée, la proposition n'agit pas dans le même espace que la distribution cible, mais dans un espace de plus petite dimension, de sorte que la validation n'est pas claire [et peut imposer de maintenir les pondérations entre les itérations, ce qui fait face à la dégénérescence]
2. les constantes de normalisation manquantes dans les conditionnelles complètes changent à chaque itération mais ne sont pas prises en compte [voir ci-dessous]
3. les poids ne sont pas limités, en ce sens que le long des itérations, il y aura éventuellement des simulations avec un poids très important, à moins que l'on garde une trace de la dernière occurrence d'une mise à jour pour le même indice , ce qui peut entrer en conflit avec la validation markovienne de l'échantillonneur Gibbs . L'exécution d'une expérience modeste avec et itérations montre une gamme de poids de à .$j$$n=2$$T=10^3$7.656397e-073.699364e+04

Pour entrer dans les détails, considérons une cible bidimensionnelle , y compris la constante de normalisation appropriée, et implémentons l'importance de l'échantillonneur Gibbs avec les propositions et . Les poids d'importance appropriés [dans le sens de produire l'espérance correcte, c'est-à-dire un estimateur sans biais, pour une fonction arbitraire de ] pour les simulations successives sont soit où et sont les marginaux de . Ou équivalent $p(\cdot,\cdot)$$q_X(\cdot|y)$$q_Y(\cdot|x)$$(X,Y)$

Il vaut la peine de comparer ce qui se passe ici avec l' algorithme Metropolis pondéré en parallèle . (Voir par exemple Schuster und Klebanov, 2018. ) Si la cible est à nouveau et que la proposition est , le poids d'importance est correct [pour produire une estimation non biaisée] et ne met pas à jour le poids précédent mais recommence à zéro à chaque itération.$p(\cdot,\cdot)$$q(\cdot,\cdot|x,y)$

(C.) Une correction de l'importance d'origine proposée par Gibbs consiste à proposer une nouvelle valeur pour le vecteur entier, par exemple, , à partir de la proposition de Gibbs , car alors l'importance poids est correcte [manque une éventuelle normalisation constante qui est maintenant vraiment constante et ne porte pas sur les précédentes itérations de Gibbs] .$(x,y)$$q_X(x_t|y_{t-1})q_Y(y_t|x_{t})$

Une dernière note: pour la cible de marche aléatoire considérée dans le code, la simulation directe est réalisable en cascade: simulez , puis étant donné , & tc.$X_1$$X_2$$X_1$