Types of Recommendation Systems

The Five Families of Recommendation Systems

Content-Based Filtering

Content-Based Filtering recommends items similar to those a user has interacted with positively in the past — based purely on the features of the items themselves. It builds a profile of the user's taste from item attributes, then finds items whose feature vectors are closest to that profile.

TF-IDF for Text-Based Content Filtering

For text-heavy items (articles, job listings, product descriptions), the most common feature representation is TF-IDF (Term Frequency – Inverse Document Frequency). It weights words by how distinctive they are to a document relative to the whole corpus — suppressing common words like "the" and amplifying rare, meaningful ones.

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

# ── Sample movie dataset with text descriptions ──────────────
movies = pd.DataFrame({
    'title': [
        'Inception', 'Interstellar', 'Dune', 'The Matrix',
        'Arrival', 'Parasite', '1917', 'Tenet'
    ],
    'soup': [
        'sci-fi thriller dream heist nolan subconscious layered',
        'sci-fi space epic nolan wormhole relativity emotional',
        'sci-fi epic desert chosen-one villeneuve political',
        'sci-fi action simulation reality hacker rebellion',
        'sci-fi alien language time thriller emotional villeneuve',
        'thriller drama class-divide korean dark comedy',
        'war drama one-shot wwii emotional sacrifice',
        'sci-fi action espionage time-reversal nolan thriller',
    ]
})

# ── Build TF-IDF matrix ───────────────────────────────────────
tfidf   = TfidfVectorizer(stop_words='english')
tfidf_m = tfidf.fit_transform(movies['soup'])

# ── Pairwise cosine similarity ────────────────────────────────
cos_sim = cosine_similarity(tfidf_m, tfidf_m)

# ── Recommend function ────────────────────────────────────────
def recommend_cb(title, top_n=3):
    idx    = movies[movies['title'] == title].index[0]
    scores = list(enumerate(cos_sim[idx]))
    scores = sorted(scores, key=lambda x: -x[1])
    top    = [movies['title'].iloc[i] for i, _ in scores[1:top_n+1]]
    return top

print("Because you watched Inception:")
print(recommend_cb('Inception'))

print("\nBecause you watched Arrival:")
print(recommend_cb('Arrival'))

Collaborative Filtering

Collaborative Filtering (CF) predicts a user's preferences by collecting and analysing interaction data from many users — collaborating to filter the item space. It operates entirely on the user-item interaction matrix, requiring no knowledge of item content or user demographics.

Two Variants: Memory-Based vs Model-Based

import numpy as np
from surprise import SVD, Dataset, Reader
from surprise.model_selection import cross_validate
import pandas as pd

# ── Build a synthetic ratings dataset ────────────────────────
ratings_dict = {
    'userID':  ['Ali','Ali','Ali','Ben','Ben','Ben','Cara','Cara','Dev','Dev'],
    'itemID':  ['A','B','C','A','B','D','B','C','A','C'],
    'rating':  [5,4,3,4,5,2,3,5,5,4],
}
df     = pd.DataFrame(ratings_dict)
reader = Reader(rating_scale=(1, 5))
data   = Dataset.load_from_df(df[['userID', 'itemID', 'rating']], reader)

# ── SVD Matrix Factorisation ──────────────────────────────────
svd = SVD(n_factors=20, n_epochs=30, lr_all=0.005, reg_all=0.02)

# ── 5-fold cross-validation ───────────────────────────────────
results = cross_validate(svd, data, measures=['RMSE', 'MAE'], cv=5, verbose=False)
print(f"SVD RMSE: {results['test_rmse'].mean():.4f}")
print(f"SVD MAE : {results['test_mae'].mean():.4f}")

# ── Predict a missing rating: Ali on item D ───────────────────
trainset = data.build_full_trainset()
svd.fit(trainset)
pred = svd.predict('Ali', 'D')
print(f"\nPredicted rating — Ali on Item D: {pred.est:.2f}")

Hybrid Recommendation Systems

Four Hybridisation Strategies

import numpy as np

# ── Simulated scores from three separate models ───────────────
# Each array: scores for 8 candidate items for a specific user
cf_scores   = np.array([0.91, 0.44, 0.72, 0.88, 0.31, 0.65, 0.52, 0.79])
cb_scores   = np.array([0.78, 0.82, 0.61, 0.55, 0.90, 0.47, 0.69, 0.33])
ctx_scores  = np.array([0.60, 0.70, 0.85, 0.45, 0.55, 0.90, 0.40, 0.75])

items = ['Dune', 'Parasite', 'Arrival', 'Inception',
         'Midsommar', '1917', 'Annihilation', 'Interstellar']

