Performance Labeling System

How our foundational model represents player performance

Our base model predicts five key performance statistics as a single unified label. Each label represents a unique combination of discrete performance bins.

For example:

A performance falling into the bin group “10–20 passes completed, 80–85% pass completion, 34–44 touches, >2 shots, >0.30 xG” corresponds to the label 1993.

We have 7,680 unique labels, each describing a distinct category of performance. This discretization strategy, turning continuous values into categorical bins, was a deliberate modeling choice that:

• Transforms the problem into multi-class classification, which proved more stable and performant than regression.

• Encourages structured, contextual reasoning about performance profiles instead of noisy continuous estimates.

• Scales elegantly to additional performance metrics: if you want to build your own simulation engine with custom metrics, you can naturally extend the BALLER Transfer Portal architecture with your own binning scheme.

Stat Bin Definitions

Below are the bins used in our base model.

• Shots (4 bins)

Bin	Range
0	0 shots
1	1–2 shots
2	>2 shots
3	N/A

• Expected goals: xG (5 bins)

Bin	Range
0	0.00
1	0.01–0.10
2	0.11–0.30
3	>0.30
4	N/A

• Pass Completion % (8 bins)

Bin	Range
0	0–60%
1	60–70%
2	70–75%
3	75–80%
4	80–85%
5	85–90%
6	90–100%
7	N/A

• Passes Completed (8 bins)

Bin	Range
0	0–10
1	10–20
2	20–30
3	30–50
4	50–200
5	N/A

• Touches (8 bins)

Bin	Range
0	0–11
1	11–22
2	22–34
3	34–44
4	44–55
5	55–69
6	69–217
7	N/A

As you can see, the model is robust enough to explicitly handles missing or nonsensical values. This allows it to output “I don’t know” when the context does not provide enough information, rather than producing incorrect predictions. It also enables the model to gracefully handle special cases—such as statistics that are irrelevant for goalkeepers—without forcing artificial or misleading outputs.

Convert bins to a unique label

// Some code
# mapp combined quantized stat with unique label
mapping = {}
for i in range(6): # pass_cmp
    for j in range(8): # pct_pass_cmp
        for k in range(8): # touches
            for l in range(4): # sh
                for m in range(5): # xG 
                    label = i * (8*8*4*5) + j * (8*4*5) + k * (4*5) + l * 5 + m
                    mapping[f"{i}_{j}_{k}_{l}_{m}"] = label

Convert label to bins

// Some code
# convert label to stat
def label_to_stats(label: int) -> Dict[str, int]:
    """
    Convert a single combined integer label back to individual stat bins.
    The original encoding is reversed here.
    """
    # careful integer arithmetic as in original
    m = label % 5
    label = label // 5
    l = label % 4
    label = label // 4
    k = label % 8
    label = label // 8
    j = label % 8
    i = label // 8

    return {
        'pass_cmp': i,
        'pct_pass_cmp': j,
        'touches': k,
        'sh': l,
        'xg': m
    }

Convert label to human-readable stat bins

// Some code
STATS_BINS = {
    'pass_cmp': [0, 10, 20, 30, 50, 200],
    'pct_pass_cmp': [0, 60, 70, 75, 80, 85, 90, 100],
    'touches': [0, 11, 22, 34, 44, 55, 69, 217],
    'sh': [0, 0, 2],
    'xg': [0, 0, 0.1, 0.3]
}
STATS_NBINS = {
    'pass_cmp': 6,
    'pct_pass_cmp': 8,
    'touches': 8,
    'sh': 4,
    'xg': 5
}
def get_stat_range_str(stat_name: str, bin_id: int) -> str:
    """
    Convert a stat_name + bin_id into a human-friendly textual range.
    Returns "N/A" for the NaN / pad bin.
    """
    if bin_id >= STATS_NBINS[stat_name] - 1:
        return "N/A"

    bins = STATS_BINS[stat_name]

    if stat_name == 'sh':
        if bin_id == 0:
            return "0"
        elif bin_id == 1:
            return "1-2"
        else:
            return ">2"
    elif stat_name == 'xg':
        if bin_id == 0:
            return "0.00"
        elif bin_id == 1:
            return "0.01-0.10"
        elif bin_id == 2:
            return "0.11-0.30"
        else:
            return ">0.30"
    elif stat_name == 'pct_pass_cmp':
        if bin_id >= len(bins) - 1:
            return "N/A"
        return f"{bins[bin_id]}-{bins[bin_id + 1]}%"
    else:
        if bin_id >= len(bins) - 1:
            return "N/A"
        else:
            range_bins = f"{bins[bin_id]}-{bins[bin_id + 1]}"
            if range_bins=="50-200":
                return ">50"
            elif range_bins=="69-217":
                return ">69"
            else:
                return range_bins