Explicit vs Implicit Feedback in Recommender Systems

The Signal Behind Every Recommendation

Explicit Feedback — Ratings

Ratings are the canonical form of explicit feedback. Users assign a numerical or categorical score to an item — expressing how much they liked or disliked it. Ratings are clean, unambiguous, and directly interpretable. They are also frustratingly rare.

import numpy as np
import pandas as pd

# ── Raw ratings dataset ───────────────────────────────────────
ratings = pd.DataFrame({
    'user'  : ['Ali','Ali','Ali','Ben','Ben','Ben','Cara','Cara'],
    'item'  : ['A','B','C','A','B','D','B','C'],
    'rating': [5, 4, 1, 3, 4, 5, 2, 5],
})

# ── Problem: raw ratings confound user generosity with preference
# Ali gives 5,4,1 — tough rater.  Cara gives 2,5 — wide spread.
# A raw "4" from Ali ≠ a "4" from a generous rater.

# ── Solution: mean-centre per user ───────────────────────────
user_means = ratings.groupby('user')['rating'].transform('mean')
ratings['rating_norm'] = ratings['rating'] - user_means

print(ratings.to_string(index=False))
print("\nUser mean ratings:")
print(ratings.groupby('user')['rating'].mean().round(2))

Explicit Feedback — Likes & Dislikes

Binary feedback — thumbs up / thumbs down, heart / no heart, upvote / downvote — is the simplest form of explicit preference signal. What it loses in granularity, it more than compensates for in volume and participation rate.

import pandas as pd
import numpy as np

# ── Binary feedback: asymmetric weighting ────────────────────
interactions = pd.DataFrame({
    'user'   : ['Ali','Ali','Ali','Ben','Ben','Cara','Cara'],
    'item'   : ['A','B','C','A','C','B','D'],
    'signal' : ['like','dislike','like','like','dislike','like','like'],
})

# Asymmetric weights: dislike carries 3× the signal strength of a like
weight_map = {'like': 1.0, 'dislike': -3.0}
interactions['weight'] = interactions['signal'].map(weight_map)

# ── Build weighted user preference score per item ─────────────
user_item_score = (
    interactions
    .groupby(['user', 'item'])['weight']
    .sum()
    .reset_index()
    .rename(columns={'weight': 'pref_score'})
)
print(user_item_score.to_string(index=False))

# ── Suppress disliked items from candidate pool ───────────────
suppress = interactions[interactions['signal'] == 'dislike'][['user','item']]
print(f"\nSuppressed (user, item) pairs:")
print(suppress.to_string(index=False))

Implicit Feedback — Clicks

Position Bias — The Elephant in the Room

Users are far more likely to click items that appear higher on a list — not because those items are better, but because they are seen first. This is called position bias, and it is the most dangerous confound in click data. If you train a model on raw click data, you will systematically reinforce items that were already ranked highly — regardless of their true quality.

import numpy as np
import pandas as pd

# ── Click data with position information ──────────────────────
clicks = pd.DataFrame({
    'user'    : ['Ali','Ali','Ben','Ben','Cara','Cara'],
    'item'    : ['A','B','A','C','B','D'],
    'position': [1, 3, 1, 5, 2, 4],
    'clicked' : [1, 1, 1, 1, 1, 1],
})

# ── Inverse Propensity Scoring (IPS) ──────────────────────────
# P(click | position) estimated from empirical CTR curve
propensity = {1: 0.20, 2: 0.13, 3: 0.09, 4: 0.07, 5: 0.05}

clicks['propensity'] = clicks['position'].map(propensity)

# IPS weight: down-weight easy (high-position) clicks
clicks['ips_weight'] = 1.0 / clicks['propensity']

print(clicks[['user','item','position','propensity','ips_weight']]
      .to_string(index=False))

print("\nIPS-weighted click value by item:")
print(clicks.groupby('item')['ips_weight']
      .sum().sort_values(ascending=False).round(2))

Implicit Feedback — Watch Time & Dwell Time

Watch time (for video), dwell time (for articles), listen duration (for podcasts/music), and reading time are time-based implicit signals that are considerably more informative than binary clicks. Time is a scarce resource — users who give it are signalling genuine engagement.

import pandas as pd
import numpy as np

# ── Video watch events ────────────────────────────────────────
watches = pd.DataFrame({
    'user'       : ['Ali','Ali','Ben','Ben','Cara','Cara'],
    'video'      : ['V1','V2','V1','V3','V2','V3'],
    'duration_s' : [1800, 1800, 1800, 2400, 1800, 2400],  # video length
    'watched_s'  : [1750, 120,  900,  2380, 1800, 85],   # seconds watched
    'replayed'   : [True, False, False, True, False, False],
})

