Ağırlıklı rastgele sayılar

Ağırlıklı rastgele sayılar uygulamaya çalışıyorum. Şu anda kafamı duvara vuruyorum ve bunu çözemiyorum.

Projemde (Hold'em el aralıkları, öznel hepsi bir arada öz sermaye analizi), Boost'un rastgele işlevlerini kullanıyorum. Diyelim ki 1 ile 3 arasında rastgele bir sayı seçmek istiyorum (yani 1, 2 veya 3). Boost'un mersenne twister jeneratörü bunun için bir cazibe gibi çalışıyor. Ancak, örneğin şu şekilde ağırlıklandırılmasını istiyorum:

1 (weight: 90)
2 (weight: 56)
3 (weight:  4)

Boost'un bunun için bir çeşit işlevselliği var mı?

Öğelerin ayrı ağırlıklara sahip olduğu rastgele bir öğeyi seçmek için basit bir algoritma vardır:

1) tüm ağırlıkların toplamını hesaplayın

2) 0 veya daha büyük olan ve ağırlıkların toplamından daha küçük olan rastgele bir sayı seçin

3) rastgele sayının o öğenin ağırlığından daha az olduğu öğeyi elde edene kadar, ağırlıklarını rastgele sayınızdan çıkararak öğeleri birer birer gözden geçirin.

Bunu gösteren sözde kod:

int sum_of_weight = 0;
for(int i=0; i<num_choices; i++) {
   sum_of_weight += choice_weight[i];
}
int rnd = random(sum_of_weight);
for(int i=0; i<num_choices; i++) {
  if(rnd < choice_weight[i])
    return i;
  rnd -= choice_weight[i];
}
assert(!"should never get here");

Bu, destek kaplarınıza ve benzerlerine uyum sağlamak için basit olmalıdır.

Ağırlıklarınız nadiren değiştiriliyorsa ancak sık sık rastgele bir ağırlık seçiyorsanız ve konteynırınız nesnelere işaretçileri depoladığı veya birkaç düzineden fazla öğe uzunluğunda olduğu sürece (temel olarak, bunun yardımcı olup olmadığını veya engelleyeceğini bilmek için profil yapmanız gerekir) , sonra bir optimizasyon var:

Her bir öğedeki kümülatif ağırlık toplamını depolayarak , toplama ağırlığına karşılık gelen öğeyi seçmek için bir ikili arama kullanabilirsiniz .

Listedeki öğelerin sayısını bilmiyorsanız, ağırlıklı olarak uyarlanabilen rezervuar örnekleme adı verilen çok düzgün bir algoritma vardır .

Eski bir soruya verilen cevap güncellendi. Bunu C ++ 11'de sadece std :: lib ile kolayca yapabilirsiniz:

#include <iostream>
#include <random>
#include <iterator>
#include <ctime>
#include <type_traits>
#include <cassert>

int main()
{
    // Set up distribution
    double interval[] = {1,   2,   3,   4};
    double weights[] =  {  .90, .56, .04};
    std::piecewise_constant_distribution<> dist(std::begin(interval),
                                                std::end(interval),
                                                std::begin(weights));
    // Choose generator
    std::mt19937 gen(std::time(0));  // seed as wanted
    // Demonstrate with N randomly generated numbers
    const unsigned N = 1000000;
    // Collect number of times each random number is generated
    double avg[std::extent<decltype(weights)>::value] = {0};
    for (unsigned i = 0; i < N; ++i)
    {
        // Generate random number using gen, distributed according to dist
        unsigned r = static_cast<unsigned>(dist(gen));
        // Sanity check
        assert(interval[0] <= r && r <= *(std::end(interval)-2));
        // Save r for statistical test of distribution
        avg[r - 1]++;
    }
    // Compute averages for distribution
    for (double* i = std::begin(avg); i < std::end(avg); ++i)
        *i /= N;
    // Display distribution
    for (unsigned i = 1; i <= std::extent<decltype(avg)>::value; ++i)
        std::cout << "avg[" << i << "] = " << avg[i-1] << '\n';
}

Sistemimdeki çıktı:

avg[1] = 0.600115
avg[2] = 0.373341
avg[3] = 0.026544

Yukarıdaki kodun çoğunun yalnızca çıktıyı görüntülemeye ve analiz etmeye ayrıldığını unutmayın. Gerçek nesil, sadece birkaç satır koddur. Çıktı, istenen "olasılıkların" elde edildiğini gösterir. İstenilen çıktıyı 1.5'e bölmeniz gerekir, çünkü isteklerin toplamı budur.

Ağırlıklarınız çizildiğinden daha yavaş değişiyorsa, C ++ 11 discrete_distributionen kolayı olacaktır:

#include <random>
#include <vector>
std::vector<double> weights{90,56,4};
std::discrete_distribution<int> dist(std::begin(weights), std::end(weights));
std::mt19937 gen;
gen.seed(time(0));//if you want different results from different runs
int N = 100000;
std::vector<int> samples(N);
for(auto & i: samples)
    i = dist(gen);
//do something with your samples...

Bununla birlikte, c ++ 11'in discrete_distributionbaşlatma sırasında tüm kümülatif toplamları hesapladığını unutmayın. Genellikle bunu istersiniz çünkü örnekleme süresini bir kerelik O (N) maliyeti için hızlandırır. Ancak hızla değişen bir dağıtım için ağır bir hesaplama (ve hafıza) maliyetine yol açacaktır. Örneğin, ağırlıklar kaç tane öğe olduğunu gösteriyorsa ve her bir tane çizdiğinizde onu kaldırırsanız, muhtemelen özel bir algoritma isteyeceksiniz.

Will'in cevabı https://stackoverflow.com/a/1761646/837451 bu ek yükten kaçınır, ancak ikili aramayı kullanamadığı için C ++ 11'den daha yavaş çekilir.

Bunu yaptığını görmek için ilgili satırları görebilirsiniz ( /usr/include/c++/5/bits/random.tccUbuntu 16.04 + GCC 5.3 kurulumumda):

  template<typename _IntType>
    void
    discrete_distribution<_IntType>::param_type::
    _M_initialize()
    {
      if (_M_prob.size() < 2)
        {
          _M_prob.clear();
          return;
        }

      const double __sum = std::accumulate(_M_prob.begin(),
                                           _M_prob.end(), 0.0);
      // Now normalize the probabilites.
      __detail::__normalize(_M_prob.begin(), _M_prob.end(), _M_prob.begin(),
                            __sum);
      // Accumulate partial sums.
      _M_cp.reserve(_M_prob.size());
      std::partial_sum(_M_prob.begin(), _M_prob.end(),
                       std::back_inserter(_M_cp));
      // Make sure the last cumulative probability is one.
      _M_cp[_M_cp.size() - 1] = 1.0;
    }

Sayıları ağırlıklandırmam gerektiğinde yaptığım şey, ağırlık için rastgele bir sayı kullanmaktır.

Örneğin: 1'den 3'e kadar aşağıdaki ağırlıklarla rastgele sayılar oluşturmam gerekiyor:

• Rastgele bir sayının% 10'u 1 olabilir
• Rastgele bir sayının% 30'u 2 olabilir
• Rastgele bir sayının% 60'ı 3 olabilir

Sonra kullanırım:

weight = rand() % 10;

switch( weight ) {

    case 0:
        randomNumber = 1;
        break;
    case 1:
    case 2:
    case 3:
        randomNumber = 2;
        break;
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
        randomNumber = 3;
        break;
}

Bununla rastgele olarak olasılıkların% 10'u 1,% 30'u 2 ve% 60'ı 3'e sahiptir.

İhtiyaçlarınız olarak onunla oynayabilirsiniz.

Umarım sana yardım edebilirim, İyi Şanslar!

Seçilebilecek tüm öğelerden bir çanta (veya std :: vektör) oluşturun.
Her bir öğenin sayısının ağırlığınızla orantılı olduğundan emin olun.

Misal:

• 1% 60
• 2% 35
• 3% 5

Öyleyse 60 1, 35 2 ve 53'lü 100 parçalık bir çantanız olsun.
Şimdi çantayı rastgele sıralayın (std :: random_shuffle)

Boş olana kadar çantadan öğeleri sırayla seçin.
Boşaldığında çantayı yeniden rastgele seçin ve yeniden başlayın.

Yükseltme RNG'si için varsayılan işleç () olması gereken [0,1) üzerinde rastgele bir sayı seçin. Kümülatif olasılık yoğunluğu işlevine sahip öğeyi seçin> = bu sayı:

template <class It,class P>
It choose_p(It begin,It end,P const& p)
{
    if (begin==end) return end;
    double sum=0.;
    for (It i=begin;i!=end;++i)
        sum+=p(*i);
    double choice=sum*random01();
    for (It i=begin;;) {
        choice -= p(*i);
        It r=i;
        ++i;
        if (choice<0 || i==end) return r;
    }
    return begin; //unreachable
}

Random01 () bir çift> = 0 ve <1 döndürür. Yukarıdakilerin olasılıkların toplamının 1 olmasını gerektirmediğini unutmayın; onları sizin için normalleştirir.

p, koleksiyondaki bir öğeye [başlama, bitiş) olasılık atayan bir işlevdir. Sadece bir olasılıklar dizisine sahipseniz, onu atlayabilirsiniz (veya bir kimlik kullanabilirsiniz).

Birkaç basit ağırlıklı rastgele algoritma uyguladım .