# ── Weighted hybrid fusion ────────────────────────────────────
alpha, beta, gamma = 0.55, 0.30, 0.15
hybrid_scores = alpha * cf_scores + beta * cb_scores + gamma * ctx_scores

# ── Rank by hybrid score ──────────────────────────────────────
ranked = sorted(zip(items, hybrid_scores), key=lambda x: -x[1])

print("Hybrid Recommendations (Top-5):")
for rank, (item, score) in enumerate(ranked[:5], 1):
    print(f"  {rank}. {item:15s}  score={score:.3f}")

Knowledge-Based Recommendation Systems

Knowledge-Based Systems recommend items using explicit knowledge about users' requirements, preferences, and item attributes — combined with domain-expert knowledge about what makes items suitable for certain needs. They do not rely on interaction history at all.

# ── Constraint-Based Knowledge Recommender — Laptop Example ──

laptops = [
    {'name':'ProBook X1',  'price':1200, 'battery_h':10, 'weight_kg':1.4, 'ram_gb':16, 'gpu':True},
    {'name':'SlimAir 3',   'price':950,  'battery_h':14, 'weight_kg':1.1, 'ram_gb':8,  'gpu':False},
    {'name':'WorkForce 15','price':1500, 'battery_h':8,  'weight_kg':2.1, 'ram_gb':32, 'gpu':True},
    {'name':'UltraBook Z', 'price':1100, 'battery_h':12, 'weight_kg':1.2, 'ram_gb':16, 'gpu':False},
    {'name':'PowerEdge G', 'price':800,  'battery_h':6,  'weight_kg':2.5, 'ram_gb':16, 'gpu':True},
]

# ── User requirements (hard constraints) ─────────────────────
user_req = {
    'max_price':     1300,
    'min_battery_h': 10,
    'max_weight_kg': 1.5,
    'min_ram_gb':    16,
}

# ── Soft preference: minimise weight (lower = better) ────────
def knowledge_recommend(laptops, req):
    candidates = [
        l for l in laptops
        if l['price']      <= req['max_price']
        and l['battery_h'] >= req['min_battery_h']
        and l['weight_kg'] <= req['max_weight_kg']
        and l['ram_gb']    >= req['min_ram_gb']
    ]
    # Rank surviving candidates by weight (lightest first)
    return sorted(candidates, key=lambda x: x['weight_kg'])

results = knowledge_recommend(laptops, user_req)
print("Laptops matching your requirements:")
for r in results:
    print(f"  {r['name']:15s} £{r['price']} | {r['battery_h']}h | {r['weight_kg']}kg | {r['ram_gb']}GB")

Session-Based Recommendation Systems

Session-Based Systems generate recommendations using only the sequence of user interactions within the current browsing session — no long-term user profile is needed or used. They are essential for: anonymous users, platforms with high user turnover, and any context where current intent matters more than historical preference.

Two Dominant Approaches

import numpy as np

# ── Simplified Markov Chain Session Recommender ───────────────
# Transition matrix: P(next_item | current_item)

items = ['Running Shoes', 'Running Socks', 'Water Bottle',
         'Energy Gels', 'GPS Watch', 'Compression Leggings']

# Row i → probability of transitioning to item j next
transitions = np.array([
    [0.00, 0.40, 0.25, 0.10, 0.15, 0.10],  # Running Shoes →
    [0.30, 0.00, 0.20, 0.25, 0.15, 0.10],  # Running Socks →
    [0.15, 0.15, 0.00, 0.40, 0.20, 0.10],  # Water Bottle →
    [0.10, 0.15, 0.20, 0.00, 0.30, 0.25],  # Energy Gels →
    [0.20, 0.10, 0.25, 0.15, 0.00, 0.30],  # GPS Watch →
    [0.30, 0.20, 0.10, 0.15, 0.25, 0.00],  # Compression Leggings →
])

def session_recommend(session_clicks, top_n=3):
    # Accumulate transition probabilities for the whole session
    scores = np.zeros(len(items))
    for click in session_clicks:
        idx     = items.index(click)
        scores += transitions[idx]
    # Zero out already-seen items
    seen_idx = [items.index(c) for c in session_clicks]
    scores[seen_idx] = 0
    top_idx = np.argsort(scores)[::-1][:top_n]
    return [(items[i], round(scores[i], 3)) for i in top_idx]

session = ['Running Shoes', 'Running Socks', 'Water Bottle', 'Energy Gels']
recs = session_recommend(session)

print("Session-based recommendations:")
for item, score in recs:
    print(f"  → {item:25s}  score={score}")

Choosing the Right System — The Decision Framework