Two-Tower Model

The model consists of two distinct neural networks—a user tower and an item tower—that operate independently. The user tower encodes user features (demographics, historical behavior, context) into a dense vector, while the item tower encodes item features (metadata, content, price) into a vector of the same dimensionality. This separation means item embeddings can be pre-computed and indexed offline, while only the user embedding is computed at inference time, enabling sub-millisecond retrieval from billion-scale catalogs.

Both towers project their inputs into a common latent space where proximity equates to relevance. The model is trained so that the dot product or cosine similarity between a user embedding and an item embedding represents the predicted affinity score. This shared geometry is what makes vector similarity search possible—the system simply finds the item vectors nearest to the user's query vector using Approximate Nearest Neighbor (ANN) algorithms like Hierarchical Navigable Small World (HNSW) or ScaNN.

A critical design constraint: the user tower and item tower cannot share features at inference time. The user tower only sees user-side features, and the item tower only sees item-side features. This prevents the model from learning cross-feature interactions like 'this user likes this specific item category when it's on sale.' While this limits expressiveness compared to a cross-encoder, it is the trade-off that enables offline indexing and real-time retrieval at massive scale.

Training a two-tower model on millions of items requires efficient negative sampling. A common technique is in-batch negative sampling, where other items in the same mini-batch serve as negatives for a given user. For a batch of B user-item pairs, each user treats the B-1 other items as negatives, yielding B*(B-1) training examples per batch. This is computationally efficient but introduces selection bias toward popular items, which can be mitigated with techniques like mixed negative sampling or log-Q correction.

Two-tower models are almost never used in isolation. They serve as the candidate generation stage in a larger recommender system. The two-tower model retrieves hundreds of relevant candidates from a massive corpus using ANN search. A more expressive cross-encoder or multi-task ranking model then re-ranks these candidates, incorporating cross-features and business rules. This two-stage design balances the speed of dual-encoders with the accuracy of full-interaction models.

The final layer of each tower typically applies L2 normalization to constrain embeddings to the unit hypersphere. This makes cosine similarity equivalent to dot product and improves training stability. A temperature parameter τ is often applied to the logits before the softmax during training. Lower temperatures sharpen the distribution, penalizing hard negatives more aggressively, while higher temperatures smooth the distribution, which can help with convergence in early training stages.

The two independent neural networks that form the architecture's backbone. The user tower encodes static features (demographics) and dynamic behavior (click history) into a single vector. The item tower encodes product attributes (price, category, description) into a vector of identical dimensionality. Crucially, the towers never interact directly during training—they only meet in the final dot product loss function, enabling offline item vector pre-computation.

A trainable lookup table that maps high-cardinality categorical features—like user_id or item_sku—into dense, low-dimensional continuous vectors. This is the first layer in both towers, transforming sparse one-hot encoded inputs into the dense representations that subsequent fully-connected layers can process. The quality of these learned embeddings directly determines the expressiveness of the final user and item representations.

The retrieval engine that makes Two-Tower models viable at scale. After the item tower pre-computes embeddings for millions of products, ANN algorithms like Hierarchical Navigable Small World (HNSW) or ScaNN find the top-K items closest to a user's query vector in milliseconds. This trades a small, bounded accuracy loss for a 100-1000x speedup over exact brute-force search, enabling real-time candidate generation from billion-scale catalogs.

A training efficiency technique that avoids computing the prohibitively expensive full softmax over millions of items. For each positive user-item interaction, the loss function samples a small set of negative items (items the user didn't interact with) and only updates their embeddings. Common strategies include:

• In-batch negatives: reusing other users' positive items as negatives within the same mini-batch
• Random negatives: uniformly sampling from the catalog
• Hard negatives: sampling items the model currently ranks highly but are irrelevant

The self-supervised learning paradigm often used to train Two-Tower models. The objective pulls the user embedding and the positive item embedding closer together in the shared vector space while simultaneously pushing apart the embeddings of negative items. The standard loss function is InfoNCE (Noise Contrastive Estimation), which frames the task as a multi-class classification problem: identify the true positive item among a set of distractors.

The process of creating synthetic features by combining two or more individual inputs to model non-linear interactions. While deep layers in the towers can learn some crossings implicitly, explicit Hadamard product or concatenation of feature pairs (e.g., user_age * item_price_tier) can inject crucial multiplicative relationships. This is especially important when the towers are simple MLPs that may struggle to discover sparse, high-order interactions without guidance.