The recommender’s four-trillion-ID claim is off by 1,000×

A conventional recommender retrieves products by comparing one user vector against a giant index of item vectors. TIGER tries something stranger: turn each product into a short sentence of integer tokens, then ask a transformer to generate the next product's sentence.

Those tokens form a Semantic ID. Similar products share early tokens, so “orange shoes, Brand Y” can borrow evidence from other shoes instead of starting as an isolated item number. This makes recommendation look like language generation and gives new products a route into the system through their content.

TIGER begins with a 768-dimensional content embedding built from title, price, brand, and category. An encoder compresses it to 32 dimensions. Residual quantization then chooses the nearest vector from the first codebook, subtracts it, and asks the next codebook to describe what remains. Each chosen vector's index becomes one token.

def residual_quantize(vector, codebooks):
    residual = vector[:]
    codes = []
    for codebook in codebooks:
        code = min(range(len(codebook)), key=lambda k: squared_distance(residual, codebook[k]))
        residual = [r - q for r, q in zip(residual, codebook[code])]
        codes.append(code)
    return codes, residual

The live TypeScript uses the same loop; Python and C++ are faithful translations. Our two-dimensional codebooks are deterministic illustrations, not the paper's learned 32-dimensional vectors.

With separate codebooks, an ID such as (5, 25, 55) is a path: token 5 gives a broad neighborhood, token 25 refines it, and token 55 resolves a smaller residual. In the paper's Beauty visualization, the first token grouped broad categories such as hair or makeup while later tokens separated finer categories.

A transformer reads a user's sequence of Semantic IDs and autoregressively predicts the next ID one token at a time. Autoregressive means each predicted token becomes context for predicting the next. Beam search keeps several likely partial IDs alive until they resolve to candidate items.

The paper uses four tokens with 256 choices each and says this spans “approximately 4 trillion” IDs. The exact calculation is 256⁴ = 2³², or 4,294,967,296: about 4.3 billion. That is a three-order-of-magnitude arithmetic slip.

Multiple products can quantize to the same three-token ID. TIGER fixes this after training by appending 0, 1, 2, and so on to colliding products. That suffix is an atomic tie-breaker, not learned meaning, and it requires a lookup table from IDs back to actual items. The method compresses the giant index; it does not make the catalog disappear entirely.

• Constrain beam search to valid prefixes instead of filtering only at the end.
• Report collision rates and suffix dependence for new, long-tail products.
• Measure serving latency against a tuned approximate-neighbor index.

To inspect the attention and autoregressive decoding underneath TIGER, poke at the interactive transformer page.