Collaborative Filtering: When to Use It for Recommendations

You have a spreadsheet with 5,000 users and their ratings for 200 products. Your boss wants personalized recommendations by next week. You Google "recommendation engine" and get buried in academic papers about matrix factorization, singular value decomposition, and neural collaborative filtering. This guide walks through a way to suggest items from user activity.

Let me walk you through this step by step. We're going to start with a simple approach, finding similar users and recommending what they liked, and build from there. No PhD required.

Worked Example (Simulated): What Might User_1 Rate Item C?

Question: What might User_1 rate item C?

Inputs: Simulated data, seed 17. The table has ratings for items A to D. A dash means no rating. The pattern of which items each user rated is typed in by hand in the script. Only the rating values are random.

Method: Compare User_1 and User_2 on the items both rated. Cosine similarity is a score for how alike their ratings are. Use User_2's rating for C as a guess for User_1.

import numpy as np

seed = 17
rng = np.random.default_rng(seed)
# The rated-item pattern is typed by hand; only rating values are random.
known = np.array([
    [1, 1, 0, 0],
    [1, 1, 1, 0],
    [0, 1, 1, 1],
    [1, 1, 0, 1],
], dtype=bool)
ratings = rng.integers(1, 6, size=known.shape).astype(float)
ratings[~known] = np.nan

print(f"Simulated data, seed {seed}")
print("Columns: A B C D")
for i, row in enumerate(ratings):
    shown = ["-" if np.isnan(x) else str(int(x)) for x in row]
    print(f"User_{i + 1}: " + " ".join(shown))

# Compare User_1 and User_2 on shared items.
# Use User_2's C rating as a one-user guess.
a, b = ratings[0], ratings[1]
shared = ~np.isnan(a) & ~np.isnan(b)
x, y = a[shared], b[shared]
similarity = float(np.dot(x, y) / (np.linalg.norm(x) * np.linalg.norm(y)))
prediction = float(ratings[1, 2])
print(f"Shared items for User_1 and User_2: {int(shared.sum())}")
print(f"Cosine similarity on shared ratings: {similarity:.3f}")
print(f"User_2 rating for C: {prediction:.0f}")
print(f"Predicted rating for User_1 on C (single neighbor): {prediction:.1f}")

Printed output:

Simulated data, seed 17
Columns: A B C D
User_1: 4 5 - -
User_2: 3 3 4 -
User_3: - 2 3 2
User_4: 5 3 - 4
Shared items for User_1 and User_2: 2
Cosine similarity on shared ratings: 0.994
User_2 rating for C: 4
Predicted rating for User_1 on C (single neighbor): 4.0

Result: They share 2 ratings. Their cosine score is 0.994, but with only 2 shared ratings, a score this high is not strong evidence that the two users agree. User_2 rated C as 4, so the one-user guess for User_1 is 4.0.

Limit: This guess uses one other user. More users may rate C in a different way. Simulated data may not show how this works for real users.

Sources

• Koren Y, Bell R, Volinsky C (2009). Matrix Factorization Techniques for Recommender Systems. Computer 42(8). doi 10.1109/MC.2009.263. Cited for an overview of matrix factorization as a recommender method.
• Hu Y, Koren Y, Volinsky C (2008). Collaborative Filtering for Implicit Feedback Datasets. IEEE International Conference on Data Mining (ICDM). doi 10.1109/ICDM.2008.22. Cited for the topic of collaborative filtering from implicit feedback such as views and purchases.

What Collaborative Filtering Actually Means (In Plain English)

Before we jump into methodology, let's make sure we're on the same page about what collaborative filtering is.

Imagine you're at a bookstore. You loved "The Martian" by Andy Weir. The bookseller says, "People who bought that also loved 'Project Hail Mary.'" That's collaborative filtering. You're getting recommendations based on what similar readers enjoyed, not based on book genres or author similarities.

Collaborative filtering finds patterns in user behavior. It answers one fundamental question: If User A and User B liked the same things in the past, what else might they both enjoy?

There are two main flavors:

• User-based collaborative filtering: Find users similar to you, recommend what they liked
• Item-based collaborative filtering: Find items similar to what you liked, recommend those

Both approaches work. We'll focus on user-based first because the logic is more intuitive, then I'll show you when to switch to item-based.

