GOODREADS CONTENT-BASED BOOK RECOMMENDATION SYSTEM¶

import pandas as pd
import numpy as np
import pickle
import fasttext
from rake_nltk import Rake
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import linear_kernel
from sklearn.pipeline import Pipeline
from tqdm import tqdm

tqdm.pandas()

class KeywordsTransformer(BaseEstimator, TransformerMixin):
    """
    gathering the keywords of each book into one column and will .
    the keyword will containe book's first author, genre, and important keywords description.
    
    """
    
    def __init__(self):
        print('keywords transformer called...')
        
    def fit(self, X, y=None):
        return self
        
    def transform(self, X, y=None):
        X_ = X.copy()
        
        # getting only English books for the recommendation system
        print('filtering English books only...')
        self.lang_model = fasttext.load_model('lid.176.ftz')
        X_['lang_status'] = X_.progress_apply(lambda x: self.lang_detect(x), axis=1)
        
        # getting the first author of the book
        print('getting first author...')
        X_['first_author'] = X_.apply(lambda x: self.set_author(x), axis=1)
        X_['keywords'] = X_.progress_apply(lambda x: ''.join(x['first_author'].split(' ')), axis=1)
        
        # getting important keywords in the description
        print('getting description...')
        rake = Rake()
        X_['keywords'] = X_.progress_apply(lambda x: self.set_description(rake, x), axis=1)
        
        # getting the genre of the books
        print('getting genre...')
        X_['keywords'] = X_.progress_apply(lambda x: self.set_genres(x), axis=1)
        
        # eliminating the books that is not written in English
        X_ = X_[X_.lang_status=='en']
        
        # eliminating duplicates book based on combination of first author and book title
        X_ = X_.drop_duplicates(['first_author', 'book_title'], keep='first').reset_index(drop=True)
        
        return X_
        
    def lang_detect(self, x):
        """
        detecting book's language using fasttext based on book's description and title
        """
        try:
            status = (self.lang_model.predict(x['book_desc'])[0][0] in ('__label__en') or isinstance(x['book_desc'], float)) and self.lang_model.predict(x['book_title'])[0][0] in ('__label__en')
            if status:
                return 'en'
            return 'other'
        except:
            return 'other'
    
    def set_author(self, x):
        """
        getting the first author of the books
        """
        return x['book_authors'].split('|')[0]
    
    def set_description(self, rake, x):
        """
        inserting some important keywords from book's description using rake into keywords
        """
        DESCRIPTION_KEYWORDS_COUNT = 2
        if isinstance(x['book_desc'], str):
            rake.extract_keywords_from_text(x['book_desc'])
            key = rake.get_ranked_phrases()[:DESCRIPTION_KEYWORDS_COUNT]
            return x['keywords']+' '+' '.join(key)
        return x['keywords']
        
    def set_genres(self, x):
        """
        inserting the genres of the books into keywords
        """
        if isinstance(x['genres'], str):
            return x['keywords'] + ' ' + ' '.join(x['genres'].split('|'))
        return x['keywords']

class BookRecommender():
    def __init__(self, data):
        self.data = data

    def transform(self):
        """
        transforming the raw dataset, getting TfIdf from its keywords, and getting cosine similarity of the tfidf
        """
        self.preprocessed()
        
        print('preprocess completed. getting tfidf...')
        vectorizer = TfidfVectorizer()
        tfidf = vectorizer.fit_transform(self.processed_data['keywords'])
        
        print('getting cosine similarity...')
        self.cosine_similarity = linear_kernel(tfidf, tfidf)
        
        print('transformation completed.')
    
    def preprocessed(self):
        """
        preprocessing the dataset using KeywordsTransformer
        """
        kt = KeywordsTransformer()
        kt.fit(self.data)
        self.processed_data = kt.transform(self.data)
    
    def book_recommender(self, title):
        """
        getting books that have high similarity with book that's entered by users
        """
        try:
            ids = self.processed_data.loc[self.processed_data.book_title.str.lower()==title.lower()].index[0]
            
            BOOK_RECOMMENDATION_COUNT = 10
            
            # getting id of books that have high similarity with entered book
            sim_scores = list(enumerate(self.cosine_similarity[ids]))
            sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)[0:BOOK_RECOMMENDATION_COUNT+1]

            res_dic = {}
            for x in sim_scores:
                res_dic[x] = {'book_id': x[0], 
                            'book_title': self.processed_data.iloc[x[0]].book_title,
                            'book_author': self.processed_data.iloc[x[0]].first_author,
                            'similarity': x[1]}

            return self.book_recommender_printer(sorted(res_dic.items(), key=lambda x: x[1]['similarity'], reverse=True))
        except IndexError:
            return 'Book is not found!'

    def book_recommender_printer(self, books):
        """
        printing the recommended book results
        """
        print('---------title input    : ', books[0][1]['book_title'], ' by', books[0][1]['book_author'], '\n')
        print('---------recommendations: \n')
        for b in books[1:]:
            print(b[1]['book_title'], 'by', b[1]['book_author'])
            print('similarity: ', b[1]['similarity'])
            print('\n')

# load the dataset
df = pd.read_csv('data/book_data.csv')

# initiate the book recommender
recommender = BookRecommender(df)