Movie Recommender System With a Deep Ranking Model

!pip install -qU pinecone-client

import pinecone

# Load Pinecone API key
import os 

api_key = os.getenv("PINECONE_API_KEY") or "YOUR_API_KEY"
pinecone.init(api_key=api_key, environment='us-west1-gcp')

#List all current indexes for your API key
pinecone.list_indexes()

!pip install -q scikit-learn pandas matplotlib==3.2.2 tensorflow tfds-nightly pandas-profiling unidecode

import numpy as np
import pandas as pd
import tensorflow as tf
import tensorflow_datasets as tfds

# Load data
_ratings = tfds.load("movielens/100k-ratings", split="train")
_movies = tfds.load("movielens/100k-movies", split="train")

# Collect data that we'd use throughout this notebook
class DATA:
    ratings = None
    train = None
    test = None
    
DATA.ratings = _ratings.map(lambda x: {
    "movie_title": x["movie_title"],
    "user_id": x["user_id"],
    "user_rating": x["user_rating"]  # We keep the ratings of a user-movie pair
})

# Split data into training and testing
shuffled = DATA.ratings.shuffle(100_000, reshuffle_each_iteration=False)
DATA.train = shuffled.take(80_000)
DATA.test = shuffled.skip(80_000).take(20_000)

#Downloading the pretrained models from Drive. If running outside Colab please install gdown.
!gdown --id 1OPflMW6yzBcSlaxWWOSa_SAFSe1iiTZl

# extract the models
import tarfile

tfile = tarfile.open("premade-models.tgz")
tfile.extractall()
tfile.close()

user_model = tf.saved_model.load('tf_retrieval_user_model')
movie_model = tf.saved_model.load('tf_retrieval_movie_model')

scoring_model = tf.saved_model.load('tf_ranking_pairwise_score')

user_embedding = user_model(np.array(["42"]))
movie_embedding = movie_model(np.array(["One Flew Over the Cuckoo's Nest (1975)"]))
pairwised_score = scoring_model(tf.concat([user_embedding, movie_embedding], axis=1))
print(f"user embedding: {user_embedding}")
print(f"movie embedding: {movie_embedding}")
print(f"pairwise score: {pairwised_score}")

movielens_index_name = 'movielens-demo-simple'

# Check whether the index with the same name already exists
if movielens_index_name in pinecone.list_indexes():
    pinecone.delete_index(movielens_index_name)

pinecone.create_index(movielens_index_name, dimension=32, metric="dotproduct")

index = pinecone.Index(movielens_index_name)
index.describe_index_stats()

from unidecode import unidecode

# Get all of the movies
all_movies = list(set([unidecode(title.decode()[:64]) for title in DATA.ratings.map(lambda xx: xx['movie_title']).as_numpy_iterator()]))

# Transform movies into embeddings
movie_embeddings = movie_model(np.array(all_movies)).numpy().tolist()

# Prepare movie embeddings for upload
items_to_insert = list(zip(all_movies, movie_embeddings))
display(items_to_insert[:1])

import itertools

def chunks(iterable, batch_size=100):
    it = iter(iterable)
    chunk = tuple(itertools.islice(it, batch_size))
    while chunk:
        yield chunk
        chunk = tuple(itertools.islice(it, batch_size))

print('Index statistics before upsert:', index.describe_index_stats())

# Upsert data
for batch in chunks([(ii[:64],x) for ii,x in items_to_insert], 1000):
    index.upsert(vectors=batch)

print('Index statistics after upsert:', index.describe_index_stats())

import requests
from IPython.display import Image, display
from IPython.core.display import HTML 

def movie_title_to_poster_url(title):
    POSTERS_URL_TEMPLATE = "http://www.omdbapi.com/?i=tt3896198&apikey=4a3604bd&t="
    parsed_title = ' '.join(title.split()[:-1])
    if parsed_title.lower().endswith(', the'):
        parsed_title = "The "+parsed_title[:-len(', the')]
    try:
        r = requests.get(POSTERS_URL_TEMPLATE+parsed_title).json()
        return r['Poster']
    except:
        # Fallback image
        return "https://cdn4.iconfinder.com/data/icons/small-n-flat/24/movie-alt2-512.png"


