Recommender Systems — Stop Cold-Start Empty Recommendations

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

# --- Data Setup ---
# Rows = users, Columns = movies
# Rating scale: 1-5, 0 = not yet watched
user_movie_ratings = np.array([
    # Inception, Interstellar, The Dark Knight, Toy Story, Finding Nemo
    [5, 4, 5, 1, 0],  # Alice
    [4, 5, 4, 0, 1],  # Bob
    [0, 3, 5, 2, 1],  # Carol
    [1, 0, 1, 5, 5],  # David
    [2, 1, 0, 4, 5],  # Eve
])

user_names = ["Alice", "Bob", "Carol", "David", "Eve"]
movie_names = ["Inception", "Interstellar", "The Dark Knight", "Toy Story", "Finding Nemo"]

# --- Step 1: Compute user-to-user similarity ---
# cosine_similarity returns a matrix where [i][j] is how similar user i is to user j
user_similarity_matrix = cosine_similarity(user_movie_ratings)

print("=== User Similarity Matrix ===")
print(f"{'':10}", end="")
for name in user_names:
    print(f"{name:12}", end="")
print()
for i, name in enumerate(user_names):
    print(f"{name:10}", end="")
    for score in user_similarity_matrix[i]:
        print(f"{score:.3f}       ", end="")
    print()

# --- Step 2: Generate recommendations for a target user ---
def recommend_movies_for_user(target_user_index, top_n_users=2, top_n_movies=2):
    """
    Find the most similar users to the target user, then recommend
    movies those users rated highly that the target user hasn't seen.
    """
    target_user_name = user_names[target_user_index]
    target_ratings = user_movie_ratings[target_user_index]

    # Get similarity scores for the target user vs everyone else
    similarity_scores = user_similarity_matrix[target_user_index]

    # Sort users by similarity, excluding the target user themselves (similarity = 1.0)
    similar_user_indices = np.argsort(similarity_scores)[::-1]
    similar_user_indices = [i for i in similar_user_indices if i != target_user_index]

    # Take the top N most similar users
    top_similar_users = similar_user_indices[:top_n_users]

    print(f"\n=== Recommendations for {target_user_name} ===")
    print(f"Movies {target_user_name} has NOT watched: ", end="")
    unwatched = [movie_names[j] for j in range(len(movie_names)) if target_ratings[j] == 0]
    print(", ".join(unwatched))

    print(f"Most similar users: {[user_names[i] for i in top_similar_users]}")

    # Accumulate weighted scores for each unwatched movie
    movie_scores = {}
    for similar_user_idx in top_similar_users:
        similarity_weight = similarity_scores[similar_user_idx]
        for movie_idx, rating in enumerate(user_movie_ratings[similar_user_idx]):
            # Only consider movies the TARGET user hasn't watched
            if target_ratings[movie_idx] == 0 and rating > 0:
                movie_name = movie_names[movie_idx]
                # Weight the rating by how similar this user is to the target
                weighted_score = rating * similarity_weight
                movie_scores[movie_name] = movie_scores.get(movie_name, 0) + weighted_score

    # Sort by score descending and return top N
    ranked_recommendations = sorted(movie_scores.items(), key=lambda item: item[1], reverse=True)

    print(f"\nTop {top_n_movies} recommendations:")
    for rank, (movie, score) in enumerate(ranked_recommendations[:top_n_movies], start=1):
        print(f"  {rank}. {movie} (weighted score: {score:.3f})")

# Run recommendations for Alice (index 0) and David (index 3)
recommend_movies_for_user(target_user_index=0)
recommend_movies_for_user(target_user_index=3)

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# --- Movie Catalog with Metadata ---
# In production this would come from a database. Here we define it inline.
movie_catalog = pd.DataFrame({
    'title': [
        'Inception', 'Interstellar', 'The Dark Knight',
        'Toy Story', 'Finding Nemo', 'Avengers: Endgame',
        'The Prestige', 'Up'
    ],
    # 'tags' is a space-separated string of features — genre, mood, themes.
    # TF-IDF will treat each word as a feature dimension.
    'tags': [
        'sci-fi thriller mind-bending dreams heist christopher-nolan',
        'sci-fi space drama time-travel emotion christopher-nolan',
        'action thriller dark superhero crime christopher-nolan',
        'animation family adventure friendship comedy pixar',
        'animation family ocean adventure comedy pixar',
        'action superhero adventure sci-fi ensemble marvel',
        'thriller mystery magic drama christopher-nolan',
        'animation family adventure emotion loss pixar'
    ]
})

