Introduction

A recommendation system usually answers two related questions: which users behave similarly, and which items tend to be liked together. Even simple collaborative-filtering models can answer both questions by representing user behavior as vectors and comparing those vectors with a similarity metric such as cosine similarity.

User-Based And Item-Based Collaborative Filtering

User-based collaborative filtering looks for users whose rating patterns resemble the current user. Item-based collaborative filtering flips the matrix and looks for items that attract similar audiences.

Suppose you have a small ratings matrix where rows are users and columns are items:

1import pandas as pd
2
3ratings = pd.DataFrame(
4    {
5        "book_a": [5, 4, 0, 1],
6        "book_b": [4, 5, 1, 0],
7        "book_c": [0, 1, 5, 4],
8        "book_d": [1, 0, 4, 5],
9    },
10    index=["alice", "bob", "carol", "dave"],
11)
12
13print(ratings)

Zeros here mean "no rating" for simplicity, though a production system should usually distinguish missing data from an actual zero score.

Computing Similarity Between Users

Cosine similarity is a common first step because it compares direction rather than raw magnitude.

1import numpy as np
2
3
4def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
5    denom = np.linalg.norm(a) * np.linalg.norm(b)
6    if denom == 0:
7        return 0.0
8    return float(np.dot(a, b) / denom)
9
10
11alice = ratings.loc["alice"].to_numpy(dtype=float)
12bob = ratings.loc["bob"].to_numpy(dtype=float)
13print(cosine_similarity(alice, bob))

A high value means the two users rated items in a similar pattern. Once you can compute one pair, you can rank all neighbors for a target user.

Recommending Items To A User

A basic user-based recommender can score unseen items using the weighted ratings of similar users.

1def recommend_for_user(user_name: str, top_n: int = 2):
2    target = ratings.loc[user_name]
3    sims = {}
4
5    for other_name, row in ratings.iterrows():
6        if other_name == user_name:
7            continue
8        sims[other_name] = cosine_similarity(
9            target.to_numpy(dtype=float), row.to_numpy(dtype=float)
10        )
11
12    scores = {}
13    for item in ratings.columns:
14        if target[item] != 0:
15            continue
16        weighted_sum = 0.0
17        sim_sum = 0.0
18        for other_name, sim in sims.items():
19            rating = ratings.loc[other_name, item]
20            if rating == 0:
21                continue
22            weighted_sum += sim * rating
23            sim_sum += sim
24        if sim_sum > 0:
25            scores[item] = weighted_sum / sim_sum
26
27    return sorted(scores.items(), key=lambda pair: pair[1], reverse=True)[:top_n]
28
29
30print(recommend_for_user("alice"))

This is intentionally small and readable rather than industrial-strength. It demonstrates the structure of a recommendation pipeline without requiring extra libraries.

Finding Similar Items

Item-based recommendations often perform better in systems with many users and a stable item catalog. The idea is to compare columns instead of rows.

1def similar_items(item_name: str):
2    target = ratings[item_name].to_numpy(dtype=float)
3    result = []
4    for other in ratings.columns:
5        if other == item_name:
6            continue
7        sim = cosine_similarity(target, ratings[other].to_numpy(dtype=float))
8        result.append((other, sim))
9    return sorted(result, key=lambda pair: pair[1], reverse=True)
10
11
12print(similar_items("book_a"))

This gives a ranked list of items consumed by similar users.

Data Sparsity Matters

Real recommendation data is sparse. Most users interact with only a small fraction of the catalog, so dense matrix code becomes wasteful quickly. Production systems often use sparse-matrix representations, approximate nearest-neighbor search, or factorization models. Still, the small vector approach is the right place to learn the mechanics.

Choosing A Similarity Metric

Cosine similarity is popular because it is easy to compute and works reasonably well for many implicit-feedback problems. Pearson correlation can be useful when you care more about rating trends than absolute values. Jaccard similarity is often a better fit when the data is binary, such as whether a user clicked or purchased an item.

The best metric depends on what the numbers mean, not on which formula is most common in tutorials.

Common Pitfalls

The first mistake is treating missing data as a real zero without thinking through the effect on similarity. Another is recommending items the user already consumed because the scoring step forgot to exclude known interactions. Developers also often build a beautiful similarity matrix before asking whether the catalog is too sparse for memory-heavy dense operations. Finally, recommendation quality depends heavily on evaluation, so do not assume a mathematically neat similarity score automatically produces useful product behavior.

Summary

• User-based filtering compares users; item-based filtering compares items.
• Cosine similarity is a good baseline for vector-style recommendation experiments.
• A simple weighted-neighbor score can recommend unseen items.
• Real systems must handle sparse data and evaluation carefully.
• The right similarity metric depends on whether your data represents ratings, clicks, or another signal.