User-Item Interaction Matrix

The Cold Start Problem — When the Engine Has No Fuel

The New User Problem

The new user problem occurs because collaborative filtering requires interaction history to compute user similarity. With no rated items, no watched videos, no purchased products, the user vector is entirely empty — every entry is NaN. You cannot compute meaningful cosine similarity between an empty vector and any other vector.

The Exploration-Exploitation Dilemma for New Users

The new user problem is fundamentally an exploration-exploitation trade-off. To learn what a user likes, the system must show them items — but without knowing what they like, it doesn't know which items to show. Every recommendation is simultaneously a guess and a data collection opportunity. The faster the system learns, the sooner personalisation kicks in — and the sooner the user gets value.

The New Item Problem

The new item problem is the column-side equivalent of the new user problem. When a new item is added to the catalogue, its column in the interaction matrix is entirely empty. No user has rated it, clicked it, or watched it. Collaborative filtering cannot place it relative to other items because there is no co-rating data to compare against.

Data Sparsity — The Cold Start Amplifier

import numpy as np
import pandas as pd

# ── Simulating density collapse as platform grows ─────────────
# Assume avg user interacts with k items regardless of catalogue size
k_avg = 50   # avg interactions per user

platform_stages = [
    {'stage':'Startup',    'users':1_000,     'items':500},
    {'stage':'Early',     'users':50_000,    'items':5_000},
    {'stage':'Growth',    'users':500_000,   'items':50_000},
    {'stage':'Scale',     'users':5_000_000, 'items':500_000},
    {'stage':'Netflix',   'users':280_000_000,'items':15_000},
]

for p in platform_stages:
    total       = p['users'] * p['items']
    observed    = p['users'] * min(k_avg, p['items'])
    density     = observed / total
    cold_window = 10 / k_avg   # sessions before warm-up
    print(f"{p['stage']:12s} | "
          f"users={p['users']:>12,} | "
          f"items={p['items']:>8,} | "
          f"density={density:>10.4%} | "
          f"cold_sessions≈{cold_window:.1f}")

Solutions — Solving New User Cold Start

import pandas as pd
import numpy as np

# ── Onboarding-based warm start ───────────────────────────────
# Existing users with known genre preferences
users = pd.DataFrame({
    'user'     : ['Ali', 'Ben', 'Cara', 'Dev'],
    'age_grp'  : ['18-24', '25-34', '18-24', '25-34'],
    'sci_fi'   : [0.9, 0.3, 0.8, 0.4],
    'thriller' : [0.7, 0.6, 0.6, 0.8],
    'comedy'   : [0.2, 0.9, 0.3, 0.5],
    'drama'    : [0.5, 0.7, 0.9, 0.6],
})

# ── New user says: "I like Sci-Fi and Thriller" (onboarding) ─
new_user_prefs = {'sci_fi': 1, 'thriller': 1, 'comedy': 0, 'drama': 0}
genre_cols = ['sci_fi', 'thriller', 'comedy', 'drama']

# ── Find most similar existing users by onboarding vector ────
new_vec = np.array([new_user_prefs[g] for g in genre_cols])

def cosine(a, b):
    d = np.linalg.norm(a) * np.linalg.norm(b)
    return np.dot(a, b) / d if d > 0 else 0

users['similarity'] = users[genre_cols].apply(
    lambda row: cosine(row.values, new_vec), axis=1
)
top_neighbours = users.nlargest(2, 'similarity')

print("New user onboarding preferences:")
print(f"  Sci-Fi=1, Thriller=1, Comedy=0, Drama=0\n")
print("Nearest neighbours from onboarding match:")
print(top_neighbours[['user','sci_fi','thriller','similarity']]
      .to_string(index=False))

# ── Bootstrap: use neighbours' item ratings as warm start ─────
item_ratings = {
    'Ali'  : {'Dune':5, 'Arrival':4, 'Interstellar':5},
    'Cara' : {'Dune':4, 'Tenet':5, 'Blade Runner':5},
}
warm_start_items = set()
for u in top_neighbours['user']:
    if u in item_ratings:
        warm_start_items.update(item_ratings[u].keys())
