Core ML

Implicit Feedback

Deducing what a user likes by observing their silent actions (clicking, watching, scrolling) rather than asking them to explicitly rate an item with 5 stars.

Why Does This Exist?

In the early days of machine learning (like the 2006 Netflix Prize), all recommender systems were built on Explicit Feedback. If you wanted Netflix to know you liked a movie, you had to manually click "5 Stars".

This created massive problems:

Scarcity: 99% of users never rate anything. If a user watches 100 movies and rates 0 of them, an explicit-feedback system thinks the user doesn't exist.
Bias: People only rate extremes. They rate movies they absolutely loved (5 stars) or absolutely hated (1 star). They never rate "okay" movies (3 stars).
Lying: People rate documentaries 5-stars because they want to feel smart, but they actually binge-watch trashy reality TV.

Modern systems rely almost entirely on Implicit Feedback. We don't ask what you like. We observe what you do. If you click a video, that's a signal. If you watch it to the end, that's a huge positive signal. If you skip it after 3 seconds, that's a negative signal.

Think of It Like This

Imagine running a restaurant and trying to figure out if people like the new soup.

Explicit Feedback: You put a survey card on the table asking "Rate this soup 1 to 5." Only the angriest customers and your closest friends fill it out. The data is heavily skewed.

Implicit Feedback: You stand by the dishwasher and look at the bowls coming back from the dining room. If the bowls are licked clean, the soup is a massive success. If the bowls are mostly full, the soup is terrible. You get 100% participation without ever asking a single question.

How It Actually Works

Modeling implicit feedback requires a fundamental shift in the math behind Matrix Factorization.

With explicit ratings (1 to 5 stars), the goal of the algorithm is to predict the exact rating. With implicit feedback (clicks, watch time), the goal is to predict Preference and Confidence.

Preference vs. Confidence

Let's say we are tracking how many times a user listens to a song.

$r_{ui} = 0$ : The user has never listened to the song.
$r_{ui} = 20$ : The user has listened to the song 20 times.

Preference ( $p$ ): Did they like it? It's binary. If they listened to it at all ( $r > 0$ ), we assume $p = 1$ (They like it). If they never listened to it, $p = 0$ .

Confidence ( $c$ ): How sure are we that they like it? If they listened 1 time, $p=1$ , but our confidence is very low. Maybe they clicked it by accident. If they listened 20 times, $p=1$ , and our confidence is extremely high. If they listened 0 times, $p=0$ , but our confidence is low. Maybe they actually hate it, or maybe they just haven't discovered it yet.

ALS for Implicit Data

A famous algorithm called Alternating Least Squares (ALS) for Implicit Feedback modifies the Matrix Factorization loss function. It tries to predict the binary Preference ( $p$ ), but it multiplies the error by the Confidence ( $c$ ). If the model wrongly predicts that a user hates a song they've listened to 50 times, the error is multiplied by a massive Confidence score, forcing the model to fix its mistake.

Show Me the Code

In Python, the implicit library is the industry standard for fast, C++ optimized implicit matrix factorization.

1import implicit2import scipy.sparse as sparse3import numpy as np4
5# 1. Create a sparse matrix of Implicit Feedback6# Rows = Users, Columns = Items, Values = Number of Clicks/Plays7# Imagine User 0 clicked Item 1 exactly 5 times.8clicks = np.array([5, 1, 10, 2])9rows = np.array([0, 0, 1, 2])10cols = np.array([1, 2, 0, 1])11
12# The implicit library requires an Item-User matrix, so we create it13item_user_matrix = sparse.csr_matrix((clicks, (cols, rows)))14
15# 2. Initialize the ALS model16model = implicit.als.AlternatingLeastSquares(factors=50, iterations=15)17
18# 3. Train the model on the implicit data19# The library automatically calculates the Confidence weights based on the click counts20model.fit(item_user_matrix)21
22# 4. Recommend items for User 023user_id = 024recommendations = model.recommend(user_id, item_user_matrix.T)25
26print(f"Top recommendations for User {user_id}:")27for item, score in recommendations:28    print(f"Item {item} (Score: {score:.2f})")

Watch Out For

The problem of negative samples. In explicit feedback, a 1-star rating is a clear "I hate this." In implicit feedback, you only have positive signals (clicks). A lack of a click does not mean the user hates the item; it usually just means they never saw it. Algorithms like BPR (Bayesian Personalized Ranking) try to solve this by randomly sampling unclicked items and assuming they are negative, but this requires very careful tuning to avoid destroying the model.

The Quick Version

Explicit Feedback (ratings, reviews) is rare, highly biased, and often doesn't reflect true user behavior.
Implicit Feedback (clicks, watch time, add-to-cart) provides massive amounts of unbiased data, but is harder to interpret because you don't have explicit negative signals.
When modeling implicit data, we don't try to predict a "score". We predict a binary Preference (1 or 0), weighted by our Confidence (how many times they interacted with it).

Related concepts

Two-Tower Retrieval