Addsome changes 6

app.py

@@ -3,9 +3,9 @@ import pandas as pd
 import pickle
 import torch
 from sentence_transformers import SentenceTransformer, util, CrossEncoder
-from recommender import BookRecommender
 from duckduckgo_search import DDGS
 from fuzzywuzzy import process
+
 # Load book dataset
 df = pd.read_csv("data/books_summary_cleaned.csv")
 
@@ -17,61 +17,57 @@ with open("model/sbert_embeddings2.pkl", "rb") as f:
 retriever_model = SentenceTransformer("all-mpnet-base-v2")  # More accurate than MiniLM
 reranker_model = CrossEncoder("cross-encoder/ms-marco-MiniLM-L-6-v2")  # More accurate ranking
 
-def fetch_summary_duckduckgo(book_title):
+def fetch_summary_duckduckgo(book_title, log):
     """Fetch book summary from DuckDuckGo API (search engine)."""
+    log.append(f"Searching the internet for '{book_title}' summary...")
+
     with DDGS() as ddgs:
         search_results = list(ddgs.text(f"{book_title} book summary", max_results=3))
-    print(search_results)
-    itr = 0
+
     for result in search_results:
-        if itr<=1:
-          itr+=1
-          continue
         if "body" in result:
-            return result["body"]
-    
-    return None
-
-def get_best_match(book_title, book_list):
-    """
-    Finds the closest matching book title in the dataset.
+            log.append("Summary found from the web.")
+            return result["body"], log
     
-    Parameters:
-    - book_title (str): User-inputted book title (possibly with typos).
-    - book_list (list): List of book titles in the dataset.
+    log.append("No summary found on the web.")
+    return None, log
 
-    Returns:
-    - str: Best-matching book title.
-    """
+def get_best_match(book_title, book_list, log):
+    """Find the closest matching book title in the dataset using fuzzy matching."""
     best_match, score = process.extractOne(book_title, book_list)
-    return best_match if score > 90 else book_title
+    if score > 90:
+        log.append(f"Typo detected! Corrected '{book_title}' to '{best_match}'.")
+        return best_match, log
+    log.append(f"No correction needed for '{book_title}'.")
+    return book_title, log
 
 def retrieve_candidates(book_title, top_n=10):
     """Retrieve top-N similar books using SBERT embeddings"""
-    book_title = get_best_match(book_title, df["book_name"].values.tolist())
+    log = ["Starting book recommendation process..."]
+    book_title, log = get_best_match(book_title, df["book_name"].values.tolist(), log)
     
     if book_title in df["book_name"].values:
         book_idx = df[df["book_name"] == book_title].index[0]
         query_embedding = book_embeddings[book_idx]
-        summary = df[df["summaries"] == book_title]
-    # If book is NOT in dataset
+        summary = df[df["book_name"] == book_title]["summaries"].values[0]
+        log.append(f"Book '{book_title}' found in the dataset.")
     else:
-        print(f"Book '{book_title}' not found! scraping the web for summaries")
-        summary = fetch_summary_duckduckgo(book_title)
+        log.append(f"Book '{book_title}' not found in the dataset.")
+        summary, log = fetch_summary_duckduckgo(book_title, log)
         
         if summary is None:
-            return None
-        # Compute embedding for new book summary
+            log.append("No summary found. Cannot proceed with recommendation.")
+            return None, None, None, log
+
         query_embedding = retriever_model.encode(summary, convert_to_tensor=True)
 
     scores = util.cos_sim(query_embedding, book_embeddings)[0]
-
-    # Get top-N similar books (excluding the book itself)
     top_indices = torch.argsort(scores, descending=True)[1:top_n+1]
 
-    return book_title, summary ,df.iloc[top_indices][["book_name", "summaries"]].values.tolist()
+    log.append(f"Top {top_n} similar books retrieved from the dataset.")
+    return book_title, query_embedding, df.iloc[top_indices][["book_name", "summaries"]].values.tolist(), log
 
-def rerank_books(query_title, query_embedding, candidates):
+def rerank_books(query_title, query_embedding, candidates, log):
     """Re-rank books using a cross-encoder"""
     query_summary = df[df["book_name"] == query_title]["summaries"].values[0]
     pairs = [(query_summary, cand_summary) for _, cand_summary in candidates]
@@ -79,17 +75,21 @@ def rerank_books(query_title, query_embedding, 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]]  
+    log.append("Books re-ranked based on cross-encoder model.")
+    return [book[0][0] for book in ranked_books[:5]], log
 
 def recommend_books(book_title):
-    """Complete recommendation pipeline"""
-    book_title, query_embedding, candidates = retrieve_candidates(book_title, top_n=10)
-    if book_title==None:
-        return "Book not found"
-    if isinstance(candidates, list) and "Error" in candidates[0]:
-        return candidates[0]
+    """Complete recommendation pipeline with logging"""
+    book_title, query_embedding, candidates, log = retrieve_candidates(book_title, top_n=10)
+    
+    if book_title is None:
+        log.append("Book not found. Exiting recommendation process.")
+        return "Book not found", "\n".join(log)
+
+    recommendations, log = rerank_books(book_title, query_embedding, candidates, log)
+    log.append("Recommendation process complete.")
     
-    return rerank_books(book_title, query_embedding, candidates)
+    return ", ".join(recommendations), "\n".join(log)
 
 # Gradio Interface
 with gr.Blocks() as demo:
@@ -100,7 +100,7 @@ with gr.Blocks() as demo:
         book_input = gr.Textbox(label="Enter Book Title")
         submit_btn = gr.Button("Recommend")
     
-    output = gr.Textbox(label="Recommended Books")
+    output = gr.Textbox(label="Recommended Books", interactive=False)
     log_output = gr.Textbox(label="Logs", interactive=False, lines=10)  # Log display
 
     submit_btn.click(recommend_books, inputs=book_input, outputs=[output, log_output])