Step 1: Structure Your Data (The User-Item Matrix)

Every collaborative filtering project starts with the same data structure: a user-item matrix. Let's build one together.

Here's what your raw data probably looks like: a transaction log or ratings table:

We need to transform this into a matrix where rows are users, columns are items, and cells contain ratings:

Notice all those blanks (shown as n/a)? That's normal. Most users haven't rated most items. This is called a sparse matrix, and it's the defining characteristic of collaborative filtering data.

What If You Don't Have Explicit Ratings?

No star ratings? No problem. You can use implicit feedback:

• Purchase history: 1 if purchased, 0 if not
• View counts: Number of times a user viewed a product
• Time spent: Minutes watching a video or reading an article
• Click-through: Did they click? Binary yes/no

Implicit feedback can be noisier than explicit ratings (someone might click by accident), but many businesses have more of it than they have star ratings. It is often handled differently from star ratings, since a missing action is not the same as a dislike. The Hu, Koren and Volinsky paper in Sources is on this topic.

Step 2: Calculate User Similarity (Finding Your User's Twins)

Now comes the core of collaborative filtering: measuring how similar users are to each other.

Let's say we want to recommend products to User_1. We need to find users who rated things similarly. A widely used similarity metric is cosine similarity.

Cosine Similarity: The Geometry of Taste

Think of each user as a vector in multi-dimensional space. Each dimension represents a product. The value in that dimension is the user's rating.

Cosine similarity measures the angle between two vectors. If two users have similar taste, their vectors point in the same direction (small angle = high similarity). If they have opposite taste, vectors point in opposite directions (large angle = low similarity).

The formula looks scary, but the concept is simple:

cosine_similarity(User_A, User_B) = (dot_product of ratings) / (magnitude_A × magnitude_B)

Cosine similarity ranges from -1 to 1:

• 1: Identical preferences (vectors point same direction)
• 0: No relationship (vectors perpendicular)
• -1: Opposite preferences (vectors point opposite directions)

Worked by Hand (Made-up Ratings)

Let's calculate similarity between User_1 and User_3 using the Step 1 matrix above (these are made-up ratings):

User_1 ratings: Product_A = 5, Product_B = 3
User_3 ratings: Product_A = 5, Product_B = 4

We only compare products both users rated (A and B).

Dot product = (5 × 5) + (3 × 4) = 25 + 12 = 37

Magnitude of User_1 = sqrt(5² + 3²) = sqrt(25 + 9) = sqrt(34) = 5.83
Magnitude of User_3 = sqrt(5² + 4²) = sqrt(25 + 16) = sqrt(41) = 6.40

Cosine similarity = 37 / (5.83 × 6.40) = 37 / 37.31 = 0.99

User_1 and User_2 share only Product_A (5 and 4). With one shared rating, cosine similarity is always 1.00, whatever the two numbers are, so that score carries no information about taste.

A similarity of 0.99 looks like nearly identical taste, but it rests on only two shared ratings, so treat it as unsure. With more overlap, whatever User_3 likes (but User_1 hasn't tried yet) becomes a stronger candidate to suggest to User_1.

Alternative Similarity Metrics

Cosine similarity is popular, but not the only option:

• Pearson correlation: Accounts for rating scale differences (some users rate everything 5 stars, others are harsh critics). Use this when rating scales vary between users.
• Jaccard similarity: For binary data (purchased vs not purchased). Measures overlap in purchase sets.
• Euclidean distance: Measures direct distance between rating vectors. Simpler but less effective with sparse data.

Cosine similarity is a reasonable first metric to try. It is simple to compute and is often used on sparse rating data, but compare it with the other metrics on held-out data before you settle on one.

Step 3: Generate Predictions (Weighted Averages That Work)

You've found User_1's similar users. Now what? You need to predict what User_1 would rate for products they haven't seen yet.

The logic is beautifully simple: take a weighted average of how similar users rated that product.

The Prediction Formula

Let's predict User_1's rating for Product_C (which they haven't rated yet).

From our similarity calculations:

• User_3 (similarity 0.99, two shared ratings) rated Product_C: 4 stars
• User_2 (similarity 1.00, but from one shared rating) rated Product_C: 5 stars

Weighted prediction formula:

Predicted rating = Σ(similarity × rating) / Σ(similarity)

For Product_C:
Predicted rating = [(0.99 × 4) + (1.00 × 5)] / (0.99 + 1.00)
                 = [3.96 + 5.00] / 1.99
                 = 8.96 / 1.99
                 = 4.50 stars

With these made-up ratings the weighted guess for User_1 on Product_C is about 4.5 stars. Only two other users rated Product_C, and one of the two similarity scores rests on a single shared rating, so treat this as a rough guess, not a firm prediction.

Accounting for User Rating Bias

Some users are generous raters (average rating: 4.5 stars). Others are critics (average rating: 2.5 stars). If you ignore this, your predictions will be skewed.

The solution: center ratings around each user's mean.

Adjusted formula:

Predicted rating = User_A_mean + [Σ(similarity × (rating - User_mean)) / Σ(similarity)]

This subtracts each similar user's mean rating from their actual rating (capturing how much they liked it relative to their baseline), then adds back User_1's mean rating to get a prediction on User_1's scale.

From the Step 1 matrix, User_1's average rating is 4.0 (5 and 3), User_3's is 3.75 (5, 4, 4 and 2), and User_2's is 4.5 (4 and 5).

Adjusted prediction = 4.0 + [(0.99 × (4 - 3.75)) + (1.00 × (5 - 4.5))] / (0.99 + 1.00)
                    = 4.0 + [(0.99 × 0.25) + (1.00 × 0.5)] / 1.99
                    = 4.0 + 0.7475 / 1.99
                    = 4.0 + 0.38
                    = 4.38 stars

The adjusted guess (4.38) is a little lower than the unadjusted 4.50. User_2's 5 is only half a star above their own average of 4.5, so it counts for less once each rater's baseline is removed. The same caution applies: two neighbors, one with a single shared rating.

Step 4: Rank and Recommend (Turning Predictions Into Action)

You've calculated predicted ratings for all products User_1 hasn't seen. Now you need to decide what to actually recommend.

Top-N Recommendations

The simplest approach: rank products by predicted rating and recommend the top 5 or top 10.

But wait. There's a catch. High predicted ratings often go to popular items that everyone likes. You might end up recommending the same bestsellers to everyone.

Balancing Relevance and Diversity

Good recommendation systems balance:

• Relevance: High predicted rating (user will like it)
• Diversity: Show variety (don't recommend 10 similar items)
• Novelty: Surface less-known items (increase discovery)
• Serendipity: Occasionally surprise with something unexpected

Here's a practical ranking strategy:

1. Filter candidates: Only consider items with predicted rating ≥ 4.0 (or your threshold)
2. Boost diversity: Group items by category, include at least one from each category
3. Add exploration: Include 1-2 items from less popular categories or new arrivals
4. Apply business rules: Promote items with higher margins, in-stock inventory, or seasonal relevance

Step 5: Evaluate and Iterate (How to Know If It's Working)

You've built a recommendation engine. But is it any good? Let's measure that.

Offline Evaluation (Before You Go Live)

Split your data: build the model on most of it and hold out the rest to test predictions.

Key metrics:

• RMSE (Root Mean Squared Error): Lower is better. RMSE is the square root of the mean of squared guess errors. It is not the mean absolute error. Squaring gives more weight to large errors.
• Precision@K: Of your top K recommendations, what percentage did the user actually like? If you recommend 10 items and the user liked 6, precision@10 = 0.60.
• Recall@K: Of all items the user liked, what percentage did you capture in your top K? If the user liked 20 items total and you recommended 6 of them, recall = 0.30.

Online Evaluation (The Real Test)

Offline metrics don't tell the whole story. You need to measure actual user behavior:

• Click-through rate (CTR): Percentage of users who click on recommendations
• Conversion rate: Percentage who purchase recommended items
• Average order value (AOV): Revenue from orders containing recommended items
• Engagement over time: Do users keep clicking recommendations after week 1?

Run A/B tests: show half your users collaborative filtering recommendations, half your users a baseline (popular items or random items). Measure the difference in conversion and revenue.

When to Retrain Your Model

User preferences change. Inventory changes. Seasonal trends emerge. Your model needs regular updates.

Retrain when:

• Weekly or monthly: For fast-moving inventory (e-commerce, news)
• Quarterly: For stable catalogs (enterprise software, B2B)
• After major changes: New product lines, seasonal shifts, major marketing campaigns

Set an alert using a chosen baseline and time span. Check the trend before you retrain.

User-Based vs Item-Based: When to Switch Approaches

So far, we've focused on user-based collaborative filtering (find similar users, recommend what they liked). But item-based collaborative filtering can be easier to run in production. Let me explain when to use each.

Item-Based Collaborative Filtering

Instead of finding similar users, you find similar items. If a user liked Product_A, recommend products similar to Product_A.

Item similarity is calculated the same way as user similarity, but you flip the matrix. Now rows are items, columns are users, and cells contain ratings.

Why item-based can be easier to run:

• Stability: Item relationships change slowly. You can pre-compute item similarities and cache them. User preferences change constantly, requiring frequent recalculation.
• Scalability: Most systems have more users than items. Computing item-item similarities (items × items) is cheaper than user-user (users × users).
• Explainability: "You liked The Martian, so we recommend Project Hail Mary" is clearer than "Users similar to you liked this."

Decision Framework

Item-based is a common choice for e-commerce and content platforms. For social networks or niche communities with stable users, user-based can suit better.

Matrix Factorization: When Simple Similarity Isn't Enough

User-based and item-based collaborative filtering work well with dense data. But when most of your matrix is empty, they can struggle.

Matrix factorization solves this by finding latent factors: hidden patterns that explain user preferences.

The Intuition Behind Matrix Factorization

Imagine you're predicting movie ratings. Users and movies have underlying characteristics:

• User factors: Likes action movies (0.9), likes romance (-0.3), likes sci-fi (0.7)
• Movie factors: The Martian has action (0.6), romance (0.1), sci-fi (0.9)

To predict a rating, multiply the user vector by the movie vector:

Predicted rating = (0.9 × 0.6) + (-0.3 × 0.1) + (0.7 × 0.9)
                 = 0.54 - 0.03 + 0.63
                 = 1.14 (on a normalized scale)

The magic: you don't manually define these factors. The algorithm learns them from the data.

When to Use Matrix Factorization

Matrix factorization (techniques like SVD, ALS, NMF) can work better when:

• Your matrix is very sparse
• You have many ratings to learn from
• You need high prediction accuracy
• You can tolerate longer computation time

Start with simple user-based or item-based collaborative filtering. If performance plateaus, graduate to matrix factorization.

The Cold Start Problem (And How to Handle It)

Collaborative filtering has an Achilles heel: it needs data to work. What do you recommend to:

• New users: No rating history
• New items: No one has rated them yet

This is the cold start problem. Here's how to handle it.

For New Users

Option 1: Onboarding questionnaire
Ask new users to rate 5-10 items during signup. "Tell us your favorites" builds an instant profile.

Option 2: Demographic defaults
Until you have user-specific data, recommend based on demographic group (age, location, gender). Crude but better than nothing.

Option 3: Popular items
Show trending or bestselling items. Most new users expect this anyway.

For New Items

Option 1: Content-based filtering
Use item attributes (category, brand, price, description) to find similar items. Recommend the new item to users who liked those similar items.

Option 2: Exploration sampling
Show the new item to a random sample of users. Track who engages. Use that initial feedback to start collaborative filtering.

Option 3: Hybrid model
Combine collaborative filtering (when you have data) with content-based filtering (when you don't). Weight each method based on data availability.

Putting It All Together: Your Implementation Checklist

You've learned the methodology. Now let's make sure you're ready to implement.

Common Implementation Mistakes to Avoid

• Not normalizing ratings: Some users rate everything high, others low. Always center ratings around user means.
• Ignoring data sparsity: If your matrix is almost empty, simple similarity may not work. Use matrix factorization or hybrid methods.
• Recommending already-purchased items: Filter out items the user already owns (unless they're consumables).
• No diversity in recommendations: Don't show 10 nearly-identical items. Group by category and enforce variety.
• Not handling cold start: New users and new items need special treatment. Have a fallback strategy.
• Ignoring temporal effects: User preferences change over time. Weight recent interactions more heavily than old ones.