File size: 5,309 Bytes
4536b92
 
 
 
 
2b69634
4536b92
 
 
 
 
 
 
 
2b69634
4536b92
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
import asyncio
import tempfile
import os
import fitz  # PyMuPDF
import io
import streamlit as st
from PIL import Image
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain_community.llms import HuggingFacePipeline
from transformers import AutoTokenizer, pipeline, AutoModelForSeq2SeqLM

# Fix for event loop issues
if os.name == 'nt':
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

MODEL_NAME = "google/flan-t5-base"
EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
CHUNK_SIZE = 500
CHUNK_OVERLAP = 50

def initialize_general_model():
    """Initialize the model for general knowledge questions"""
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
    model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME)
    
    return pipeline(
        "text2text-generation",
        model=model,
        tokenizer=tokenizer,
        max_length=256,
        temperature=0,
        repetition_penalty=1.2
    )

def create_vector_store(pdf_path):
    """Process PDF and create FAISS vector store"""
    loader = PyPDFLoader(pdf_path)
    pages = loader.load_and_split()

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=CHUNK_SIZE,
        chunk_overlap=CHUNK_OVERLAP
    )
    texts = text_splitter.split_documents(pages)

    embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL)
    return FAISS.from_documents(texts, embeddings)

def create_qa_chain(vectorstore):
    """Create the Retrieval QA chain for PDF content"""
    pipe = initialize_general_model()
    llm = HuggingFacePipeline(pipeline=pipe)
    
    return RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=vectorstore.as_retriever(),
        return_source_documents=True
    )

def render_pdf_page(pdf_bytes, page_number):
    """Render specific PDF page as image"""
    doc = fitz.open(stream=pdf_bytes, filetype="pdf")
    page = doc.load_page(page_number)
    pix = page.get_pixmap()
    img_bytes = pix.tobytes()
    return Image.open(io.BytesIO(img_bytes))

def main():
    st.title("VectorAsk")
    st.write("Get answers with source page images!")
    
    # Initialize session states
    if 'pdf_bytes' not in st.session_state:
        st.session_state.pdf_bytes = None

    mode = st.radio("Select answer source:",
                    ("PDF Content", "Text input"),
                    horizontal=True)

    if mode == "PDF Content":
        uploaded_file = st.file_uploader("Upload PDF", type="pdf")
        if uploaded_file is not None:
            st.session_state.pdf_bytes = uploaded_file.getvalue()
            with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_file:
                tmp_file.write(st.session_state.pdf_bytes)
                tmp_path = tmp_file.name

            with st.spinner("Processing PDF..."):
                vectorstore = create_vector_store(tmp_path)
                os.remove(tmp_path)
                st.session_state['qa_chain'] = create_qa_chain(vectorstore)

    question = st.text_input("Enter your question:")
    
    if question:
        with st.spinner("Generating answer..."):
            if mode == "General Knowledge":
                if 'general_pipe' not in st.session_state:
                    st.session_state.general_pipe = initialize_general_model()
                
                result = st.session_state.general_pipe(
                    question,
                    max_length=256,
                    temperature=0
                )[0]['generated_text']
                
                st.subheader("Answer:")
                st.write(result)
                st.info("This answer is generated from the model's general knowledge")
                
            elif mode == "PDF Content":
                if 'qa_chain' not in st.session_state:
                    st.warning("Please upload a PDF file first!")
                    return
                
                result = st.session_state['qa_chain']({"query": question})
                
                # Display answer
                st.subheader("Answer:")
                st.write(result["result"])
                
                # Display source documents with images
                st.subheader("Source Evidence:")
                for doc in result["source_documents"]:
                    page_num = doc.metadata['page']
                    
                    col1, col2 = st.columns([2, 3])
                    with col1:
                        try:
                            img = render_pdf_page(st.session_state.pdf_bytes, page_num)
                            st.image(img, caption=f"Page {page_num + 1}", use_column_width=True)
                        except Exception as e:
                            st.error(f"Error rendering page: {str(e)}")
                    
                    with col2:
                        st.write(f"**Page {page_num + 1} Content:**")
                        st.write(doc.page_content)
                    
                    st.write("---")

if __name__ == "__main__":
    main()