Upload 3 files

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "flask_app:app"]

flask_app.py

@@ -0,0 +1,135 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from langchain_core.output_parsers import BaseOutputParser
+from langchain.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough, RunnableMap
+from langchain.schema import Generation
+import torch
+
+# Load your tokenizer and model
+tokenizer = AutoTokenizer.from_pretrained("NLPGenius/KPDastak-llama3-1b")
+model = AutoModelForCausalLM.from_pretrained("NLPGenius/KPDastak-llama3-1b", torch_dtype=torch.bfloat16, device_map="auto",)
+
+
+import transformers
+from transformers import pipeline
+llm_chain = transformers.pipeline(
+    model=model, tokenizer=tokenizer,
+    return_full_text=True,  # langchain expects the full text
+    task='text-generation',
+    # we pass model parameters here too
+    temperature=0.3,  # 'randomness' of outputs, 0.0 is the min and 1.0 the max
+    do_sample=True,
+    max_length=2000,  # mex number of tokens to generate in the output
+    truncation=True,
+    repetition_penalty=1.1  # without this output begins repeating
+)
+
+from langchain.llms import HuggingFacePipeline
+
+llm = HuggingFacePipeline(pipeline=llm_chain)
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.vectorstores import FAISS
+
+# Define the chunking and embedding strategy
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+embedding_model = HuggingFaceEmbeddings()  # Adjust if you have a specific embedding model
+
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from langchain_community.document_loaders import Docx2txtLoader
+
+# Set up the vector store for FAISS
+def create_faiss_index(pdf_path):
+    loader = Docx2txtLoader(pdf_path)
+    data = loader.load()
+    
+    texts = text_splitter.split_documents(data)
+    
+    vector_store = FAISS.from_documents(texts, embedding_model)
+    retriever = vector_store.as_retriever()
+    return retriever
+
+
+# Define a custom output parser to extract only the answer
+class AnswerOutputParser(BaseOutputParser):
+    def parse(self, text: str) -> str:
+        # Extract everything after "Answer:"
+        if "Answer:" in text:
+            return text.split("Answer:")[-1].strip()
+        return "I don't know."
+
+# Define the RAG pipeline
+def create_rag_pipeline(pdf_path):
+    retriever = create_faiss_index(pdf_path)
+
+    # Define the prompt template
+    prompt = PromptTemplate(
+        input_variables=["context", "question"],
+        template="""\
+        You are a helpful assistant. Answer the query accurately by focusing solely on the most relevant parts of the provided context.
+        1. Identify and use only the sections of the context directly related to the query, ignoring unrelated or extraneous information.
+        2. If the query cannot be explicitly answered using the relevant parts of the context, respond with: "The answer is not found in the context provided."
+        
+        Context:
+        {context}
+        
+        Query:
+        {question}
+        
+        Answer:
+        """
+    )
+
+    # Define the sequence
+    rag_chain = (
+        RunnableMap({"context": retriever, "question": RunnablePassthrough()})  # Map inputs
+        | prompt  # Use the prompt template
+        | llm  # Apply the LLM
+        | AnswerOutputParser()  # Extract answer from output
+    )
+    return rag_chain
+
+# Usage example
+pdf_path = "Dastak_FullContext.docx"
+rag_pipeline = create_rag_pipeline(pdf_path)
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+# Initialize Flask app
+app = Flask(__name__)
+CORS(app, supports_credentials=True, allow_headers=["Content-Type"])
+
+# Mock chatbot function (replace with your actual pipeline)
+def chatbot_response(query):
+    try:
+        # Call your actual RAG pipeline here
+        response = rag_pipeline.invoke(query)  # Replace with your actual RAG pipeline call
+        return response
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Route for chatbot responses
+@app.route('/', methods=['GET','POST'])
+def chat():
+    
+    # Try to get JSON data
+    if request.content_type == 'application/json':
+        data = request.get_json(silent=True)
+        user_query = data.get("query", "").strip() if data else ""
+    else:
+        # Fallback to form-data
+        user_query = request.form.get("query", "").strip()
+    
+    if not user_query:
+        return jsonify({"error": "Please provide a valid query."}), 400
+
+    # Get chatbot response
+    bot_reply = chatbot_response(user_query)
+    return jsonify({"response": bot_reply})
+
+# Run the Flask app
+if __name__ == '__main__':
+    app.run()

requirements.txt

@@ -0,0 +1,23 @@
+jupyter
+transformers
+git+https://github.com/huggingface/transformers.git
+numpy
+torch
+aiohttp
+torchvision 
+torchaudio
+langchain 
+unstructured
+langchain-community
+faiss-cpu
+docx2txt
+sentence-transformers
+xformers
+accelerate 
+einops
+scikit-learn 
+datasets 
+peft
+flask
+flask-cors
+gunicorn