app.py

import nltk
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer

# Download necessary resources (comment out if already downloaded)
nltk.download('punkt')
nltk.download('stopwords')

def preprocess_text(text):
  """
  This function preprocesses the text for training.

  Args:
      text: String containing the text data.

  Returns:
      A list of preprocessed tokens.
  """
  # Tokenization
  tokens = nltk.word_tokenize(text.lower())  # Lowercase and tokenize

  # Stop word removal
  stop_words = set(stopwords.words('english'))
  tokens = [word for word in tokens if word not in stop_words]

  # Stemming (optional - Experiment with stemming vs lemmatization)
  stemmer = PorterStemmer()
  tokens = [stemmer.stem(word) for word in tokens]

  return tokens

# Read the Bhagavad Gita text file
with open("Geeta.txt", "r") as f:
  bhagavad_gita_text = f.read()

# Preprocess the text
preprocessed_text = preprocess_text(bhagavad_gita_text)

# Install spaCy (if not already installed)
# pip install spacy
import spacy

# Load a spaCy model for English language processing
# nlp = spacy.load("en_core_web_sm")

# import spacy
import subprocess



try:
    nlp = spacy.load("en_core_web_sm")
except OSError:
    print("Downloading en_core_web_sm model...")
    subprocess.run(["python", "-m", "spacy", "download", "en_core_web_sm"])
    nlp = spacy.load("en_core_web_sm")

# @st.cache(allow_output_mutation=True)
# def download_and_load_model():
#     try:
#         nlp = spacy.load("en_core_web_sm")
#     except OSError:
#         print("Downloading en_core_web_sm model...")
#         !python -m spacy download en_core_web_sm  # This line works within the cached function
#         nlp = spacy.load("en_core_web_sm")
#     return nlp

# # Later in your code, use the model:
# nlp = download_and_load_model()



def extractive_qa(question, text):
  """
  This function attempts to answer a question by extracting relevant phrases from the text.

  Args:
      question: The user's question.
      text: The text to search for answers (Bhagavad Gita text).

  Returns:
      A potential answer extracted from the text (or None if not found).
  """
  doc = nlp(text)
  doc_question = nlp(question)

  # Identify named entities and noun phrases in the question that might be relevant for searching the text
  answer_candidates = []
  for ent in doc_question.ents:
      answer_candidates.append(ent.text)
  for chunk in doc_question.noun_chunks:
      answer_candidates.append(chunk.text)

  # Search for the answer candidates within the text and return the first match
  for candidate in answer_candidates:
      if candidate in text:
          return candidate
  return None

# Use extractive_qa to generate some question-answer pairs from the Bhagavad Gita text
qa_pairs = []
for question in ["What is karma?", "Who is Arjuna?"]:
  answer = extractive_qa(question, bhagavad_gita_text)
  if answer:
      qa_pairs.append((question, answer))

# You can combine manually curated and extractive QA pairs for a richer dataset.
# Create a list of question-answer pairs manually (replace with your examples)
# qa_pairs = [
#   ("What is the central message of the Bhagavad Gita?", "The Bhagavad Gita emphasizes the importance of fulfilling one's duty without attachment to the outcome."),
#   ("What is the role of Krishna in the Bhagavad Gita?", "Krishna acts as Arjuna's charioteer and divine guide, offering him philosophical knowledge and motivation to perform his duty."),
#   # Add more question-answer pairs...
# ]
from transformers import BertTokenizer, TFBertForQuestionAnswering
from transformers import Adam  # Optimizer (optional)
from transformers import SquadLoss  # Loss function (optional)

# Load pre-trained model and tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = TFBertForQuestionAnswering.from_pretrained('bert-base-uncased')


# Function to prepare training data for transformers (omitted for brevity)
def prepare_training_data(qa_pairs, tokenizer):
  """
  This function prepares training data for a question answering model by converting
  question-answer pairs into model inputs (token IDs, attention masks).

  Args:
      qa_pairs: A list of tuples containing (question, answer) pairs.
      tokenizer: A pre-trained tokenizer (e.g., BertTokenizer).

  Returns:
      A list of dictionaries containing model inputs for each question-answer pair.
  """

  encoded_data = []
  for question, answer in qa_pairs:
    # Tokenize question and answer
    question_encoded = tokenizer(question, add_special_tokens=True, return_tensors="pt")
    answer_encoded = tokenizer(answer, add_special_tokens=True, return_tensors="pt")

    # Create attention masks to identify relevant parts of the sequence
    question_mask = question_encoded["attention_mask"]
    answer_mask = answer_encoded["attention_mask"]

    # Get start and end token IDs for the answer within the context (Bhagavad Gita text)
    # This step might require adjustments depending on how you represent the context.
    # Here, we assume the context is a single long string.
    context = "your_bhagavad_gita_text_here"  # Replace with your preprocessed Bhagavad Gita text
    context_encoded = tokenizer(context, add_special_tokens=True, return_tensors="pt")
    start_positions = answer_encoded.input_ids == tokenizer.convert_tokens_to_ids(tokenizer.sep_token)[0]  # Find first SEP token
    end_positions = answer_encoded.input_ids == tokenizer.convert_tokens_to_ids(tokenizer.eos_token)[0]  # Find first EOS token

    # Combine all data into a dictionary for each QA pair
    encoded_data.append({
      "question_input_ids": question_encoded["input_ids"],
      "question_attention_mask": question_mask,
      "answer_start_positions": start_positions,
      "answer_end_positions": end_positions,
    })

  return encoded_data