# --- Step 1: Build the TF-IDF Feature Matrix ---
# TF-IDF converts text tags into numeric vectors.
# Words that appear in every movie (like 'the') get low weight;
# distinctive words (like 'christopher-nolan') get high weight.
tfidf_vectorizer = TfidfVectorizer(stop_words='english')
tfidf_feature_matrix = tfidf_vectorizer.fit_transform(movie_catalog['tags'])

print(f"Feature matrix shape: {tfidf_feature_matrix.shape}")
print(f"(That's {tfidf_feature_matrix.shape[0]} movies x {tfidf_feature_matrix.shape[1]} unique tag features)\n")

# --- Step 2: Compute Item-to-Item Cosine Similarity ---
# Each row in the matrix represents a movie as a point in tag-space.
# cosine_similarity measures the angle between any two movies' vectors.
item_similarity_matrix = cosine_similarity(tfidf_feature_matrix, tfidf_feature_matrix)

# Build a lookup: movie title -> row index
title_to_index = pd.Series(movie_catalog.index, index=movie_catalog['title'])

# --- Step 3: The Recommendation Function ---
def get_content_based_recommendations(liked_movie_title, top_n=3):
    """
    Given a movie the user liked, find the most similar movies
    based purely on their content/tag profiles.
    """
    if liked_movie_title not in title_to_index:
        print(f"Movie '{liked_movie_title}' not found in catalog.")
        return

    movie_index = title_to_index[liked_movie_title]

    # Get the similarity row for this movie — a score vs every other movie
    similarity_scores = list(enumerate(item_similarity_matrix[movie_index]))

    # Sort by similarity score, highest first
    # Exclude index 0 because that's the movie itself (similarity = 1.0)
    similarity_scores_sorted = sorted(
        similarity_scores,
        key=lambda pair: pair[1],
        reverse=True
    )
    # Skip the first result (it's the same movie)
    top_similar_movies = similarity_scores_sorted[1: top_n + 1]

    print(f"Because you liked '{liked_movie_title}', you might enjoy:")
    print(f"  (Tags: {movie_catalog.loc[movie_index, 'tags']})\n")
    for rank, (idx, score) in enumerate(top_similar_movies, start=1):
        recommended_title = movie_catalog.loc[idx, 'title']
        recommended_tags = movie_catalog.loc[idx, 'tags']
        print(f"  {rank}. {recommended_title} (similarity: {score:.3f})")
        print(f"     Tags: {recommended_tags}")
    print()

# --- Run recommendations ---
get_content_based_recommendations('Inception', top_n=3)
get_content_based_recommendations('Toy Story', top_n=3)

import pandas as pd
import numpy as np

# --- Simulated movie ratings data ---
# Each row is one rating event: which user rated which movie and how.
ratings_data = [
    {'user_id': 'alice',  'movie': 'Inception',        'rating': 5},
    {'user_id': 'alice',  'movie': 'Interstellar',     'rating': 4},
    {'user_id': 'alice',  'movie': 'The Dark Knight',  'rating': 5},
    {'user_id': 'bob',    'movie': 'Inception',        'rating': 4},
    {'user_id': 'bob',    'movie': 'Interstellar',     'rating': 5},
    {'user_id': 'bob',    'movie': 'Toy Story',        'rating': 3},
    {'user_id': 'carol',  'movie': 'The Dark Knight',  'rating': 4},
    {'user_id': 'carol',  'movie': 'Avengers: Endgame','rating': 5},
    {'user_id': 'carol',  'movie': 'Toy Story',        'rating': 4},
    {'user_id': 'david',  'movie': 'Toy Story',        'rating': 5},
    {'user_id': 'david',  'movie': 'Finding Nemo',     'rating': 5},
    {'user_id': 'eve',    'movie': 'Avengers: Endgame','rating': 4},
    {'user_id': 'eve',    'movie': 'Inception',        'rating': 3},
]

ratings_df = pd.DataFrame(ratings_data)

# --- Build the Popularity Scorecard ---
# A good popularity score isn't just average rating — it must account for
# the number of ratings too. A film with 1,000 ratings of 4.0 is safer
# to recommend than one with 2 ratings of 5.0.
# We use a Bayesian average: (n / (n + m)) * mean_rating + (m / (n + m)) * global_mean
# Where n = number of ratings for this film, m = minimum ratings threshold

