计算函数合理性的算法/蒙特卡罗方法

我正在编写一个程序，试图复制本文开头讨论的算法，

http://www-stat.stanford.edu/cgates/PERSI/论文/MCMCRev.pdf

F是一个从char到char的函数。假设Pl(f)是该函数的"合理性"度量。算法为:

从对函数的初步猜测开始，比如f，然后是一个新的函数f*——

• 计算Pl (f)。
• 将f赋给两个符号的值随机调换为f*。
• 计算Pl (f *);如果该值大于Pl(f)，则接受f*.
• 如果没有，抛一个Pl(f)/Pl(f*)硬币;如果出现正面，接受f*.
• 如果抛硬币是反面，保持在f。

我使用下面的代码实现它。我正在使用c#，但试图使它对每个人都更简化。如果有更好的论坛，请让我知道。

 var current_f = Initial();    // current accepted function f
 var current_Pl_f = InitialPl();  // current plausibility of accepted function f
 for (int i = 0; i < 10000; i++)
        {
            var candidate_f = Transpose(current_f); // create a candidate function
            var candidate_Pl_f = ComputePl(candidate_f);  // compute its plausibility
            if (candidate_Pl_f > current_Pl_f)            // candidate Pl has improved
            {
                current_f = candidate_f;            // accept the candidate
                current_Pl_f = candidate_Pl_f; 
            }
            else                                    // otherwise flip a coin
            {
                int flip = Flip(); 
                if (flip == 1)                      // heads
                {
                    current_f = candidate_f;        // accept it anyway
                    current_Pl_f = candidate_Pl_f; 
                }
                else if (flip == 0)                 // tails
                {
                    // what to do here ?
                }
            }
        }

我的问题基本上是这看起来是不是实现该算法的最佳方法。似乎我可能会陷入一些局部最大值/局部最小值，尽管实施这种方法。

EDIT -这是转置()方法背后的本质。我使用类型为<<的字典/哈希表。Char, Char>>，候选函数用来查找任何给定的Char -> Char转换。所以转置方法只是交换字典中指示函数行为的两个值。

    private Dictionary<char, char> Transpose(Dictionary<char, char> map, params int[] indices)
    {
        foreach (var index in indices)
        {
            char target_val = map.ElementAt(index).Value;   // get the value at the index
            char target_key = map.ElementAt(index).Key;     // get the key at the index
            int _rand = _random.Next(map.Count);   // get a random key (char) to swap with
            char rand_key = map.ElementAt(_rand).Key;
            char source_val = map[rand_key]; // the value that currently is used by the source of the swap
            map[target_key] = source_val; // make the swap
            map[rand_key] = target_val;
        }
        return map; 
    }

请记住，使用底层字典的候选函数基本上只是:

public char GetChar(char in, Dictionary<char, char> theMap)
{
     return theMap[char]; 
}

这是计算Pl(f)的函数:

    public decimal ComputePl(Func<char, char> candidate, string encrypted, decimal[][] _matrix)
    {
        decimal product = default(decimal);
        for (int i = 0; i < encrypted.Length; i++)
        {
            int j = i + 1;
            if (j >= encrypted.Length)
            {
                break;
            }
            char a = candidate(encrypted[i]);
            char b = candidate(encrypted[j]);
            int _a = GetIndex(_alphabet, a); // _alphabet is just a string/char[] of all avl chars 
            int _b = GetIndex(_alphabet, b);
            decimal _freq = _matrix[_a][_b]; 
            if (product == default(decimal))
            {
                product = _freq;
            }
            else
            {
                product = product * _freq;
            }
        }
        return product;
    }

var current_f = Initial();    // current accepted function f
var current_Pl_f = ComputePl(current_f);  // current plausibility of accepted function f
for (int i = 0; i < 10000; i++)
{
    var candidate_f = Transpose(current_f); // create a candidate function
    var candidate_Pl_f = ComputePl(candidate_f);  // compute its plausibility
    if (candidate_Pl_f > current_Pl_f  ||  Flip() == 1)
    {
        // either candidate Pl has improved,
        // or it hasn't and we flipped the coin in candidate's favor
        //  - accept the candidate
        current_f = candidate_f;            
        current_Pl_f = candidate_Pl_f; 
    }
}