
<Wrap id="introduction">

There are two popular strategies to sample from a dataset in reinforcement learning. The first is uniform sampling, where each data point has the same probability. The second one is prioritised sampling ([Schaul et al., 2015](https://arxiv.org/abs/1511.05952)), where each data point has a different probability of getting sampled e.g. weighted by training error.[^\ref{cit:replay-buffer}]

The aim of this post is to give an outline how to implement these sampling strategies as efficient algorithms.

# Table of Contents

</Wrap>

<Wrap id="uniform-sampling">

# Uniform Distribution

The default strategy in stochastic gradient descent is sampling batches uniformly. All data points have the same probability.

$$
P(x_i) = \frac{1}{n} \; \text{ where $i \in  \{0, 1, \dots, n-1\}$}
$$

Here $x_i$ is a data point from our dataset $\mathcal{D} = \{x_0, x_1, \dots, x_{n-1}\}$.

Our goal here is to sample $k$ items from $\mathcal{D}$. Throughout the post we will be sampling $k$ indices $\{i_0, i_1, \dots, i_{k-1}\}$ that refer to the actual data points.

## With Replacement

Sampling with replacement means you can pick items multiple times. This can easily be accomplished by picking $k$ random integers in the range $[0; n-1]$ using your favorite random number generator.

## Without Replacement

We call it sampling without replacement if items can only be picked **once** per batch.

To get to an algorithm, let's think of a physical analogy first: picking cards. If you were asked to pick $k$ random cards out of a poker deck without replacement, you might come up with the following strategy: 1. Pick a random card out of one stack of cards, 2. Put that card on a different stack, 3. Repeat.

If we replace stacks with arrays in this description, we already have a quite convincing algorithm, although a few details are missing. Here is one way to do it:

Much like with a stack of cards, we keep two arrays. The first array stores the result (_result array_), the second array stores the integers which we can still choose from (_open array_). Initially, there are zero integers in the result array and $n$ integers in the open array. On each iteration we then randomly pick one integer in the open array, remove it and put it into the result array. After doing this $k$ times, we have a batch of unique samples.

To make this more efficient, we can store both arrays in one "super" array which we divide into two at index $r$. The result array goes from index $0$ to index $r$, while the open array goes from index $r$ to $n-1$ (inclusive). When we want to transfer the sample from open to result array, we simply swap the picked index $i$ with the integer at index $r$ and increase $r$ by one. Figure \ref{fig:uni-ill} visualises this algorithm.

<Figure>
\include[className="max-w-xl mb-8"]{@/public/uploads/images/sampling-algorithms/sampling-uniform.svg}
<Figcaption>

Figure \label{fig:uni-ill}: Illustration of uniform algorithm without replacement. First, we pick a random element of the range and swap it with the first element. From now on, ignore the first element and only sample beginning with the second integer. Keep swapping the samples and shrinking the sampling range until we have $k$ integers. The first $k = 3$ integers represent the final sample.

</Figcaption>
</Figure>

## Implementation

Let's implement this algorithm using C++. As we need to have an array of size $n$ in memory, it makes sense to reuse that througout multiple samples. Therefore we create a class for the sampler.

<Figure>

```cpp
#include <stdio.h>
#include <random>

typedef std::mt19937 RandomEngine; // or any other PRNG

class UniformSampler {
public:

   UniformSampler(unsigned int N);
   ~UniformSampler();

   unsigned int *SampleWithReplacement(unsigned int k);
   unsigned int *SampleWithoutReplacement(unsigned int k);

   unsigned int N_;
   unsigned int *array_;

   RandomEngine engine_;

};

UniformSampler::UniformSampler(unsigned int N)
      : N_(N), engine_(RandomEngine { std::random_device{}() }) {
   // Initialize array A to the range [0, N-1)
   array_ = new unsigned int[N_];
   for (int j = 0; j < N_; ++j) {
      array_[j] = j;
   }
}

UniformSampler::~UniformSampler() {
   delete [] array_;
}
```

<Figcaption>Figure \label{fig:uniform-class}: Class for the uniform sampler. Make sure to free the array in the destructor!</Figcaption>

</Figure>

Now that we have our class, we can implement the algorithm. On each iteration $i$, we sample $j \sim U\{r, N\}$ and swap the $r$-th with $j$-th integer as previously discussed.

<Figure size="text">

```cpp
// Sample k integers and return pointer to result array
unsigned int *UniformSampler::SampleWithoutReplacement(unsigned int k) {
   for (unsigned int r = 0, j; r < k; ++r) {
      // Sample random int in [r; N)
      j = engine_() % (N_ - r) + r;
      // Swap i-th with j-th integer
      std::swap(array_[r], array_[j]);
   }
   // Return pointer to result
   return array_;
}
```

<Figcaption>Figure \label{fig:uniform-algo}: Implementation of uniform algorithm without replacement.</Figcaption>

</Figure>

The runtime of this algorithm is $O(k)$. The memory requirement is $O(n)$. In contrast to other algorithms, the runtime does not depend on $n$. More analysis on the runtime can be found in Figure \ref{fig:runtime}.

</Wrap>

<Wrap id="categorical-sampling">

# Unnormalised Categorical Distribution

As mentioned in the introduction, there are other ways to sample from a dataset besides uniform sampling. In the following, I will be focusing on the _categorical distribution_ where each data point has its own probability of getting sampled.

$$
P(x_i) = p_i
$$

Most of the time, however, we do not have probabilities. Instead we are given weights $w_i$ which indicate relative importance of a data point. In machine learning, this could be the loss of the model. A set of weights might be $\{1, 3, 8, 1, 3, 2, 1, 4\}$. In this case, the third data point has the highest chance of getting sampled with a weight of $w_2 = 8$.

However, a valid probability distribution requires that $\sum_i p_i = 1$. Therefore we need to normalise the weights before we can sample from this distribution.

$$
P(x_i) = \frac{w_i}{\sum_j w_j}
$$

Returning to the example from above, we would have a probability distribution of $\{\frac{1}{23}, \frac{3}{23}, \frac{8}{23}, \frac{1}{23}, \frac{3}{23}, \frac{2}{23}, \frac{1}{23}, \frac{4}{23}\}$. For larger datasets, sampling from this distribution is tricky. Summing over all elements has linear complexity. Moreover, we cannot cache the sum, because in reinforcement learning, for example, weights are changing after each iteration. Is there a way to improve over linear complexity?

## Segment Tree

The answer is yes. We can make use of a binary tree structure to efficiently compute the sum over all elements. The idea is to arrange all data points as leafs of a tree. The key of each leaf is the weight $w_i$ of its data point. To maintain a sum over all weights, the key of a higher-level node is defined as the sum of its child nodes.

$$
\mathrm{key}\left(i\right) = \sum_{j \in \mathrm{children}\left(i\right)} \mathrm{key}\left(j\right)
$$

This is known as a _segment tree_ or _sum heap_. Take a look at Figure \ref{fig:segment-tree} for an illustration of this data structure.

<Figure>
\include[className={`mb-8`}]{@/public/uploads/images/sampling-algorithms/sampling-categorical.svg}
<Figcaption>

Figure \label{fig:segment-tree}: Illustration of a 'sum' [segment tree](https://en.wikipedia.org/wiki/Segment_tree). The leafs of the tree represent the weight of each data point. Every node is equal to the sum of its child nodes. Dividing by the value of the root gives normalised probabilities (shown in green).

</Figcaption>
</Figure>

Given a segment tree of the weights, it is straightforward to sample from a categorical distribution. Take a random number $u \in \mathbb{R}$ between $0$ and $1$ sampled from a uniform distribution $u \sim U\{0, 1\}$. Let $v = \hat{w} \cdot u$ where $\hat{w}$ is the value of the root node. Start at the root node and descent left if $v < \mathrm{key}\left(\mathrm{left\,node}\right)$, otherwise set $v = v - \mathrm{key}\left(\mathrm{left\,node}\right)$ and descent right. Once you reach a leaf node, you have your sample.

Essentially, we partition $\left[0, \hat{w}\right)$ into $n$ intervals with the size $w_i$, sample from $\left[0, \hat{w}\right)$ uniformly and then find the interval in which that number falls.

To sample without replacement, simply remove the weight from the tree. This has $\log n$ computational cost.

## Implementation

We start implementing this algorithm by designing a class that can hold the tree. To keep it simple, we use an array representation for the segment tree. The two children of node $j$ are stored at position $2j$ and $2j + 1$.

<Figure>

```cpp
#include <cassert>
#include <stdio.h>
#include <random>

typedef std::mt19937 RandomEngine;

class CategoricalSampler {
public:

   CategoricalSampler(unsigned int N);
   ~CategoricalSampler();

   void SampleWithReplacement(unsigned int k, unsigned int *result);
   void SampleWithoutReplacement(unsigned int k, unsigned int *result);

   void SetWeight(unsigned int j, float weight);
   const float& GetWeight(unsigned int j);

   unsigned int N_; // Dataset size
   float *w_; // Tree array
   RandomEngine engine_;

};

CategoricalSampler::CategoricalSampler(unsigned int N)
      : N_(N), engine_(RandomEngine { std::random_device{}() }) {
   // Create tree structure using array representation
   w_ = new float[2 * N + 1];
   // Initialize the weights to w_i = 1
   std::fill(w_ + N + 1, w_ + 2 * N + 1, 1.0f);
   // Heapify
   for (unsigned int i = N; i > 0; i -= 1) {
      w_[i] = w_[2 * i] + w_[2 * i + 1];
   }
}

CategoricalSampler::~CategoricalSampler() {
   delete [] w_;
}
```

<Figcaption>Figure \label{fig}: Categorical class using an array representation for the segment tree.</Figcaption>
</Figure>

Next, we implement some basic functions to maintain the sum tree. `Heapify` walks up the tree and restores the sum condition. `SetWeight` and `GetWeight` are for users who wish to update the distribution.

<Figure>

```cpp
inline void Heapify(float *w, int j) {
   // Walk up tree and restore sum condition
   while (j > 1) {
      j /= 2;
      w[j] = w[2 * j] + w[2 * j + 1];
   }
}

void CategoricalSampler::SetWeight(unsigned int i, float weight) {
   if (weight < 0.0F) {
      throw std::invalid_argument("Weight must be greater or equal to zero.");
   }
   unsigned int j = N_ + 1 + i; // Position of w_j in array
   w_[j] = weight;
   Heapify(w_, j); // Maintain sum condition
}

const float& CategoricalSampler::GetWeight(unsigned int i); {
   return w_[N_ + 1 + i];
}
```

<Figcaption>Figure \label{fig}</Figcaption>
</Figure>

After having all the setup done, we can focus on implementing the sampling algorithm as described earlier.

<Figure>

```cpp
void CategoricalSampler::
     SampleWithoutReplacement(unsigned int k, unsigned int *result) {
   float v, w; // Sampled value
   for (unsigned int i = 0, j; i < k; i += 1) {
      // Pick random number between [0; w_[1])
      v = std::uniform_real_distribution<>(0.0f, w_[1])(engine_);
      // Binary search through segment tree
      j = 1;
      do {
         j *= 2;
         // Go right if w_[j] < v, or, if w_[j] is invalid
         if (w_[j] < v || (j > N_ && w_[j] < 0.0F)) {
            v -= w_[j];
            j += 1;
         }
      } while (j <= N_);
      // Set output index
      result[i] = j - N_ - 1;
      // Remove weight from tree
      w = w_[j];
      w_[j] *= -1.F; // Mark as invalid
      while (j > 1) {
         j /= 2;
         w_[j] -= w;
      }
   }
   // Restore original state
   for (unsigned int i = 0, j; i < k; i += 1) {
      j = N_ + 1 + result[i];
      w_[j] *= -1.F; // Mark as valid
      w = w_[j];
      while (j > 1) {
         j /= 2;
         w_[j] += w;
      }
   }
}
```

<Figcaption>Figure \label{fig}: Sampling algorithm for a categorical distribution without replacement.</Figcaption>
</Figure>

<Expander className="mb-8" teaser="code for sampling with replacement">

<Figure className="mt-8">

```cpp
void CategoricalSampler::
     SampleWithReplacement(unsigned int k, unsigned int *result) {
   float v; // sampled value
   for (unsigned int i = 0, j; i < k; i += 1) {
      // Pick random number between [0; w_[1])
      v = std::uniform_real_distribution<>(0.0f, w_[1])(engine_);
      // Binary search through sum-heap
      j = 1;
      do {
         j *= 2;
         if (w_[j] < v) {
            v -= w_[j];
            j += 1;
         }
      } while (j <= N_);
      // Set output index
      result[i] = j - N_ - 1;
   }
}
```

<Figcaption>Figure \label{fig}: We can also implement a function that samples with replacement.</Figcaption>
</Figure>

</Expander>

This segment tree-based algorithm has runtime complexity $O(k \log n)$. Its memory complexity is $O(2n)$.

</Wrap>

<Wrap id="runtime">

## Runtime Analysis

You might wonder how well these algorithms perform for bigger datasets in practice. To find that out, I ran some performance tests. Take a look at Figure \ref{fig:runtime}.

<Figure>
<Image
   src="/uploads/images/sampling-algorithms/runtime_analysis.svg"
   alt="Runtime analysis"
   width={700}
   height={500}
   contain={true}
/>
<Figcaption>

Figure \label{fig:runtime}: Runtime analysis of the presented algorithms. Evaluations were conducted on a Intel Core i9 using a single-thread and `-O3` optimization flag. (1) Runtime of categorical sampling w.r.t. $n$ and $k$ fixed to $256$. (2) Runtime of categorical sampling w.r.t. $k$ and $n$ fixed to $65 536$. (3) Runtime of uniform algorithm w.r.t. $k$ and $n$ fixed to $65 536$. (4) Ratio of categorical runtime divided by uniform runtime with $n = 65 536$.

</Figcaption>
</Figure>

The log-complexity of categorical sampling w.r.t. to $n$ is visible in plot (1). It takes around $100\mu{s}$ to sample a batch of size $256$ from a dataset with $10$ million data points. Surprisingly, sampling without replacement is faster for the categorical distribution. Compared with uniform sampling, categorical sampling is around $15$ to $30$ times slower for $n = 65 536$, as seen in plot (4).

# Effect on Training Neural Nets

We discussed sampling _without replacement_ throughout this post. It might not be obvious what the effect on training a neural net is. From a theoretical standpoint, it reduces the variance of an estimator. Take for example a mean estimator $Y = \frac{1}{k}\sum_{i=1}^k X_i$ with $X_i \sim \mathcal{D}$. Using sampling without replacement, the variance of this estimator reduces to[^\ref{cit:utexas}]

$$
\hat{\sigma}^2 = \frac{n-k}{n-1} \cdot \sigma^2
$$

where $\sigma^2$ is the variance of the same estimator but _with replacement_ sampling.

In domains where $n$ is small, this can make a difference. If $n$ is large, however, the factor $\frac{n-k}{n-1}$ gets closer and closer to $1$. For example, with a batch size of $b = 1\%$ of the dataset size, we get a factor of $n \cdot \frac{1 - b}{n-1} \approx 1 - b = 99 \%$. Sampling without replacement reduces the variance by $1\%$ in this case.

Although this applies only to mean estimators, the analogy might give you some intuition about the effect on neural network training of sampling without replacement.

</Wrap>

<Wrap id="conclusion">

# Conclusion

In this post, I presented algorithms to sample from a dataset uniformly or weighted. These algorithms find application in reinforcement learning for prioritised replay buffers [^\ref{cit:replay-buffer}] or in supervised learning when sampling batches. The effect of sampling without replacement is larger for small datasets.

Further research into the effect of prioritising training examples based on learning error would be interesting. The algorithms presented here could be used as a basis for ideas in that space.

</Wrap>

---

If you want to read more about sampling algorithms, take a look at Tim Vieira's blog: https://timvieira.github.io/blog/post/2019/09/16/algorithms-for-sampling-without-replacement/

[^\label{cit:replay-buffer}]: A good breakdown can be found at https://danieltakeshi.github.io/2019/07/14/per/
[^\label{cit:utexas}]: https://web.ma.utexas.edu/users/parker/sampling/woreplshort.htm


A walkthrough how to efficiently sample from datasets

Efficient Sampling Algorithms


South Africa is, I would say, one of the most beautiful and at the same time heart-breaking
countries. Its beautiful nature and devastating townships are in stark contrast.

This year I made it back to the country that has all of the big five — lion, leopard, elephant,
rhino, and buffalo. It was a stunning experience.

We started our trip in Johannesburg, going to the north-west to the Madikwe Game Reserve.

<Figure>
   <Image
      src="/uploads/images/safari-in-south-africa/madikwe.jpg"
      alt="Overview of Madikwe Game Reserve"
      width={600}
      height={400}
      priority
   />
   <Figcaption>Overlooking Madikwe Game Reserve</Figcaption>
</Figure>

<Figure size="extend">
   <Image
      src="/uploads/images/safari-in-south-africa/elephant-2.jpg"
      alt="Elephant on safari"
      width={1200}
      height={900}
      priority
   />
</Figure>

<Figure size={3} position={3} className="pr-8">
   <Image
      src="/uploads/images/safari-in-south-africa/early-morning-coffee.jpg"
      alt="Drinking coffee early in the morning in the safari park"
      width={300}
      height={400}
   />
</Figure>

<Figure size={4} position={6} align="end">
   <Image
      src="/uploads/images/safari-in-south-africa/tree.jpg"
      alt="Magical tree"
      width={400}
      height={300}
   />
</Figure>

<Figure>
   <Image
      src="/uploads/images/safari-in-south-africa/lion-1.jpg"
      alt="A lion"
      width={600}
      height={450}
   />
</Figure>

<Figure>
   <Image
      src="/uploads/images/safari-in-south-africa/safari-3.jpg"
      alt="Sun rising over Madikwe"
      width={1200}
      height={900}
   />
</Figure>

<Figure size="extend">
   <Image
      src="/uploads/images/safari-in-south-africa/lion-3.jpg"
      alt="Lion that is photographed by people out of safari vehicles"
      width={600}
      height={450}
   />
</Figure>

<Figure>
   <Image
      src="/uploads/images/safari-in-south-africa/safari-4.jpg"
      alt="Picture out of our car into the sun"
      width={600}
      height={800}
   />
</Figure>

<Figure size="extend">
   <Image
      src="/uploads/images/safari-in-south-africa/dusk.jpg"
      alt="Artsy picture of dusk in the desert"
      width={600}
      height={450}
   />
   <Figcaption>Pink and White Skies</Figcaption>
</Figure>

Waking up at 5 in the morning while the sun was still down, coffee at 8. Our schedule was insane.
The early bird, gets the worm – I guess; getting up early meant we were getting all the
sunrises. At 9 we were done. We went back to sleep, only to be ready for the next safari at 4 in
the afternoon.

After three awesome days in Madikwe, it was about time to move to our next destination. We went
to the Welgevonden Reserve. It was north of Madikwe, near the border to Botswana. Getting there
was a bumpy ride. Roads on a map do not necessarily translate to tarred streets in South Africa.
Take note.

<Figure justify="center">
   <Image
      src="/uploads/images/safari-in-south-africa/maps.png"
      alt="A map of South Africa which highlights our journey"
      className="rounded-xl"
      width={300}
      height={300}
      intrinsic
   />
   <Figcaption>
      The three stops on our journey: Madikwe, Welgevonden, Cape Town
   </Figcaption>
</Figure>

Once we arrived, everything changed. It was quite interesting how much the landscape differed.
Even in Madikwe, on the same day, it felt like we were visiting different locations on earth
although it was all part of the same game reserve. Welgevonden felt completely different yet
again. If Madikwe was like a steppe, this game reserve was like a jungle.

<Figure size="extend">
   <Image
      src="/uploads/images/safari-in-south-africa/jungle.jpg"
      alt="Sun rising in the Welgevonden Reserve"
      width={1200}
      height={900}
   />
   <Figcaption>Do you feel the jungle?</Figcaption>
</Figure>

<Figure>
   <Image
      src="/uploads/images/safari-in-south-africa/safari-1.jpg"
      alt="Elephant on the street"
      width={600}
      height={800}
   />
</Figure>

<Figure>
   <Image
      src="/uploads/images/safari-in-south-africa/giraffe.jpg"
      alt="Giraffe in the wild"
      width={600}
      height={450}
   />
</Figure>

<Figure>
   <Image
      src="/uploads/images/safari-in-south-africa/elephant-1.jpg"
      alt="Elephant moving away from our car"
      width={600}
      height={450}
   />
</Figure>

In this game reserve the elephants were messing with us. Usually, they came running towards our
safari vehicle when we encountered them. Get's your blood pumping. Apparently they were in their
musth phase which means they are more aggressive. With their 6 tons of weight, elephants could
easily turn around a safari vehicle.

After a few days and many elephant encounters, we drove back to Johannesburg. From there we flew
to our last destination: Cape Town, one of my favorite cities I have been to. We stayed in Cape
Town over New Years Eve. It’s crazy how cheap good food is in this city. One restaurant I can
highly recommend is called Manna Epicure in Kloof Street. It's damn good. And also, did I tell
you about the light?

<Figure size={{ all: 12, md: 6 }} position={{ all: 3, md: 2 }}>
   <Image
      src="/uploads/images/safari-in-south-africa/from-table-mountain.jpg"
      alt="Clouds over Cape Town and Lions Head"
      width={800}
      height={600}
   />
   <Figcaption>Mystic haze</Figcaption>
</Figure>

<Figure
   size={{ all: 8, md: 5 }}
   position={{ all: 7, md: 9 }}
   align="center"
   className="md:row-span-2"
>
   <Image
      src="/uploads/images/safari-in-south-africa/lions-head.jpg"
      alt="Beautiful lions head during dusk"
      width={600}
      height={800}
   />
   <Figcaption>Lions Head at dusk</Figcaption>
</Figure>

<Figure size={{ all: 8, md: 5 }} position={3}>
   <Image
      src="/uploads/images/safari-in-south-africa/twelve-apostels.jpg"
      alt="Clouds over twelve apostels"
      width={600}
      height={800}
   />
   <Figcaption>Clouds over the twelve apostles</Figcaption>
</Figure>


Safari in South Africa


The best startups are founded by ingenius people. I agree with this. But there is another, somewhat more overlooked aspect to great founders. The best founders live in the future.

In order to find problems that are yet to be solved, the future is the best place to be. Only when you take for granted what is novel to other people, you are able to assemble the puzzle and look for missing pieces.
Mark Zuckerberg did not create Facebook because he looked for good ideas to pursue. He already spent so much of his time on the internet, more than most people at that time. For him it was only natural to share things with his friends online. That’s why he build Facebook. He lived in the future.


Live in the Future


Imagine a world where artificial general intelligence is a thing, where robots assemble robots, where computers cure cancer, and where everything we do today is automated. In such a robot world, the problems arise with humans – not robots. What is left to do for us, if we are replaced in everything we do today? More importantly, how can computers align with our values, so they work with us and not against us?

## The Solution

In my opinion, an inevitable solution is a device called neural lace. It’s a brain implant that extends your intelligence by connecting neurons in your brain to an artificial neural network. It works by replicating processes of your brain, with the speed and scalability perks of silicon. Wearing such a device must feel like an epiphany, where suddenly you can make sense of things you could not before.

Why is a neural lace inevitable? First of all, it keeps humans at work – as they are not replaced but augmented. Second, it’s of high economic interest because it increases productivity. Finally, it solves the problem of value-alignment: a neural lace doesn’t act on its own, keeping humans in charge. These reasons make me to strongly believe a neural lace to be inevitable in a post-AGI world.
Although a neural lace may solve some of AGI’s problems, it inherently comes with new, bigger controversies.

## Bye, Meritocracy

Top of society has always consisted of the brightest minds, the greatest thinkers, the ones who come up with best ideas and most ingenious inventions. If we assume a neural lace to be inevitable, people having access to such a device will outsmart others. They will have unattainable brain capabilities, will be able to memorize and comprehend more than their peers and will be able to see connections where others don’t. Hence, access to such devices will be very desirable. To be at top of the society will mean having a neural lace. This slashes even the slightest delusion of a meritocracy, as only the one percent may be able to afford such devices. Suddenly being rich means being smart.

As cognitive abilities grow, leadership and value-creation in the society will shift towards intelligence-augmented people. Being 100x more intelligent than your rivals will obviously mean outperforming them. Being smarter also means producing things, that people need, more efficiently. As more value is created by intelligence augmented people this way, a social divide is unavoidable. If 99% of the population accounts only for 1% of value creation in the economy, society will be split. Two groups emerge: a small, elite group of people who have access to neural laces, and the rest. In my opinion, this will be the biggest controversy in the history of mankind.
