如何在 C++ 中有效地生成排序均匀分布的随机数？

Question

我想在 C++ 中生成大量排序和均匀分布的随机数n （即n >= 1,000,000,000 ）。

我考虑的第一个简单的方法是

1. 使用std::uniform_real_distribution<double>顺序生成n均匀分布的数字，
2. 然后使用std::sort对它们进行排序。

但是，这需要几分钟。

第二种更复杂的方法是并行化这两个步骤，如下所示：

template <typename T>
void computeUniformDistribution(std::vector<T>& elements)
{
    #pragma omp parallel
    {
        std::seed_seq seed{distribution_seed, static_cast<size_t>(omp_get_thread_num())};
        std::mt19937 prng = std::mt19937(seed);
        std::uniform_real_distribution<double> uniform_dist(0, std::numeric_limits<T>::max());

        #pragma omp for
        for (size_t i = 0; i < elements.size(); ++i)
        {
            elements[i] = static_cast<T>(uniform_dist(prng));
        }
    }

    std::sort(std::execution::par_unseq, elements.begin(), elements.end());
}

然而，即使这样也需要大约30秒。 鉴于均匀分布数的生成只需要大约1.5秒，瓶颈仍然是排序阶段。

因此，我想问以下问题：如何以排序的方式有效地生成均匀分布的数据？

Answer 1

有一些方法可以生成已经排序的样本，但我认为生成部分排序的样本可能会更好。

将 output 范围划分为 k 个等宽的桶。 每个桶中的样本数将具有等概率的多项分布。 对多项分布进行采样的慢速方法是在 [0, k) 中生成 n 个整数。 一种更有效的方法是抽取 k 个泊松样本，其速率为 n/k，条件是它们的总和不超过 n，然后使用慢速方式添加另一个 n-sum 样本。 完美地对泊松分布进行采样是很棘手的，但是当 n/k 非常大时（就像这里一样），泊松分布可以通过对具有均值和方差 n/k 的正态分布进行四舍五入来很好地逼近。 如果这是不可接受的，那么慢速方法确实可以很好地并行化。

给定存储桶计数，计算前缀总和以找到存储桶边界。 对于并行的每个桶，在桶范围内生成给定数量的样本并对其进行排序。 如果我们选择好 n/k，每个桶几乎肯定会适合 L1 缓存。 对于 n = 1e9，我想我会尝试 k = 1e5 或 k = 1e6。

这是一个顺序实现。 有点粗糙，因为我们确实需要避免对封闭的桶边界进行 2 倍过采样，但我会把它留给你。 我不熟悉 OMP，但我认为您可以通过在SortedUniformSamples末尾的 for 循环中添加一个编译指示来获得一个非常好的并行实现。

#include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <random>
#include <span>
#include <vector>

template <typename Dist, typename Gen>
void SortedSamples(std::span<double> samples, Dist dist, Gen& gen) {
  for (double& sample : samples) {
    sample = dist(gen);
  }
  std::sort(samples.begin(), samples.end());
}

template <typename Gen>
void ApproxMultinomialSample(std::span<std::size_t> samples, std::size_t n,
                             Gen& gen) {
  double lambda = static_cast<double>(n) / samples.size();
  std::normal_distribution<double> approx_poisson{lambda, std::sqrt(lambda)};
  std::size_t sum;
  do {
    for (std::size_t& sample : samples) {
      sample = std::lrint(approx_poisson(gen));
    }
    sum = std::accumulate(samples.begin(), samples.end(), std::size_t{0});
  } while (sum > n);
  std::uniform_int_distribution<std::size_t> uniform{0, samples.size() - 1};
  for (; sum < n; sum++) {
    samples[uniform(gen)]++;
  }
}

