update space

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: RegRag
+emoji: 💬
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 5.0.1
+app_file: app.py
+pinned: false
+license: mit
+---
+
+An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).

app.py

@@ -0,0 +1,54 @@
+# app.py
+import gradio as gr
+
+from rag_agent import prepare_index_and_chunks, load_model
+from utils.retrieval import retrieve_relevant_chunks
+from utils.generation import generate_answer
+
+# ——— FIXED CONFIGURATION ———
+PDF_FOLDER      = "./data"  # your folder with all PDFs
+EMBEDDER        = "sentence-transformers/multi-qa-mpnet-base-dot-v1"
+CHUNK_SIZE      = 500
+OVERLAP         = 100
+INDEX_TYPE      = "innerproduct"
+MODEL_NAME      = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
+TOP_K           = 5
+
+# ——— PREPARE INDEX & MODEL ONCE ———
+faiss_index_path, chunks_path = prepare_index_and_chunks(
+    pdf_folder=PDF_FOLDER,
+    chunk_size=CHUNK_SIZE,
+    overlap=OVERLAP,
+    index_type=INDEX_TYPE,
+    embedder_name=EMBEDDER
+)
+model, tokenizer = load_model(MODEL_NAME)
+
+# ——— INFERENCE FUNCTION ———
+def answer_query(query: str) -> str:
+    if not query.strip():
+        return "⚠️ Please enter a question."
+    # Retrieve top-K chunks
+    chunks = retrieve_relevant_chunks(
+        query=query,
+        embedder_name=EMBEDDER,
+        k=TOP_K,
+        faiss_index=faiss_index_path,
+        chunks_path=chunks_path
+    )
+    # Generate answer
+    return generate_answer(query, chunks, model, tokenizer)
+
+# ——— GRADIO UI ———
+iface = gr.Interface(
+    fn=answer_query,
+    inputs=gr.Textbox(lines=2, placeholder="Type your telecom question here…", label="Question"),
+    outputs=gr.Textbox(label="Answer"),
+    title="📡 Telecom RAG Assistant",
+    description=(
+        "Ask questions over the preloaded telecom regulation PDFs.\n\n"
+    )
+)
+
+if __name__ == "__main__":
+    iface.launch()

data/.gitattributes

@@ -0,0 +1 @@
+*.pdf filter=lfs diff=lfs merge=lfs -text

data/2400594-RR-Vol 1-E-A5.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a19db60201342f44443143c01c528abe725b93cf133602631edaa2b6c9ba6a8f
+size 2496298

data/2400594-RR-Vol 2-E-A5.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49e283a5c22e57b44b5e0220eee94df4a7d2055418662bf83c125475d98f3abf
+size 7200340

data/2400594-RR-Vol 3-E-A5.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a08159f6efe34c5ea71db5c698fc30bd27167a94b05dafdbe9a86196d6cdc492
+size 5431837

data/2400594-RR-Vol 4-E-A5.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4f5f521c351c117c817257bcb90a748ffaf15a41717a6d82385c3a6be2d3271
+size 8507819

rag_agent.py

