Add full app

app.py

@@ -0,0 +1,52 @@
+import gradio as gr
+import pandas as pd
+import pickle
+import torch
+from sentence_transformers import SentenceTransformer, util, CrossEncoder
+from recommender import BookRecommender
+# Load book dataset
+df = pd.read_csv("model/books_summary_cleaned.csv")
+
+# Load precomputed SBERT embeddings
+with open("model/sbert_embeddings2.pkl", "rb") as f:
+    book_embeddings = pickle.load(f)
+
+# Load models
+reranker_model = CrossEncoder("cross-encoder/stsb-roberta-large")  # More accurate ranking
+
+recommender = BookRecommender()
+
+def rerank_books(query_title, candidates):
+    """Re-rank books using a cross-encoder"""
+    query_summary = df[df["title"] == query_title]["summary"].values[0]
+    pairs = [(query_summary, cand_summary) for _, cand_summary in candidates]
+    
+    scores = reranker_model.predict(pairs)
+    ranked_books = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
+
+    return [book[0][0] for book in ranked_books[:5]]  # Return top-5 ranked books
+
+def recommend_books(book_title):
+    """Complete recommendation pipeline"""
+    candidates = recommender.recommend(book_title, top_n=10)
+    if isinstance(candidates, list) and "Error" in candidates[0]:
+        return candidates[0]
+    
+    return rerank_books(book_title, candidates)
+
+# Gradio Interface
+with gr.Blocks() as demo:
+    gr.Markdown("# 📚 Content-Based Book Recommendation")
+    gr.Markdown("Enter a book title to find similar books based on summaries.")
+    
+    with gr.Row():
+        book_input = gr.Textbox(label="Enter Book Title")
+        submit_btn = gr.Button("Recommend")
+    
+    output = gr.Textbox(label="Recommended Books")
+
+    submit_btn.click(recommend_books, inputs=book_input, outputs=output)
+
+# Run the app
+if __name__ == "__main__":
+    demo.launch()

embeddings.py

@@ -0,0 +1,26 @@
+from sentence_transformers import SentenceTransformer
+from preprocess import preprocess_books
+import pickle
+import numpy as np
+
+def extract_sbert_embeddings(df, save_path="/model/sbert_embeddings2.pkl"):
+    """Extracts SBERT embeddings from book summaries."""
+    model = SentenceTransformer('all-mpnet-base-v2')  # Small, fast, high-performance
+
+    # Generate embeddings for book summaries
+    embeddings = model.encode(df["combined_text"].fillna(""), show_progress_bar=True)
+
+    with open(save_path, "wb") as f:
+        pickle.dump(embeddings, f)
+
+    return embeddings
+
+def load_book_data(filepath="/content/data/books_summary_cleaned.csv"):
+    """Loads book dataset and ensures necessary columns exist."""
+    df = pd.read_csv(filepath)
+    
+
+    return df
+preprocess_books()
+df = load_book_data()
+embeddings = extract_sbert_embeddings(df)

model/sbert_embeddings2.pkl

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

preprocess.py

@@ -0,0 +1,44 @@
+import pandas as pd
+
+import pandas as pd
+import re
+
+def clean_text(text):
+    """Cleans text by removing special characters and extra spaces."""
+    if pd.isna(text):  # Handle missing values
+        return ""
+    text = re.sub(r"\s+", " ", text)  # Remove extra spaces
+    text = re.sub(r"[^a-zA-Z0-9.,!?;:()'\" ]", "", text)  # Keep only relevant characters
+    return text.strip()
+import pandas as pd
+
+def preprocess_books(input_path="/content/data/books_summary.csv", output_path="/content/data/books_summary_cleaned.csv"):
+    """Preprocesses book dataset by handling duplicates, missing values, and text cleaning."""
+    
+    # Load dataset
+    df = pd.read_csv(input_path)
+
+    # Ensure required columns exist
+    required_cols = {"book_name", "summaries", "categories"}
+    if not required_cols.issubset(df.columns):
+        raise ValueError(f"Dataset must contain columns: {required_cols}")
+
+    # Fill missing summaries with categories if available
+    df["summaries"] = df["summaries"].fillna("")
+    df["categories"] = df["categories"].fillna("Unknown")
+
+    # 🔹 Merge duplicate titles while keeping distinct categories
+    df = df.groupby("book_name", as_index=False).agg({
+        "summaries": "first",  # Keep the first non-null summary
+        "categories": lambda x: "; ".join(set(x))  # Combine unique categories
+    })
+
+    # 🔹 Create a new feature combining title, summary, and categories
+    df["combined_text"] = df["summaries"] + " " + df["categories"]
+
+    # Save cleaned dataset
+    df.to_csv(output_path, index=False)
+    print("✅ Dataset cleaned and saved!")
+
+if __name__ == "__main__":
+  preprocess_books()

recommender.py

@@ -0,0 +1,35 @@
+import numpy as np
+import pandas as pd
+import pickle
+from sentence_transformers import SentenceTransformer, util
+from embeddings import load_book_data
+
+class BookRecommender:
+    def __init__(self, data_path="/content/data/books_summary.csv", emb_path="/content/model/sbert_embeddings2.pkl"):
+        """Loads book dataset and precomputed embeddings."""
+        # from data_loader import load_book_data
+        self.df = load_book_data(data_path)
+
+        with open(emb_path, "rb") as f:
+            self.embeddings = pickle.load(f)
+
+    def recommend(self, book_title, top_n=5):
+        """Finds top-N similar books, ensuring diversity in recommendations."""
+        if book_title not in df["book_name"].values:
+            raise ValueError("Book title not found in dataset!")
+
+        # Get the book index
+        book_idx = self.df[self.df["book_name"] == book_title].index[0]
+
+        # Compute cosine similarity with all books
+        query_embedding = self.embeddings[book_idx]
+        scores = util.cos_sim(query_embedding, self.embeddings)[0]
+
+        # Sort by similarity (excluding the book itself)
+        top_indices = np.argsort(scores.numpy())[::-1][1:top_n+1]
+
+        return self.df.iloc[top_indices][["book_name"]].values.tolist()
+
+# recommender = BookRecommender()
+# print(recommender.recommend("The End Of Stress"))  # Test with a known book title
+