Update app.py

app.py

@@ -1,116 +1,163 @@
 import streamlit as st
 import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import faiss
 import numpy as np
+import faiss
+from transformers import AutoModelForCausalLM, AutoTokenizer
 from sentence_transformers import SentenceTransformer
-import PyPDF2
+import fitz  # PyMuPDF for better PDF extraction
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 
-# Model Setup
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_path = "ibm-granite/granite-3.1-1b-a400m-instruct"
-tokenizer = AutoTokenizer.from_pretrained(model_path)
+# Configuration
+MODEL_NAME = "ibm-granite/granite-3.1-1b-a400m-instruct"
+EMBED_MODEL = "sentence-transformers/all-mpnet-base-v2"
+CHUNK_SIZE = 512
+CHUNK_OVERLAP = 64
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
-# Load the model with a conditional to avoid meta tensor issues on CPU vs GPU
-if device == "cpu":
-    model = AutoModelForCausalLM.from_pretrained(model_path)
-else:
-    model = AutoModelForCausalLM.from_pretrained(
-        model_path,
-        device_map="auto",
-        low_cpu_mem_usage=True,
-        torch_dtype=torch.float16,
-    )
-model.eval()
+# Initialize session state
+if "docs" not in st.session_state:
+    st.session_state.docs = []
+if "index" not in st.session_state:
+    st.session_state.index = None
 
-# Embedding Model for FAISS
-embedding_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+# Model loading with better error handling
+@st.cache_resource
+def load_models():
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            device_map="auto" if DEVICE == "cuda" else None,
+            torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
+            low_cpu_mem_usage=True
+        ).eval()
+        
+        embedder = SentenceTransformer(EMBED_MODEL, device=DEVICE)
+        return tokenizer, model, embedder
+    
+    except Exception as e:
+        st.error(f"Model loading failed: {str(e)}")
+        st.stop()
 
-# FAISS Index
-dimension = 384  # Embedding size for MiniLM
-index = faiss.IndexFlatL2(dimension)
-docs = []  # Store document texts
-summary = ""  # Store book summary
+tokenizer, model, embedder = load_models()
 
-# Function to extract text from PDF
-def extract_text_from_pdf(uploaded_file):
-    reader = PyPDF2.PdfReader(uploaded_file)
-    text = "\n".join([page.extract_text() for page in reader.pages if page.extract_text()])
-    return text
+# Improved text processing
+def process_text(text):
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=CHUNK_SIZE,
+        chunk_overlap=CHUNK_OVERLAP,
+        length_function=len
+    )
+    return splitter.split_text(text)
 
-# Function to process uploaded documents and generate summary
-def process_documents(files):
-    global docs, index, summary
-    docs = []
+# Enhanced PDF extraction
+def extract_pdf_text(uploaded_file):
+    try:
+        doc = fitz.open(stream=uploaded_file.read(), filetype="pdf")
+        return "\n".join([page.get_text() for page in doc])
+    except Exception as e:
+        st.error(f"PDF extraction error: {str(e)}")
+        return ""
+
+# Multi-step summarization
+def generate_summary(text):
+    chunks = process_text(text)[:10]  # Use first 10 chunks for summary
+    summaries = []
     
-    for file in files:
-        if file.type == "application/pdf":
-            text = extract_text_from_pdf(file)
-        else:
-            text = file.getvalue().decode("utf-8")
-        docs.append(text)
+    for chunk in chunks:
+        prompt = f"""<|user|>
+        Summarize this text section focusing on key themes, characters, and plot points:
+        {chunk[:2000]}
+        <|assistant|>
+        """
+        
+        inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
+        outputs = model.generate(**inputs, max_new_tokens=300, temperature=0.3)
+        summaries.append(tokenizer.decode(outputs[0], skip_special_tokens=True))
     
-    embeddings = embedding_model.encode(docs)
-    index.add(np.array(embeddings))
+    # Combine summaries
+    combined = "\n".join(summaries)
+    final_prompt = f"""<|user|>
+    Combine these section summaries into a coherent book summary:
+    {combined}
+    <|assistant|>
+    The comprehensive summary is:"""
     
-    # Generate summary after processing documents
-    summary = generate_summary("\n".join(docs))
+    inputs = tokenizer(final_prompt, return_tensors="pt").to(DEVICE)
+    outputs = model.generate(**inputs, max_new_tokens=500, temperature=0.5)
+    return tokenizer.decode(outputs[0], skip_special_tokens=True).split(":")[-1].strip()
 
