How do item side features get folded into a latent-factor recommender for cold items?

## The problem this solves A plain latent-factor model gives every item a free parameter vector fitted from that item's own interactions. That is expressive and it is exactly why cold items are hopeless: no interactions, no fitted vector. A feature-augmented hybrid changes **where the item vector comes from** so that some of it is derivable from metadata that exists before any user has done anything. ## Construction one: features as shared embeddings Assign a learned vector `v_f` in the latent space to each *feature value*, not to each item: one for `seniority=senior`, one for the skill tag `python`, one for `remote`, one for each city. Then define ``` q_i = sum over f in features(i) of v_f ``` (or the mean, which keeps the magnitude comparable across items with different numbers of tags — worth doing when tag counts vary a lot). Training is unchanged in structure: minimise prediction error on observed interactions. The difference is what the gradient reaches. An update triggered by an interaction with one senior Python posting now moves the `senior` vector and the `python` vector, and those same vectors are used by every other posting carrying those tags — **including postings that had not been created when the model was fitted**. Information flows between items through the features they share. The consequence for cold start is direct. A posting that goes live at 09:00 with zero applications has a vector at 09:00, because its tags do. It sits near other senior Python roles in the same space that user vectors live in, so `dot(p_u, q_i)` is a real, personalised prediction rather than noise. ## Construction two: features plus a free residual Pure feature representation has a hard ceiling: two postings with identical tags get **identical** vectors and are therefore indistinguishable, even after one has collected a thousand applications and the other none. That is a real loss, because much of what makes an item good is not in the metadata. The standard fix is additive: ``` q_i = sum over f in features(i) of v_f + e_i ``` `e_i` is a free per-item vector, initialised at zero and regularised. For a cold item, the data says nothing about `e_i`, so the penalty keeps it near zero and the score is effectively content-driven. As interactions arrive, the error term starts pushing `e_i` to capture whatever the features fail to explain. The model slides continuously from content-based to collaborative behaviour, with no threshold, no switch and no separate code path. The regularisation weight on `e_i` is the dial: heavy penalty means you trust the metadata and cold and warm items behave alike; light penalty means warm items get more expressive vectors but you re-open the gap between them and fresh inventory. ## Construction three: map features onto fitted factors A different route, sometimes easier to bolt onto an existing system: fit the ordinary factor model on warm items, then treat the fitted vectors as targets and learn a mapping from item features to the latent space — one regression per latent dimension, or a single small multi-output model. Apply that mapping to cold items to predict where they *would* sit. - **Pro:** the collaborative model is untouched, so warm-item quality cannot regress; the mapping can be trained and swapped independently. - **Con:** it is a two-stage fit, so errors compound, and it optimises "reproduce the fitted vector" rather than "rank well". Jointly learned feature embeddings usually beat it when you can afford to retrain the whole thing. ## The user side is symmetric Nothing about the construction is item-specific. User attributes known at signup — declared interests, region, segment — can be embedded the same way, so a brand-new user starts at the sum of their attribute vectors instead of at nothing. Folding candidate CV skill overlap into the model as side features on both sides is a natural example: the same skill tag vocabulary describes both the person and the posting. ## What decides whether it works - **Feature coverage.** If 40% of new items arrive with empty tags, they are cold whatever the architecture. Metadata quality is a data-pipeline and often an editorial problem, not a modelling one. - **Feature granularity.** Features so coarse that thousands of items collapse to the same vector give you cold-start coverage with no discrimination. Features so fine that each is seen once are as unlearnable as the items were. - **Consistency between training and serving.** The feature values must be computed the same way at fit time and at request time, or the cold item lands in the wrong place in the space. - **Honest evaluation.** Measuring on a random holdout hides the whole point. Hold out *items* — score items whose interactions were entirely removed from training — or you will not detect that the hybrid buys nothing.