# ── Compute completion rate ───────────────────────────────────
watches['completion'] = (watches['watched_s'] / watches['duration_s']).clip(0, 1)

# ── Sentiment label from completion rate ──────────────────────
def watch_sentiment(row):
    c = row['completion']
    if   c < 0.10: return 'bounce'
    elif c < 0.35: return 'browse'
    elif c < 0.80: return 'engaged'
    else:           return 'loved'

watches['sentiment'] = watches.apply(watch_sentiment, axis=1)

# ── Implicit score: completion + replay bonus ─────────────────
watches['impl_score'] = watches['completion'] + watches['replayed'].astype('float') * 0.5

cols = ['user','video','completion','sentiment','impl_score']
print(watches[cols].to_string(index=False))

Implicit Feedback — Purchase History

Purchase history is the gold-standard implicit signal for e-commerce recommendation. A transaction represents the maximum commitment a user can make — they gave money. It is a strong positive signal about intent and satisfaction. But purchases require careful contextualisation: gift-buying, seasonal purchases, one-time needs, and category exploration all create false taste signals if naively fed into a model.

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# ── Purchase history with context signals ─────────────────────
now = datetime(2024, 6, 15)
purchases = pd.DataFrame({
    'user'      : ['Ali','Ali','Ali','Ben','Ben'],
    'item'      : ['Blender','Coffee','Toy','Coffee','Headphones'],
    'category'  : ['Kitchen','Grocery','Toys','Grocery','Electronics'],
    'date'      : [now - timedelta(days=d)
                   for d in [400, 30, 360, 20, 5]],
    'returned'  : [False, False, True, False, False],
    'repeat_buy': [False, True, False, True, False],
})

# ── Time-decay: recent purchases are more relevant ────────────
purchases['days_ago']     = (now - purchases['date']).dt.days
purchases['time_decay']   = np.exp(-purchases['days_ago'] / 90)  # 90-day half-life

# ── Base signal: return = -1, normal purchase = +1 ───────────
purchases['base_signal']  = np.where(purchases['returned'], -1.0, 1.0)

# ── Repeat bonus multiplier ───────────────────────────────────
purchases['repeat_mult']  = np.where(purchases['repeat_buy'], 2.0, 1.0)

# ── Final implicit score ──────────────────────────────────────
purchases['impl_score'] = (purchases['base_signal']
                             * purchases['time_decay']
                             * purchases['repeat_mult'])

cols = ['user','item','days_ago','returned','repeat_buy','impl_score']
print(purchases[cols].round(3).to_string(index=False))

Combining All Signals — The Unified Feedback Matrix

In production, no single feedback signal is trusted alone. Every signal has biases, gaps, and misinterpretation risks. The art of feedback engineering is building a unified confidence-weighted interaction score that aggregates all available signals into a single interpretable value.

import pandas as pd
import numpy as np

# ── Unified implicit score from multiple signal types ─────────
# Signal weights: higher = more trustworthy
SIGNAL_WEIGHTS = {
    'impression' : 0.01,
    'click'      : 0.10,
    'watch_50pct': 0.30,
    'watch_full' : 0.60,
    'like'       : 0.70,
    'dislike'    : -1.50,   # negative and high-magnitude
    'rating_4'   : 0.65,
    'rating_5'   : 0.90,
    'rating_1'   : -1.20,
    'purchase'   : 1.00,
    'rewatch'    : 1.20,
}

# ── Example: Ali's interactions with Item V1 ─────────────────
ali_v1_signals = ['impression', 'click', 'watch_full', 'rewatch', 'like']
ali_v1_score   = sum(SIGNAL_WEIGHTS[s] for s in ali_v1_signals)

# ── Example: Ben's interactions with Item V2 ─────────────────
ben_v2_signals = ['impression', 'click', 'watch_50pct', 'dislike']
ben_v2_score   = sum(SIGNAL_WEIGHTS[s] for s in ben_v2_signals)

# ── Build interaction table ───────────────────────────────────
data = []
for sig in ali_v1_signals:
    data.append({'user':'Ali','item':'V1','signal':sig,'weight':SIGNAL_WEIGHTS[sig]})
for sig in ben_v2_signals:
    data.append({'user':'Ben','item':'V2','signal':sig,'weight':SIGNAL_WEIGHTS[sig]})

df = pd.DataFrame(data)
summary = df.groupby(['user','item'])['weight'].sum().reset_index()
summary.columns = ['user','item','unified_score']

print(df.to_string(index=False))
print("\nUnified Interaction Scores:")
print(summary.to_string(index=False))

Explicit vs Implicit — The Complete Comparison