-# Function to generate a book summary
-def generate_summary(text):
-    chat = [
-        {"role": "system", "content": "You are a helpful AI that summarizes books."},
-        {"role": "user", "content": f"Summarize this book in a short paragraph:\n{text[:4000]}"}  # Limiting input size for summarization
-    ]
-    chat = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
-    input_tokens = tokenizer(chat, return_tensors="pt").to(device)
-    output = model.generate(**input_tokens, max_new_tokens=300)
-    return tokenizer.batch_decode(output, skip_special_tokens=True)[0]
+# Enhanced retrieval system
+def build_faiss_index(texts):
+    embeddings = embedder.encode(texts, show_progress_bar=True)
+    dimension = embeddings.shape[1]
+    index = faiss.IndexFlatIP(dimension)
+    faiss.normalize_L2(embeddings)
+    index.add(embeddings)
+    return index
 
-# Function to retrieve relevant context using FAISS
-def retrieve_context(query):
-    if index.ntotal == 0:
-        return "No documents available. Please upload files first."
+# Context-aware generation
+def generate_answer(query, context):
+    prompt = f"""<|user|>
+    Using this context: {context}
+    Answer the question precisely and truthfully. If unsure, say "I don't know".
+    Question: {query}
+    <|assistant|>
+    """
     
-    query_embedding = embedding_model.encode([query])
-    distances, indices = index.search(np.array(query_embedding), k=1)
-    
-    if len(indices) == 0 or indices[0][0] >= len(docs):
-        return "No relevant context found."
-    return docs[indices[0][0]]
-
-# Function to generate response using IBM Granite model
-def generate_response(query, context):
-    chat = [
-        {"role": "system", "content": "You are a helpful assistant using retrieved knowledge."},
-        {"role": "user", "content": f"Context: {context}\nQuestion: {query}\nAnswer based on context:"},
-    ]
-    chat = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
-    input_tokens = tokenizer(chat, return_tensors="pt").to(device)
-    output = model.generate(**input_tokens, max_new_tokens=200)
-    return tokenizer.batch_decode(output, skip_special_tokens=True)[0]
+    inputs = tokenizer(prompt, return_tensors="pt", max_length=1024, truncation=True).to(DEVICE)
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=300,
+        temperature=0.4,
+        top_p=0.9,
+        repetition_penalty=1.2,
+        do_sample=True
+    )
+    return tokenizer.decode(outputs[0], skip_special_tokens=True).split("<|assistant|>")[-1].strip()
 
 # Streamlit UI
-st.set_page_config(page_title="📖 AI Book Assistant", page_icon="📚")
-st.title("📖 AI-Powered Book Assistant")
-st.subheader("Upload a book and get its summary or ask questions!")
+st.set_page_config(page_title="📚 Smart Book Analyst", layout="wide")
+st.title("📚 AI-Powered Book Analysis System")
 
-uploaded_file = st.file_uploader("Upload a book (PDF or TXT)", accept_multiple_files=False)
+uploaded_file = st.file_uploader("Upload book (PDF or TXT)", type=["pdf", "txt"])
 
 if uploaded_file:
-    with st.spinner("Processing book and generating summary..."):
-        process_documents([uploaded_file])
-    st.success("Book uploaded and processed!")
-    st.markdown("### 📚 Book Summary:")
-    st.write(summary)
+    with st.spinner("📖 Analyzing book content..."):
+        try:
+            if uploaded_file.type == "application/pdf":
+                text = extract_pdf_text(uploaded_file)
+            else:
+                text = uploaded_file.read().decode()
+            
+            chunks = process_text(text)
+            st.session_state.docs = chunks
+            st.session_state.index = build_faiss_index(chunks)
+            
+            with st.expander("📝 Book Summary", expanded=True):
+                summary = generate_summary(text)
+                st.write(summary)
+                
+        except Exception as e:
+            st.error(f"Processing failed: {str(e)}")
 
-query = st.text_input("Ask a question about the book:")
-if st.button("Get Answer"):
-    if index.ntotal == 0:
-        st.warning("Please upload a book first!")
-    else:
-        with st.spinner("Retrieving and generating response..."):
-            context = retrieve_context(query)
-            response = generate_response(query, context)
-            st.markdown("### 🤖 Answer:")
-            st.write(response)
+if st.session_state.index:
+    query = st.text_input("Ask about the book:")
+    if query:
+        with st.spinner("🔍 Searching for answers..."):
+            try:
+                # Retrieve top 3 relevant chunks
+                query_embed = embedder.encode([query])
+                faiss.normalize_L2(query_embed)
+                distances, indices = st.session_state.index.search(query_embed, k=3)
+                
+                context = "\n".join([st.session_state.docs[i] for i in indices[0]])
+                answer = generate_answer(query, context)
+                
+                st.subheader("Answer")
+                st.markdown(f"```\n{answer}\n```")
+                st.caption("Retrieved context confidence: {:.2f}".format(distances[0][0]))
+                
+            except Exception as e:
+                st.error(f"Query failed: {str(e)}")