template <typename Gen>
void SortedUniformSamples(std::span<double> samples, Gen& gen) {
  static constexpr std::size_t kTargetBucketSize = 1024;
  if (samples.size() < kTargetBucketSize) {
    SortedSamples(samples, std::uniform_real_distribution<double>{0, 1}, gen);
    return;
  }
  std::size_t num_buckets = samples.size() / kTargetBucketSize;
  std::vector<std::size_t> bucket_counts(num_buckets);
  ApproxMultinomialSample(bucket_counts, samples.size(), gen);
  std::vector<std::size_t> prefix_sums(num_buckets + 1);
  std::partial_sum(bucket_counts.begin(), bucket_counts.end(),
                   ++prefix_sums.begin());
  for (std::size_t i = 0; i < num_buckets; i++) {
    SortedSamples(std::span<double>{&samples[prefix_sums[i]],
                                    &samples[prefix_sums[i + 1]]},
                  std::uniform_real_distribution<double>{
                      static_cast<double>(i) / num_buckets,
                      static_cast<double>(i + 1) / num_buckets},
                  gen);
  }
}

int main() {
  std::vector<double> samples(100000000);
  std::default_random_engine gen;
  SortedUniformSamples(samples, gen);
  if (std::is_sorted(samples.begin(), samples.end())) {
    std::cout << "sorted\n";
  }
}

如果你的标准库有一个高质量的poisson_distribution实现，你也可以这样做：

template <typename Gen>
void MultinomialSample(std::span<std::size_t> samples, std::size_t n,
                       Gen& gen) {
  double lambda = static_cast<double>(n) / samples.size();
  std::poisson_distribution<std::size_t> poisson{lambda};
  std::size_t sum;
  do {
    for (std::size_t& sample : samples) {
      sample = poisson(gen);
    }
    sum = std::accumulate(samples.begin(), samples.end(), std::size_t{0});
  } while (sum > n);
  std::uniform_int_distribution<std::size_t> uniform{0, samples.size() - 1};
  for (; sum < n; sum++) {
    samples[uniform(gen)]++;
  }
}

Answer 2

我很想依赖这样一个事实，即一组排序的均匀分布变量的连续元素之间的差异呈指数分布。 这可以被利用在O(N)时间内运行，而不是O(N*log N) 。

快速实现会执行以下操作：

template<typename T> void
computeSorteUniform2(std::vector<T>& elements)
{
    std::random_device rd;
    std::mt19937 prng(rd());

    std::exponential_distribution<T> dist(static_cast<T>(1));

    auto sum = dist(prng);

    for (auto& elem : elements) {
        elem = sum += dist(prng);
    }

    sum += dist(prng);

    for (auto& elem : elements) {
        elem /= sum;
    }
}

通过假设您需要 Uniform(0, 1) 中的值来简化此示例，但它应该很容易概括。 使用 OMP 完成这项工作并不是很简单，但应该不会太难。

如果您关心最后约 50% 的性能，那么有一些数值技巧可能会加速生成随机偏差（例如，有比 MT 更快更好的 PRNG）以及将它们转换为double s（但最近的编译器可能知道这些技巧）。 一些参考资料： Daniel Lemire 的博客和Melissa O'Neill 的 PCG 网站。

我刚刚对此进行了基准测试，发现 clang 的std::uniform_real_distribution和std::exponential_distribution都非常慢。 numpy基于 Ziggurat 的实现快 8 倍，因此我可以使用上述算法在笔记本电脑上使用单线程在 ~10 秒内生成 1e9 double （即std实现需要 ~80 秒）。 我没有在 1e9 元素上尝试过 OP 的实现，但是对于 1e8 元素，我的速度要快约 15 倍。

Answer 3

我进行了一些测试，基数排序的速度是 std::sort 的 4 到 6 倍，具体取决于系统，但它需要第二个向量，对于 1 GB 的元素，每个双精度向量为 8 GB，总共16 GB 的可用 memory，因此您可能需要 32 GB 的 RAM。

如果排序不受 memory 带宽限制，则多线程基数排序可能会有所帮助。

单线程代码示例：

#include <algorithm>
#include <iostream>
#include <random>
#include <vector>
#include <time.h>

clock_t ctTimeStart;            // clock values
clock_t ctTimeStop;