# Prepare training data
train_data = prepare_training_data(qa_pairs)

# Train the model
learning_rate = 2e-5
epochs = 3  # Adjust these values as needed
model.compile(optimizer=Adam(learning_rate=learning_rate), loss=SquadLoss())
model.fit(train_data, epochs=epochs)

# Save the trained model and tokenizer
model.save_pretrained("bhagavad_gita_qa_model")
tokenizer.save_pretrained("bhagavad_gita_qa_model")

print("Model and tokenizer saved successfully!")

import streamlit as st
from transformers import pipeline  # For loading the QA model

qa_pipeline = pipeline("question-answering", model="bhagavad_gita_qa_model")

st.title("Bhagavad Gita Question Answering")
st.subheader("Ask your questions about the Bhagavad Gita here.")

user_question = st.text_input("Enter your question:")

if user_question:
  # Pass the user question and Bhagavad Gita text to the loaded model
  answer = qa_pipeline(question=user_question, context=bhagavad_gita_text)
  st.write(f"Answer: {answer['answer']}")
  # Optionally, display additional information like confidence score
  # st.write(f"Confidence Score: {answer['score']}")













# import google.generativeai as palm
# import streamlit as st 
# import os 

# # Set your API key
# palm.configure(api_key = os.environ['PALM_KEY'])

# # Select the PaLM 2 model
# model = 'models/text-bison-001'

# # Generate text
# if prompt := st.chat_input("Ask your query..."):
#     enprom = f"""Act as bhagwan krishna and Answer the below provided query in context to first Bhagwad Geeta and then vedas, puranas and shastras if required. Use the verses and chapters sentences as references to your answer with suggestions
#     coming from Bhagwad Geeta or vedas. Your answer to below query should be friendly and represent the characterstics of bhagwan krishna with fun and all knowing almight trait.\nQuery= {prompt}"""
#     completion = palm.generate_text(model=model, prompt=enprom, temperature=0.5, max_output_tokens=800)

# # response = palm.chat(messages=["Hello."])
# # print(response.last) #  'Hello! What can I help you with?'
# # response.reply("Can you tell me a joke?")

# # Print the generated text
#     with st.chat_message("Assistant"):
#         st.write(prompt)
#         st.write(completion.result)





# from transformers import AutoTokenizer, AutoModelForCausalLM

# tokenizer = AutoTokenizer.from_pretrained("google/gemma-7b")
# model = AutoModelForCausalLM.from_pretrained("google/gemma-7b")

# input_text = "Write me a poem about Machine Learning."
# input_ids = tokenizer(input_text, return_tensors="pt")

# outputs = model.generate(**input_ids)
# st.write(tokenizer.decode(outputs[0]))








# import streamlit as st
# from dotenv import load_dotenv
# from PyPDF2 import PdfReader
# from langchain.text_splitter import CharacterTextSplitter
# from langchain.embeddings import HuggingFaceEmbeddings
# from langchain.vectorstores import FAISS
# # from langchain.chat_models import ChatOpenAI
# from langchain.memory import ConversationBufferMemory
# from langchain.chains import ConversationalRetrievalChain
# from htmlTemplates import css, bot_template, user_template
# from langchain.llms import HuggingFaceHub
# import os 
# # from transformers import T5Tokenizer, T5ForConditionalGeneration
# # from langchain.callbacks import get_openai_callback

# hub_token = os.environ["HUGGINGFACE_HUB_TOKEN"]

# def get_pdf_text(pdf_docs):
#     text = ""
#     for pdf in pdf_docs:
#         pdf_reader = PdfReader(pdf)
#         for page in pdf_reader.pages:
#             text += page.extract_text()
#     return text


