User-based vs item-based in ML Python

Introduction

We want to recommend things people might like by looking at either similar users or similar items.

When you want to suggest movies to a user based on what similar users liked.

When you want to recommend products similar to what a user already bought.

When you have user ratings and want to find new items for a user.

When you want to improve recommendations by focusing on item similarities.

When you want to build a simple recommendation system for a website.

Syntax

ML Python

User-based Collaborative Filtering:
1. Find users similar to the target user.
2. Recommend items liked by those similar users.

Item-based Collaborative Filtering:
1. Find items similar to the items the user liked.
2. Recommend those similar items to the user.

User-based looks at people like you.

Item-based looks at things like what you liked.

Examples

This example shows how to find similar users and recommend their items.

ML Python

User-based:
User A likes items 1, 2
User B likes items 2, 3
User C likes items 1, 3
To recommend for User A, find users like B or C and suggest their liked items.

This example shows how to find items similar to what the user likes.

ML Python

Item-based:
User A likes item 1
Find items similar to item 1 (like item 2)
Recommend item 2 to User A.

Sample Model

This code shows how to compute user-based and item-based recommendations using cosine similarity on a small rating matrix.

ML Python

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# User-item rating matrix (rows: users, cols: items)
ratings = np.array([
    [5, 3, 0, 1],  # User 0
    [4, 0, 0, 1],  # User 1
    [1, 1, 0, 5],  # User 2
    [1, 0, 0, 4],  # User 3
    [0, 1, 5, 4],  # User 4
])

# User-based Collaborative Filtering
user_sim = cosine_similarity(ratings)

# Recommend for User 0
user_id = 0
similar_users = np.argsort(-user_sim[user_id])  # descending order

print(f"User similarities for User {user_id}: {user_sim[user_id]}")
print(f"Users sorted by similarity: {similar_users}")

# Find items liked by similar users but not by User 0
user_0_items = ratings[user_id] > 0
recommendations = np.zeros(ratings.shape[1])
for other_user in similar_users[1:]:  # skip self
    other_items = ratings[other_user] > 0
    new_items = other_items & ~user_0_items
    recommendations += ratings[other_user] * new_items

print(f"User-based recommendation scores for User {user_id}: {recommendations}")

# Item-based Collaborative Filtering
item_sim = cosine_similarity(ratings.T)

# Items User 0 liked
liked_items = np.where(user_0_items)[0]

# Sum similarity scores for items similar to liked items
item_recommendation_scores = np.zeros(ratings.shape[1])
for item in liked_items:
    item_recommendation_scores += item_sim[item]

# Remove items already liked
item_recommendation_scores[liked_items] = 0

print(f"Item similarities matrix:\n{item_sim}")
print(f"Item-based recommendation scores for User {user_id}: {item_recommendation_scores}")

Important Notes

User-based can be slow if many users exist.

Item-based is often faster and more stable.

Both need enough data to find good similarities.

Summary

User-based recommends items liked by similar users.

Item-based recommends items similar to what the user liked.

Both help suggest new things in recommendation systems.