print(f"\nWarm-start recommendations for new user:")
for item in warm_start_items:
    print(f"  → {item}")

Solutions — Solving New Item Cold Start

import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# ── Existing items with content features ──────────────────────
catalogue = pd.DataFrame({
    'title': ['Inception', 'Interstellar', 'Dune',
               'Arrival', 'The Matrix', 'Parasite'],
    'soup' : [
        'scifi thriller dream nolan heist subconscious mind',
        'scifi epic space nolan wormhole relativity love',
        'scifi epic desert villeneuve political chosen hero',
        'scifi alien language time villeneuve linguistics',
        'scifi action hacker simulation reality rebellion',
        'thriller drama class korean dark social satire',
    ],
    'avg_rating': [4.8, 4.7, 4.5, 4.3, 4.6, 4.9],
})

# ── New item just added to catalogue ─────────────────────────
new_item = {
    'title': 'Tenet',
    'soup' : 'scifi action espionage nolan time reversal spy',
}

# ── Build TF-IDF on all items including new one ───────────────
all_soups = list(catalogue['soup']) + [new_item['soup']]
tfidf     = TfidfVectorizer()
tfidf_m   = tfidf.fit_transform(all_soups)

# New item vector is the last row
new_vec   = tfidf_m[-1]
exist_m   = tfidf_m[:-1]

# ── Compute similarity to existing items ──────────────────────
sims = cosine_similarity(new_vec, exist_m).flatten()
catalogue['content_sim'] = sims

# ── Find top-k content neighbours ────────────────────────────
top_k    = catalogue.nlargest(3, 'content_sim')

print(f"New item: '{new_item['title']}'")
print("\nContent neighbours (cold-start bridge):")
print(top_k[['title','content_sim','avg_rating']].to_string(index=False))

# ── Inherit predicted rating from neighbours ─────────────────
weighted_sum = (top_k['content_sim'] * top_k['avg_rating']).sum()
weight_total = top_k['content_sim'].sum()
predicted    = weighted_sum / weight_total

print(f"\nPredicted rating for '{new_item['title']}' "
      f"(from content bridge): {predicted:.2f} / 5.0")

Advanced Solutions — Hybrid and Adaptive Strategies

import numpy as np

# ── Adaptive cold-start routing system ───────────────────────

def get_recommendations(user_id, n_interactions, user_features=None):
    """
    Route to the appropriate recommendation strategy
    based on how many interactions the user has accumulated.
    """

    if n_interactions == 0:
        strategy = 'global_popularity'
        recs     = ['Top Movie 1', 'Top Movie 2', 'Top Movie 3']

    elif n_interactions < 5:
        strategy = 'demographic_prior'
        segment  = user_features.get('segment', 'general') if user_features else 'general'
        recs     = [f'Segment-{segment} Top 1', f'Segment-{segment} Top 2',
                   f'Onboarding Genre Pick 1']

    elif n_interactions < 20:
        strategy = 'content_based_session'
        recs     = ['Content-Similar A', 'Session-Inferred B',
                   'Genre-Match C']

    elif n_interactions < 50:
        strategy = 'hybrid_cf_cb'
        cf_weight = n_interactions / 50         # more CF as data grows
        cb_weight = 1 - cf_weight
        recs = [f'Hybrid(CF={cf_weight:.0%}, CB={cb_weight:.0%}) Item {i}'
                for i in range(1, 4)]

    else:
        strategy = 'full_collaborative_filtering'
        recs     = ['CF-Personalised A', 'CF-Personalised B',
                   'CF-Personalised C']

    return strategy, recs

# ── Simulate a user's journey from cold to warm ───────────────
stages = [(0, None), (3, {'segment':'sci_fi_fans'}),
          (12, None), (35, None), (80, None)]

print(f"{'Interactions':>14} {'Strategy':>30} {'Top Recommendation'}")
print("-" * 75)
for n, feats in stages:
    strat, recs = get_recommendations('new_user', n, feats)
    print(f"{n:>14} {strat:>30}   {recs[0]}")

Complete Solutions Reference — Cold Start Toolkit