initial commit

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+recommendation_model.keras filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,272 @@
+"""
+This is a book recommendation system.
+"""
+
+import pickle
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import LabelEncoder
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+from tensorflow.keras.models import load_model
+
+# Load datasets
+books = pd.read_csv("./dataset/books.csv")
+ratings = pd.read_csv("./dataset/ratings.csv")
+
+# Preprocess data
+user_encoder = LabelEncoder()
+book_encoder = LabelEncoder()
+
+
+ratings["user_id"] = user_encoder.fit_transform(ratings["user_id"])
+ratings["book_id"] = book_encoder.fit_transform(ratings["book_id"])
+
+# Load TF-IDF models
+with open("tfidf_model_authors.pkl", "rb") as f:
+    tfidf_model_authors = pickle.load(f)
+
+with open("tfidf_model_titles.pkl", "rb") as f:
+    tfidf_model_titles = pickle.load(f)
+
+# Define TF-IDF vectorizer
+tfidf_vectorizer = TfidfVectorizer(stop_words="english")
+
+# Fit and transform the book descriptions
+tfidf_matrix = tfidf_vectorizer.fit_transform(books["original_title"].fillna(""))
+
+# Load collaborative filtering model
+model_cf = load_model("recommendation_model.keras")
+
+
+# Content-Based Recommendation
+def content_based_recommendation(
+    query, books, tfidf_model_authors, tfidf_model_titles, num_recommendations=10
+):
+    """
+    Recommend books based on content similarity.
+    Args:
+        query (str): The name of the book or author.
+        books (DataFrame): DataFrame containing book information.
+        tfidf_model_authors: Pre-trained TF-IDF model for authors.
+        tfidf_model_titles: Pre-trained TF-IDF model for titles.
+        num_recommendations (int): The number of books to recommend.
+    Returns:
+        DataFrame: A DataFrame containing recommended books with details.
+    """
+    # Check if the query corresponds to an author or a book
+    if query in books["authors"].values:
+        book_name = books.loc[books["authors"] == query, "original_title"].values[0]
+    elif query in books["original_title"].values:
+        book_name = query
+    else:
+        print("Query not found in authors or titles.")
+        return None
+
+    book_author = books.loc[books["original_title"] == book_name, "authors"].values[0]
+    book_title = books.loc[books["title"] == book_name, "title"].values[0]
+
+    # Transform book author, title, and description into TF-IDF vectors
+    book_author_tfidf = tfidf_model_authors.transform([book_author])
+    book_title_tfidf = tfidf_model_titles.transform([book_title])
+
+    # Compute cosine similarity for authors and titles separately
+    similarity_scores_authors = cosine_similarity(
+        book_author_tfidf, tfidf_model_authors.transform(books["authors"])
+    )
+    similarity_scores_titles = cosine_similarity(
+        book_title_tfidf, tfidf_model_titles.transform(books["title"])
+    )
+
+    # Combine similarity scores for authors and titles
+    similarity_scores_combined = (
+        similarity_scores_authors + similarity_scores_titles
+    ) / 2
+
+    # Get indices of recommended books
+    recommended_indices = np.argsort(similarity_scores_combined.flatten())[
+        -num_recommendations:
+    ][::-1]
+
+    # Get recommended books
+    recommended_books = books.iloc[recommended_indices]
+
+    return recommended_books
+
+
+# Collaborative Recommendation
+def collaborative_recommendation(user_id, model_cf, ratings, num_recommendations=10):
+    """
+    Recommend books based on collaborative filtering.
+    Args:
+        user_id (int): The user ID.
+        model_cf: The trained collaborative filtering model.
+        ratings (DataFrame): DataFrame containing user ratings.
+        num_recommendations (int): The number of books to recommend.
+    Returns:
+        DataFrame: A DataFrame containing recommended books with details.
+    """
+    # Check if the user ID exists in the ratings dataset
+    if user_id not in ratings["user_id"].unique():
+        print("User ID not found in ratings dataset.")
+        return None
+
+    # Get unrated books for the user
+    unrated_books = ratings[
+        ~ratings["book_id"].isin(ratings[ratings["user_id"] == user_id]["book_id"])
+    ]["book_id"].unique()
+
+    # Check if there are unrated books
+    if len(unrated_books) == 0:
+        print("No unrated books found for the user.")
+        return None
+
+    # Predict ratings for unrated books
+    predictions = model_cf.predict(
+        [np.full_like(unrated_books, user_id), unrated_books]
+    ).flatten()
+
+    # Get top indices based on predictions
+    top_indices = np.argsort(predictions)[-num_recommendations:][::-1]
+
+    # Get recommended books
+    recommended_books = books.iloc[top_indices][["original_title", "authors"]]
+    return recommended_books
+
+
+# History-Based Recommendation
+def history_based_recommendation(user_id, ratings, num_recommendations=10):
+    """
+    Recommend books based on user's historical ratings.
+    Args:
+        user_id (int): The user ID.
+        ratings (DataFrame): DataFrame containing user ratings.
+        num_recommendations (int): The number of books to recommend.
+    Returns:
+        DataFrame: A DataFrame containing recommended books with details.
+    """
+    user_ratings = ratings[ratings["user_id"] == user_id]
+    top_books = user_ratings.sort_values(by="rating", ascending=False).head(
+        num_recommendations
+    )["book_id"]
+    recommended_books = books[books["book_id"].isin(top_books)]
+    return recommended_books
+
+
+# Hybrid Recommendation
+def hybrid_recommendation(
+    user_id,
+    query,
+    model_cf,
+    books,
+    ratings,
+    tfidf_model_authors,
+    tfidf_model_titles,
+    num_recommendations=10,
+):
+    """
+    Recommend books using hybrid recommendation approach.
+    Args:
+        user_id (int): The user ID.
+        query (str): The name of the book or author.
+        model_cf: The collaborative filtering model.
+        books (DataFrame): DataFrame containing book information.
+        ratings (DataFrame): DataFrame containing user ratings.
+        tfidf_model_authors: Pre-trained TF-IDF model for authors.
+        tfidf_model_titles: Pre-trained TF-IDF model for titles.
+        num_recommendations (int): The number of books to recommend.
+    Returns:
+        DataFrame: A DataFrame containing recommended books with details.
+    """
+    content_based_rec = content_based_recommendation(
+        query,
+        books,
+        tfidf_model_authors,
+        tfidf_model_titles,
+        num_recommendations=num_recommendations,
+    )
+    collaborative_rec = collaborative_recommendation(
+        user_id, model_cf, ratings, num_recommendations=num_recommendations
+    )
+    history_based_rec = history_based_recommendation(
+        user_id, ratings, num_recommendations=num_recommendations
+    )
+
+    # Combine recommendations from different approaches
+    hybrid_rec = pd.concat(
+        [content_based_rec, collaborative_rec, history_based_rec]
+    ).drop_duplicates(subset="book_id", keep="first")
+    return hybrid_rec
+
+
+# Top Recommendations (most popular books)
+def top_recommendations(books, num_recommendations=10):
+    """
+    Recommend top books based on popularity (highest ratings count).
+    Args:
+        books (DataFrame): DataFrame containing book information.
+        num_recommendations (int): The number of books to recommend.
+    Returns:
+        DataFrame: A DataFrame containing recommended books with details.
+    """
+    top_books = books.sort_values(by="ratings_count", ascending=False).head(
+        num_recommendations
+    )
+    return top_books
+
+
+# Test the recommendation functions
+query = input("Enter book name or author: ")
+USER_ID = 0  # Example user ID for collaborative and history-based recommendations
+
+print("Content-Based Recommendation:")
+print(
+    content_based_recommendation(query, books, tfidf_model_authors, tfidf_model_titles)
+)
+
+print("\nCollaborative Recommendation:")
+print(collaborative_recommendation(USER_ID, model_cf, ratings))
+
+print("\nHistory-Based Recommendation:")
+print(history_based_recommendation(USER_ID, ratings))
+
+print("\nHybrid Recommendation:")
+print(
+    hybrid_recommendation(
+        user_id,
+        query,
+        model_cf,
+        books,
+        ratings,
+        tfidf_model_authors,
+        tfidf_model_titles,
+    )
+)
+
+print("\nTop Recommendations:")
+print(top_recommendations(books))
+
+# Streamlit App
+st.title("Book Recommendation System")
+
+# Sidebar for user input
+user_input = st.text_input("Enter book name or author:", "")
+
+# Get recommendations on button click
+if st.button("Get Recommendations"):
+    st.write("Content-Based Recommendation:")
+    content_based_rec = content_based_recommendation(
+        user_input, books, tfidf_model_authors, tfidf_model_titles
+    )
+    st.write(content_based_rec)
+
+    st.write("Collaborative Recommendation:")
+    collaborative_rec = collaborative_recommendation(0, model_cf, ratings)
+    st.write(collaborative_rec)
+
+    st.write("Hybrid Recommendation:")
+    hybrid_rec = hybrid_recommendation(
+        0, user_input, model_cf, books, ratings, tfidf_model_authors, tfidf_model_titles
+    )
+    st.write(hybrid_rec)

authors_w2v.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:254a7bb6b32780bbc3df2575c65fad32042738af828cf11b634f5bc9066f817d
+size 4978284

recommendation_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60e07d12b6cfde3b5ac7c9589a3fa1dc7890716c94f26fd8dd3bc8ae70d1f3dc
+size 38171840

recommender.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb8b80df7fbbfe345a51a8f826b260c4ce30d33dfc386b91b7b3eaaa9750f02e
+size 38177168

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+numpy
+pandas
+tensorflow
+sklearn
+keras

title_w2v.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a05d399ab55578c046a190d2d3015bcfc36fc0e7289f09c257eb17c0e78035ce
+size 6747050