# Segmentation/Autoselected Segmentation

Automatic Segmentation is a mechanism for automatically selecting from every combination of available axis, so that for any situation the best available data is used. The concept was first proposed on the old wiki by Vuen for the bot Fractal [1].

## Example

To start, you have a number of segmentation axis:

- Lateral Velocity (LV)
- Acceleration (A)
- Time Since Reversal (TSR)

You can assemble all combinations of segments into a long list of every segmentation that uses these three axes:

Segmentation | Depth |
---|---|

(no segmentation) | 0 |

LV | 1 |

A | 1 |

TSR | 1 |

LV + A | 2 |

LV + TSR | 2 |

A + TSR | 2 |

LV + A + TSR | 3 |

Once you have the array of segmentations, you need a function to determine how good the data in that segmentation is. One way to do that is with what's called the Crest factor. This is the ratio of the peak of the data to the root-mean-squared value of the data.

Crest factor calculation:

Root mean squared calculation:

Therefore, the crest factor can be calculated by:

The segmentation that returns the most useful data (as determined by the crest factor) can used for dodging, aiming, or any other statistical calculation depend on what you need.

## Implementation

*The implementation below is used in Watermelon. Fractal uses a similar implementation.*

First, you need an abstract class to represent a segmentation axis. It needs a minimum and maximum value, a number of segments, and a function to return an index value given a reference to either a bot or an enemy.

Create a subclass for each segmentation axis you need - Lateral Velocity, Acceleration, etc.

Second, you need a class to represent a single segmentation. It will be initialized with a certain number of axes, and it will segment on all those axes. It also needs to be able to handle being initialized with no axis at all. This class needs to be able to mark a "hit" on itself (possibly with bin smoothing) given the necessary index for each of its axes. It should also be able to indicate how "good" its data is given a certain set of axis indices. It can simply return the Crest Factor, or it can incorporate additional factors such as how many axes it has and how much data has been collected.

Finally you need to assemble every possible segmentation into a large array of segmentations. When you register a "hit", mark it on each segmentation. When you need to take advantage of the data you've collected, find the axis indices for each segmentation and ask it how good its data is for that set of indices. Use the segmentation with the best fitness.

One simple way to assemble these axes for each segmentation takes advantage of properties of binary numbers. You will have *2 ^{num_of_axes}* segmentations, due to some convenient cancellation in the combinations. Count from

*0*to

*num_of_segmentations*in binary, and assign each place value to one of your axes. For each number in the sequence, if that place value is a 1, include that axis.