@@ -0,0 +1,153 @@
+import os
+import argparse
+import pdfplumber
+import numpy as np
+import faiss
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import torch
+from sentence_transformers import SentenceTransformer
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from utils.retrieval import retrieve_relevant_chunks
+from utils.generation import generate_answer
+from pathlib import Path
+
+
+DEFAULT_MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
+DEFAULT_TOP_K = 5
+DEFAULT_CHUNK_SIZE = 500
+DEFAULT_OVERLAP = 100
+DEFAULT_INDEX_TYPE = "innerproduct"
+
+def extract_text_from_pdfs(pdf_folder):
+    """
+    Extract text from all PDF files in a folder.
+    """
+    texts = []
+    for pdf_file in os.listdir(pdf_folder):
+        if pdf_file.endswith(".pdf"):
+            with pdfplumber.open(os.path.join(pdf_folder, pdf_file)) as pdf:
+                text = "\n".join(
+                    [page.extract_text() for page in pdf.pages if page.extract_text()]
+                )
+                texts.append(text)
+    return texts
+
+def chunk_text(texts, chunk_size, overlap, folder_path):
+    """
+    Split text into overlapping chunks.
+    """
+    splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=overlap)
+    chunks = []
+    for text in texts:
+        chunks.extend(splitter.split_text(text))
+    chunks_path = folder_path / f"chunks_{chunk_size}_{overlap}.npy"
+    np.save(chunks_path, chunks)
+    return chunks
+
+def create_faiss_index(chunks, index_type, folder_path, embedder_name):
+    """
+    Create a FAISS index based on the selected type.
+    """
+    embedder = SentenceTransformer(embedder_name)
+    embeddings = embedder.encode(chunks, convert_to_numpy=True)
+    dimension = embeddings.shape[1]
+
+    if index_type == "flatl2":
+        index = faiss.IndexFlatL2(dimension)
+    elif index_type == "innerproduct":
+        index = faiss.IndexFlatIP(dimension)
+    elif index_type == "hnsw":
+        index = faiss.IndexHNSWFlat(dimension, 32)  # HNSW with 32 connections per node
+    elif index_type == "ivfflat":
+        nlist = 100
+        quantizer = faiss.IndexFlatL2(dimension)
+        index = faiss.IndexIVFFlat(quantizer, dimension, nlist, faiss.METRIC_L2)
+        index.train(embeddings)
+    elif index_type == "ivfpq":
+        nlist = 100
+        m = 8  # Number of subquantizers
+        quantizer = faiss.IndexFlatL2(dimension)
+        index = faiss.IndexIVFPQ(quantizer, dimension, nlist, m, 8)
+        index.train(embeddings)
+    elif index_type == "ivfsq":
+        nlist = 100
+        quantizer = faiss.IndexFlatL2(dimension)
+        index = faiss.IndexIVFScalarQuantizer(quantizer, dimension, nlist, faiss.ScalarQuantizer.QT_fp16)
+        index.train(embeddings)
+    else:
+        raise ValueError(f"Unsupported index type: {index_type}")
+
+    index.add(embeddings)
+    index_path = folder_path / f"index_{index_type}.idx"
+    faiss.write_index(index, str(index_path))
+    print(f"✅ FAISS Index ({index_type}) and text chunks saved successfully.")
+
+
+def load_model(model_name):
+    """
+    Load the generative model and its tokenizer.
+    """
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        torch_dtype=torch.float16,
+        device_map="auto"
+    )
+    return model, tokenizer
+
+def prepare_index_and_chunks(pdf_folder, chunk_size, overlap, index_type, embedder_name):
+    """
+    Prepare (or create if necessary) the FAISS index and text chunks from PDFs.
+    The folder is named based on the parameters, similar to evaluate_rag.
+    """
+    folder_name = f"{embedder_name} ; {index_type}_chunk{chunk_size}_overlap{overlap}"
+    folder_path = Path(folder_name)
+    if folder_path.exists():
+        faiss_index_path = str(folder_path / f"index_{index_type}.idx")
+        chunks_path = folder_path / f"chunks_{chunk_size}_{overlap}.npy"
+    else:
+        folder_path.mkdir(parents=True, exist_ok=True)
+        texts = extract_text_from_pdfs(pdf_folder)
+        chunks = chunk_text(texts, chunk_size, overlap, folder_path)
+        create_faiss_index(chunks, index_type, folder_path, embedder_name)
+        faiss_index_path = str(folder_path / f"index_{index_type}.idx")
+        chunks_path = folder_path / f"chunks_{chunk_size}_{overlap}.npy"
+    return faiss_index_path, chunks_path
+
+
+def rag_agent(pdf_folder, chunk_size, overlap, index_type, model_name, k):
+    """
+    Interactive RAG chatbot that creates the FAISS index and text chunks if they don't exist.
+    """
+    print("\n📡 Telecom Regulation RAG Agent (type 'exit' to quit)\n")
+
+    # Use the same embedder as in evaluate_rag for consistency
+    embedder_name = "all-MiniLM-L6-v2"
+    embedder = SentenceTransformer(embedder_name)
+    faiss_index, chunks_path = prepare_index_and_chunks(pdf_folder, chunk_size, overlap, index_type, embedder_name)
+    model, tokenizer = load_model(model_name)
+
+    while True:
+        query = input("Ask a question: ")
+        if query.lower() == "exit":
+            print("Exiting...")
+            break
+
+        retrieved_chunks = retrieve_relevant_chunks(query,embedder, k, faiss_index, chunks_path)
+        answer = generate_answer(query, retrieved_chunks, model, tokenizer)
+
+        print("\n🔹 Question:\n", query, "\n")
+        print("\n💡 Answer:\n", answer, "\n")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run the interactive RAG agent with index creation from PDFs.")
+    parser.add_argument("--pdf_folder", type=str, default="./data", help="Path to the folder containing PDF files.")
+    parser.add_argument("--chunk_size", type=int, default=DEFAULT_CHUNK_SIZE, help="Text chunk size.")
+    parser.add_argument("--overlap", type=int, default=DEFAULT_OVERLAP, help="Overlap size between chunks.")
+    parser.add_argument("--index_type", type=str, choices=["flatl2", "innerproduct", "hnsw", "ivfflat", "ivfpq", "ivfsq"],
+                        default=DEFAULT_INDEX_TYPE, help="Type of FAISS index to use.")
+    parser.add_argument("--model_name", type=str, default=DEFAULT_MODEL, help="Hugging Face model name.")
+    parser.add_argument("--top_k", type=int, default=DEFAULT_TOP_K, help="Number of retrieved text chunks to use.")
+
+    args = parser.parse_args()
+    rag_agent(args.pdf_folder, args.chunk_size, args.overlap, args.index_type, args.model_name, args.top_k)