typedef unsigned long long uint64_t;

//  a is input array, b is working array
uint64_t * RadixSort(uint64_t * a, uint64_t *b, size_t count)
{
uint32_t mIndex[8][256] = {0};          // count / index matrix
uint32_t i,j,m,n;
uint64_t u;
    for(i = 0; i < count; i++){         // generate histograms
        u = a[i];
        for(j = 0; j < 8; j++){
            mIndex[j][(size_t)(u & 0xff)]++;
            u >>= 8;
        }
    }
    for(j = 0; j < 8; j++){             // convert to indices
        m = 0;
        for(i = 0; i < 256; i++){
            n = mIndex[j][i];
            mIndex[j][i] = m;
            m += n;
        }
    }
    for(j = 0; j < 8; j++){             // radix sort
        for(i = 0; i < count; i++){     //  sort by current LSB
            u = a[i];
            m = (size_t)(u>>(j<<3))&0xff;
            b[mIndex[j][m]++] = u;
        }
        std::swap(a, b);                //  swap ptrs
    }
    return(a);
}

#define COUNT (1024*1024*1024)

int main(int argc, char**argv)
{
    std::vector<double> v(COUNT);       // vctr to be generated
    std::vector<double> t(COUNT);       // temp vector
    std::random_device rd;
    std::mt19937 gen(rd());
//  std::uniform_real_distribution<> dis(0, std::numeric_limits<double>::max());
    std::uniform_real_distribution<> dis(0, COUNT);
    ctTimeStart = clock();
    for(size_t i = 0; i < v.size(); i++)
        v[i] = dis(gen);
    ctTimeStop = clock();
    std::cout << "# of ticks " << ctTimeStop - ctTimeStart << std::endl;
    ctTimeStart = clock();
//  std::sort(v.begin(), v.end());
    RadixSort((uint64_t *)&v[0], (uint64_t *)&t[0], COUNT);
    ctTimeStop = clock();
    std::cout << "# of ticks " << ctTimeStop - ctTimeStart << std::endl;
    return(0);
}

---

如果对包含负值的双精度数（转换为 64 位无符号整数）进行排序，则需要将它们视为符号 + 幅度 64 位整数。 C++ 宏用于将符号 + 幅度 (SM) 与 64 位无符号整数 (ULL) 相互转换：

// converting doubles to unsigned long long for radix sort or something similar
// note -0 converted to 0x7fffffffffffffff, +0 converted to 0x8000000000000000
// -0 is unlikely to be produced by a float operation

#define SM2ULL(x) ((x)^(((~(x) >> 63)-1) | 0x8000000000000000ull))
#define ULL2SM(x) ((x)^((( (x) >> 63)-1) | 0x8000000000000000ull))

Answer 4

有一个简单的观察，涉及 [0, 1] 中的有序均匀随机数：

1. 每个统一的 [0, 1] 数同样可能小于一半或大于一半。 因此，小于一半与大于一半的均匀 [0, 1] 数的数量遵循二项式 (n, 1/2) 分布。
2. 在小于一半的数字中，每个数字都可能小于 1/4 和大于 1/4，因此小于 1/4 与大于 1/4 的数字遵循相同的分布。
3. 等等。

因此，每个数字可以一次生成一位，在二进制点之后从左到右。 这是如何生成n 个排序的均匀随机数的草图：

1. 如果n为 0 或 1，则停止。 否则，生成b ，一个二项式 ( n , 1/2) 随机数。
2. Append 0 到前b个随机数，1 到 rest。
3. 在前b个数字上递归运行此算法，但使用n = b 。
4. 在数字的 rest 上递归地运行此算法，但n = n - b 。

在这一点上，我们有一个具有不同位数的随机数的排序列表。 剩下要做的就是根据需要用统一的随机位填充每个数字（或砍掉或舍入多余的位）以给出数字p位（例如，53 位用于双精度）。 然后，将每个数字除以 2 ^p 。

我给出了一个类似的算法来找到n 个随机数中的第k个最小的。