global_mean_rating = ratings_df['rating'].mean()
minimum_votes_threshold = 2  # need at least 2 ratings to be trusted

movie_stats = ratings_df.groupby('movie').agg(
    total_ratings=('rating', 'count'),
    mean_rating=('rating', 'mean')
).reset_index()

def bayesian_average(row, global_mean, min_votes):
    """Pulls films with few ratings toward the global mean, reducing noise."""
    n = row['total_ratings']
    mean = row['mean_rating']
    # As n grows large, this approaches the true mean_rating.
    # With n=1, it's heavily pulled toward global_mean.
    return (n / (n + min_votes)) * mean + (min_votes / (n + min_votes)) * global_mean

movie_stats['bayesian_score'] = movie_stats.apply(
    bayesian_average,
    axis=1,
    global_mean=global_mean_rating,
    min_votes=minimum_votes_threshold
)

popularity_ranked = movie_stats.sort_values('bayesian_score', ascending=False).reset_index(drop=True)

print("=== Popularity Fallback Catalog (for new users) ===")
print(f"Global mean rating across all movies: {global_mean_rating:.2f}\n")
print(popularity_ranked[['movie', 'total_ratings', 'mean_rating', 'bayesian_score']].to_string(index=False))

# --- The Cold-Start Decision Router ---
def get_recommendations(user_id, user_history, all_ratings_df, top_n=3):
    """
    Routes to the right strategy based on how much data we have for this user.
    - No history: popularity fallback (cold start)
    - Has history: could call collaborative or content-based (placeholder here)
    """
    print(f"\n=== Fetching recommendations for: {user_id} ===")

    if len(user_history) == 0:
        # COLD START: no interactions yet — serve popularity list
        print("Status: NEW USER (cold start) — serving popularity-based fallback\n")
        already_watched = set()  # new user has watched nothing
    else:
        print(f"Status: RETURNING USER — has rated {len(user_history)} movies\n")
        already_watched = set(user_history.keys())
        # In a real system you'd call collaborative or content-based here.
        # We show the fallback logic pathway for illustration.
        print("(Would call collaborative/content-based system here in production)\n")

    # Show popularity fallback recommendations, excluding already-seen items
    recommendations = [
        row for _, row in popularity_ranked.iterrows()
        if row['movie'] not in already_watched
    ][:top_n]

    for rank, movie_row in enumerate(recommendations, start=1):
        print(f"  {rank}. {movie_row['movie']} "
              f"(score: {movie_row['bayesian_score']:.3f}, "
              f"ratings: {int(movie_row['total_ratings'])})")

# Simulate a brand new user with zero history
get_recommendations('new_signup_frank', user_history={}, all_ratings_df=ratings_df)

# Simulate a returning user who has watched some films
get_recommendations('alice', user_history={'Inception': 5, 'Interstellar': 4}, all_ratings_df=ratings_df)

import pandas as pd
import numpy as np

def weighted_rating(df, rating_col='rating', count_col='vote_count', m=1000):
    """Calculate IMDB-style weighted rating."""
    C = df[rating_col].mean()
    v = df[count_col]
    R = df[rating_col]
    return (v / (v + m)) * R + (m / (v + m)) * C

# Example with MovieLens-style data
movies = pd.DataFrame({
    'title': ['The Shawshank Redemption', 'Plan 9 from Outer Space', 'The Godfather'],
    'rating': [9.3, 2.5, 9.2],
    'vote_count': [25000, 200, 18000]
})
movies['weighted_score'] = weighted_rating(movies)
print(movies[['title', 'weighted_score']].sort_values('weighted_score', ascending=False))

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import pandas as pd

# Mini dataset with genre features
movies = pd.DataFrame({
    'title': ['Inception', 'The Dark Knight', 'The Notebook'],
    'genres': ['sci-fi action thriller', 'action crime thriller', 'romance drama']
})

# Vectorize genres using TF-IDF (one-hot is too sparse)
tfidf = TfidfVectorizer()
genre_matrix = tfidf.fit_transform(movies['genres'])

# Compute cosine similarity
sim_matrix = cosine_similarity(genre_matrix, genre_matrix)

# Recommend for Inception (index 0)
inception_idx = 0
scores = list(enumerate(sim_matrix[inception_idx]))
sorted_scores = sorted(scores, key=lambda x: x[1], reverse=True)[1:3]
print('Movies similar to Inception:')
for idx, score in sorted_scores:
    print(f'  {movies.iloc[idx]["title"]}: {score:.3f}')