requirements.txt

@@ -0,0 +1,9 @@
+huggingface_hub==0.25.2
+gradio
+pdfplumber
+numpy
+faiss-cpu
+langchain
+torch
+sentence-transformers
+transformers

utils/generation.py

@@ -0,0 +1,112 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+MODEL_NAME = "facebook/opt-1.3b"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME, torch_dtype=torch.float16, device_map="auto"
+)
+
+def generate_answer_chat(query, options, retrieved_chunks, model=model, tokenizer=tokenizer):
+    """
+    Generates an answer using the retrieved context, formatted as a conversation
+    to better suit Llama 2 7B Chat's conversational tuning.
+    """
+    # Format each retrieved chunk as a numbered paragraph.
+    paragraphs = [f"Paragraph {idx+1}: {chunk}" for idx, chunk in enumerate(retrieved_chunks)]
+    context = "\n\n".join(paragraphs)
+    
+    # Create a conversational prompt.
+    system_message = (
+        "System: You are a telecom regulations expert. Answer using the information provided in the context. Start directly by Giving the best choice from options"
+    )
+    context_message = f"Context:\n{context}"
+    user_message = f"User: {query}\nOptions: " + " | ".join(options)
+    assistant_cue = "Assistant: "
+    
+    prompt = "\n\n".join([system_message, context_message, user_message, assistant_cue])
+    
+    # Determine the model type: seq2seq or causal.
+    model_type = "seq2seq" if getattr(model.config, "is_encoder_decoder", False) else "causal"
+    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+    
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=128,
+        num_return_sequences=1,
+        no_repeat_ngram_size=2
+    )
+    
+    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    
+    if model_type == "causal":
+        # Attempt to extract only the assistant's response.
+        answer_start = generated_text.find("Assistant:")
+        if answer_start != -1:
+            answer = generated_text[answer_start + len("Assistant:"):].strip()
+        else:
+            answer = generated_text[len(prompt):].strip()
+        return answer
+    else:
+        return generated_text.strip()
+
+
+def generate_answer(query, retrieved_chunks, model=model, tokenizer=tokenizer):
+    """
+    Generates an answer using the retrieved context.
+
+    For causal models, the prompt is included in the output so it must be removed.
+    For seq2seq models, the output is directly the generated answer.
+    """
+    # Format each chunk as a separate paragraph with a numbered prefix.
+    paragraphs = [f"Paragraph {idx+1}: {chunk}" for idx, chunk in enumerate(retrieved_chunks)]
+    context = "\n\n".join(paragraphs)
+    
+    prompt = (f"You are a telecom regulations expert. Using the following context, answer the question:\n\n"
+              f"Context:\n{context}\n\n"
+              f"Question: {query}\nAnswer:")
+              
+    model_type = "seq2seq" if getattr(model.config, "is_encoder_decoder", False) else "causal"
+    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=128,  # Specifies the number of tokens to generate.
+        num_return_sequences=1,
+        no_repeat_ngram_size=2
+    )
+    
+    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    
+    # For causal models, remove the prompt from the output.
+    if model_type == "causal":
+        # Remove the prompt from the output for causal models
+        return generated_text[len(prompt):].strip()
+    else:
+        return generated_text.strip()
+
+
+def generate_norag(query, model, tokenizer):
+    """
+    Generates an answer without additional context.
+    """
+    prompt = f"Answer the question:\n\nQuestion: {query}\nAnswer:"
+    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+    
+    # Generate output with a specified maximum number of new tokens.
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=128,  # Specifies the number of tokens to generate.
+        num_return_sequences=1,
+        no_repeat_ngram_size=2
+    )
+    
+    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True) 
+    model_type = "seq2seq" if getattr(model.config, "is_encoder_decoder", False) else "causal"   
+    
+    if model_type == "causal":
+        return generated_text[len(prompt):].strip()
+    else:  # For seq2seq models
+        return generated_text.strip()
+
+

utils/retrieval.py

@@ -0,0 +1,14 @@
+import faiss
+import numpy as np
+from sentence_transformers import SentenceTransformer
+
+
+
+def retrieve_relevant_chunks(query,embedder, k=5, index_path="faiss_index.idx", chunks_path="text_chunks.npy"):
+    index = faiss.read_index(index_path)
+    chunks = np.load(chunks_path, allow_pickle=True)
+    query_embedding = embedder.encode([query], convert_to_numpy=True)
+    distances, indices = index.search(query_embedding, k)
+
+    retrieved_chunks = [chunks[i] for i in indices[0]]
+    return retrieved_chunks