# def get_text_chunks(text):
#     text_splitter = CharacterTextSplitter(
#         separator="\n",
#         chunk_size=200,
#         chunk_overlap=20,
#         length_function=len
#     )
#     chunks = text_splitter.split_text(text)
#     return chunks


# def get_vectorstore(text_chunks):
#     # embeddings = OpenAIEmbeddings()
#     # embeddings = HuggingFaceInstructEmbeddings(model_name="hkunlp/instructor-xl")
#     embeddings = HuggingFaceEmbeddings()
#     vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
#     return vectorstore


# def get_conversation_chain(vectorstore):
#     # llm = ChatOpenAI(model_name="gpt-3.5-turbo-16k")
#     # tokenizer = T5Tokenizer.from_pretrained("google/flan-t5-base")
#     # model = T5ForConditionalGeneration.from_pretrained("google/flan-t5-base")

#     llm = HuggingFaceHub(repo_id="mistralai/Mistral-7B-v0.1", huggingfacehub_api_token=hub_token, model_kwargs={"temperature":0.5, "max_length":20})

#     memory = ConversationBufferMemory(
#         memory_key='chat_history', return_messages=True)
#     conversation_chain = ConversationalRetrievalChain.from_llm(
#         llm=llm,
#         retriever=vectorstore.as_retriever(),
#         memory=memory
#     )
#     return conversation_chain


# def handle_userinput(user_question):
#     response = st.session_state.conversation
#     reply = response.run(user_question)
#     st.write(reply)
#     # st.session_state.chat_history = response['chat_history']

#     # for i, message in enumerate(st.session_state.chat_history):
#     #     if i % 2 == 0:
#     #         st.write(user_template.replace(
#     #             "{{MSG}}", message.content), unsafe_allow_html=True)
#     #     else:
#     #         st.write(bot_template.replace(
#     #             "{{MSG}}", message.content), unsafe_allow_html=True)


# def main():
#     load_dotenv()
#     st.set_page_config(page_title="Chat with multiple PDFs",
#                        page_icon=":books:")
#     st.write(css, unsafe_allow_html=True)

#     if "conversation" not in st.session_state:
#         st.session_state.conversation = None
#     if "chat_history" not in st.session_state:
#         st.session_state.chat_history = None

#     st.header("Chat with multiple PDFs :books:")
#     user_question = st.text_input("Ask a question about your documents:")
#     if user_question:
#         handle_userinput(user_question)

#     with st.sidebar:
#         st.subheader("Your documents")
#         pdf_docs = st.file_uploader(
#             "Upload your PDFs here and click on 'Process'", accept_multiple_files=True)
#         if st.button("Process"):
#             if(len(pdf_docs) == 0):
#                 st.error("Please upload at least one PDF")
#             else:
#                 with st.spinner("Processing"):
#                     # get pdf text
#                     raw_text = get_pdf_text(pdf_docs)

#                     # get the text chunks
#                     text_chunks = get_text_chunks(raw_text)

#                     # create vector store
#                     vectorstore = get_vectorstore(text_chunks)

#                     # create conversation chain
#                     st.session_state.conversation = get_conversation_chain(
#                         vectorstore)

# if __name__ == '__main__':
#     main()






# # import os
# # import getpass
# # import streamlit as st
# # from langchain.document_loaders import PyPDFLoader
# # from langchain.text_splitter import RecursiveCharacterTextSplitter
# # from langchain.embeddings import HuggingFaceEmbeddings
# # from langchain.vectorstores import Chroma
# # from langchain import HuggingFaceHub
# # from langchain.chains import RetrievalQA
# # # __import__('pysqlite3')
# # # import sys
# # # sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')


# # # load huggingface api key
# # hubtok = os.environ["HUGGINGFACE_HUB_TOKEN"]

# # # use streamlit file uploader to ask user for file
# # # file = st.file_uploader("Upload PDF")


# # path = "Geeta.pdf"
# # loader = PyPDFLoader(path)
# # pages = loader.load()

# # # st.write(pages)

# # splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=20)
# # docs = splitter.split_documents(pages)

# # embeddings = HuggingFaceEmbeddings()
# # doc_search = Chroma.from_documents(docs, embeddings)

# # repo_id = "tiiuae/falcon-7b"
# # llm = HuggingFaceHub(repo_id=repo_id, huggingfacehub_api_token=hubtok, model_kwargs={'temperature': 0.2,'max_length': 1000})

# # from langchain.schema import retriever
# # retireval_chain = RetrievalQA.from_chain_type(llm, chain_type="stuff", retriever=doc_search.as_retriever())

# # if query := st.chat_input("Enter a question: "):
# #   with st.chat_message("assistant"):
# #     st.write(retireval_chain.run(query))