def path_to_image_html(path):
    return '<img src="'+ path + '" width="100" >'


def show_image_tiles(images_urls, n_col=6):
    import math

    rows = [images_urls[ii * n_col: (1+ii) * n_col] for ii in range(math.ceil(len(images_urls) / n_col))]
    for ii, rr in enumerate(rows):
        if len(rr) < n_col:
            rows[ii] = rr + [''] * (n_col - len(rr))
    df = pd.DataFrame(rows)
    display(HTML(df.to_html(escape=False, formatters=[path_to_image_html]*df.shape[1])))

def rerank_recommendations(user_embeddings, query_results):
    result_matches = []

    for q, res in zip(user_embeddings, query_results):
        ids = [match.id for match in res.matches]
        data = [match.values for match in res.matches]
        updated_scores = [(i, scoring_model(tf.concat([[q], [movie_model(np.array([movie]))[0]]], axis=1)).numpy().flatten()[0]) for i, movie in enumerate(ids)]
        sorted_inx_score = sorted(updated_scores, key=lambda i_s: -i_s[1])
        new_scores = [float(s) for _,s in sorted_inx_score]
        new_ids = [list(ids)[i] for i,_ in sorted_inx_score]
        new_data = [list(data)[i] for i,_ in sorted_inx_score]

        for new_id, new_score, new_data in zip(new_ids, new_scores, new_data):
            result_matches.append({
                    'id':new_id, 
                    'score': new_score,
                    'values': new_data
                   })
          
    query_reranked_results = [{'matches' : result_matches}]
    return query_reranked_results

# Define a list of users
user_ids = ['55']

# Retrieve user embeddings
user_embeddings = [user_model(np.array([user]))[0].numpy().tolist() for user in user_ids]

# Query by user embeddings
query_results = []
for xq in user_embeddings:
    res = index.query(xq, top_k=50, include_values=True)
    query_results.append(res)

query_results_reranked = rerank_recommendations(user_embeddings, query_results)

from IPython.display import display_html
from itertools import chain,cycle

def display_side_by_side(*args,titles=cycle([''])):
    html_str=''
    for df,title in zip(args, chain(titles,cycle(['</br>'])) ):
        html_str+='<th style="text-align:center"><td style="vertical-align:top">'
        html_str+=f'<h2>{title}</h2>'
        html_str+=df.to_html(escape=False, formatters=dict(image=path_to_image_html)).replace('table','table style="display:inline"')
        html_str+='</td></th>'
    display_html(html_str,raw=True)

# Print results
for _id, res, res_ranked in zip(user_ids, query_results, query_results_reranked):
    print(f'user_id={_id}')

    # Not ranked
    df = pd.DataFrame({'ids': [match['id'] for match in res['matches']][:5], 'scores': [match['score'] for match in res['matches']][:5]})
    df['image'] = list(map(movie_title_to_poster_url, df['ids']))

    # Ranked
    df_r = pd.DataFrame({'ids': [match['id'] for match in res_ranked['matches'][:5]], 'scores': [match['score'] for match in res_ranked['matches'][:5]]})
    df_r['image'] = list(map(movie_title_to_poster_url, df_r['ids']))

    # Show both
    display_side_by_side(df_r, df, titles=['With re-ranking','Without re-ranking'])

user_ratings = [r for r in DATA.ratings if r["user_id"] == '55']
content = [dict(title="".join(map(chr,r["movie_title"].numpy())), movie=movie_title_to_poster_url("".join(map(chr,r["movie_title"].numpy()))), rating=r['user_rating'].numpy()) for r in user_ratings]
df = pd.DataFrame(content).sort_values('rating', ascending=False)
display(HTML(df.to_html(escape=False, index=False, formatters=dict(movie=path_to_image_html))))

pinecone.delete_index(movielens_index_name)