Coding implementation for constructing dialog analysis assistants with FAISS, LANGCHAIN, PYPDF, and TINYLLAMA-1.1B-CHAT-V1.0

!pip set up langchain-community langchain pypdf sentence-transformers faiss-cpu transformers speed up einops

import os
import torch
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain.chains import ConversationalRetrievalChain
from langchain_community.llms import HuggingFacePipeline
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
import pandas as pd 
from IPython.show import show, Markdown

from google.colab import drive
drive.mount('/content material/drive')
print("Google Drive mounted")

def load_documents(pdf_folder_path):
    paperwork = []


    if not pdf_folder_path:
        print("Downloading a pattern paper...")
        !wget -q https://arxiv.org/pdf/1706.03762.pdf -O consideration.pdf
        pdf_docs = ["attention.pdf"]
    else:
        pdf_docs = [os.path.join(pdf_folder_path, f) for f in os.listdir(pdf_folder_path)
                   if f.endswith('.pdf')]


    print(f"Discovered {len(pdf_docs)} PDF paperwork")


    for pdf_path in pdf_docs:
        strive:
            loader = PyPDFLoader(pdf_path)
            paperwork.lengthen(loader.load())
            print(f"Loaded: {pdf_path}")
        besides Exception as e:
            print(f"Error loading {pdf_path}: {e}")


    return paperwork




paperwork = load_documents("")

def split_documents(paperwork):
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len,
    )
    chunks = text_splitter.split_documents(paperwork)
    print(f"Break up {len(paperwork)} paperwork into {len(chunks)} chunks")
    return chunks


chunks = split_documents(paperwork)

def create_vector_store(chunks):
    print("Loading embedding mannequin...")
    embedding_model = HuggingFaceEmbeddings(
        model_name="sentence-transformers/all-MiniLM-L6-v2",
        model_kwargs={'system': 'cuda' if torch.cuda.is_available() else 'cpu'}
    )


    print("Creating vector retailer...")
    vector_store = FAISS.from_documents(chunks, embedding_model)
    print("Vector retailer created efficiently!")
    return vector_store


vector_store = create_vector_store(chunks)

def load_language_model():
    print("Loading language mannequin...")
    model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"


    strive:
        import subprocess
        print("Putting in/updating bitsandbytes...")
        subprocess.check_call(["pip", "install", "-U", "bitsandbytes"])
        print("Efficiently put in/up to date bitsandbytes")
    besides:
        print("Couldn't replace bitsandbytes, will proceed with out 8-bit quantization")


    from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, pipeline
    import torch


    tokenizer = AutoTokenizer.from_pretrained(model_id)


    if torch.cuda.is_available():
        strive:
            quantization_config = BitsAndBytesConfig(
                load_in_8bit=True,
                llm_int8_threshold=6.0,
                llm_int8_has_fp16_weight=False
            )


            mannequin = AutoModelForCausalLM.from_pretrained(
                model_id,
                torch_dtype=torch.bfloat16,
                device_map="auto",
                quantization_config=quantization_config
            )
            print("Mannequin loaded with 8-bit quantization")
        besides Exception as e:
            print(f"Error with quantization: {e}")
            print("Falling again to plain mannequin loading with out quantization")
            mannequin = AutoModelForCausalLM.from_pretrained(
                model_id,
                torch_dtype=torch.bfloat16,
                device_map="auto"
            )
    else:
        mannequin = AutoModelForCausalLM.from_pretrained(
            model_id,
            torch_dtype=torch.float32,
            device_map="auto"
        )


    pipe = pipeline(
        "text-generation",
        mannequin=mannequin,
        tokenizer=tokenizer,
        max_length=2048,
        temperature=0.2,
        top_p=0.95,
        repetition_penalty=1.2,
        return_full_text=False
    )


    from langchain_community.llms import HuggingFacePipeline
    llm = HuggingFacePipeline(pipeline=pipe)
    print("Language mannequin loaded efficiently!")
    return llm


llm = load_language_model()

def format_research_assistant_output(question, response, sources):
    output = f"n{'=' * 50}n"
    output += f"USER QUERY: {question}n"
    output += f"{'-' * 50}nn"
    output += f"ASSISTANT RESPONSE:n{response}nn"
    output += f"{'-' * 50}n"
    output += f"SOURCES REFERENCED:nn"


    for i, doc in enumerate(sources):
        output += f"Supply #{i+1}:n"
        content_preview = doc.page_content[:200] + "..." if len(doc.page_content) > 200 else doc.page_content
        wrapped_content = textwrap.fill(content_preview, width=80)
        output += f"{wrapped_content}nn"


    output += f"{'=' * 50}n"
    return output


import textwrap


research_assistant = create_research_assistant(vector_store, llm)


test_queries = [
    "What is the key idea behind the Transformer model?",
    "Explain self-attention mechanism in simple terms.",
    "Who are the authors of the paper?",
    "What are the main advantages of using attention mechanisms?"
]


for question in test_queries:
    response, sources = research_assistant(question, return_sources=True)
    formatted_output = format_research_assistant_output(question, response, sources)
    print(formatted_output)