ColBERT and RAGatouille: Key Concepts Unveiled

Delve into the captivating realm of ColBERT intertwined with RAGatouille, where essential ideas unite to create a delightful blend of humor and interaction. ColBERT orchestrates a harmonious interplay of BERT sentence embeddings and neural networks to facilitate humor recognition in brief texts. Simultaneously, Langchain seamlessly integrates its computational linguistics expertise, applying linguistic theories to modern technology.

Benefits of the ColBERT and Langchain Integration

A Versatile Integration with RAGatouille

#### Fine-tuning Adaptability

ColBERT, paired with RAGatouille, can be fine-tuned for retrieval utilizing any encoder-only model. Thanks to the RAGatouille library, training and implementing state-of-the-art retrieval models like ColBERT is simplified, requiring just a few lines of code.

#### Beyond Basic Retrieval

While dense retrieval methods, such as OpenAI's text-ada-002 embeddings, provide a solid starting point, research suggests that these methods may not suit every application. In contrast, models like ColBERT exhibit greater adaptability.

#### Generalization Capabilities

ColBERT has shown superior generalization to new or intricate domains compared to dense embeddings. It is extremely data-efficient and excels in training on non-English languages with limited data.

#### RAGatouille as a Connector

The RAGatouille library acts as a conduit for the seamless integration of advanced techniques into your RAG pipeline, simplifying the process of leveraging models like ColBERT.

Step I: Install Required Libraries

pip install -U -qq --ignore-installed "transformers>=4.35.0" accelerate langchain faiss-cpu ragatouille "autoawq>=0.1.6" pypdf

# Step II: Import Libraries and Load Data

import torch

from langchain.embeddings.huggingface import HuggingFaceEmbeddings

from langchain_community.document_loaders import PyPDFLoader

from langchain.vectorstores import FAISS

from langchain.text_splitter import RecursiveCharacterTextSplitter

from ragatouille import RAGPretrainedModel

device = "cuda" if torch.cuda.is_available() else "cpu"

# Load Data

loader = PyPDFLoader("2005.11401.pdf")

r_docs = loader.load_and_split()

# Prepare embedding function

embedding = HuggingFaceEmbeddings(

model_name="intfloat/multilingual-e5-large",

model_kwargs={"device": device},

)

# Vector Store with FAISS

documents = loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=40)

docs = text_splitter.split_documents(documents)

vectorstore = FAISS.from_documents(docs, embedding)

# RAGatouille/ColBERT Implementation

RAG = RAGPretrainedModel.from_pretrained("colbert-ir/colbertv2.0")

# Contextual Compression Retriever from Langchain

from langchain.retrievers import ContextualCompressionRetriever

# Retrieve 10 similar documents from FAISS vector store

base_retriever = vectorstore.as_retriever(search_kwargs={"k": 10})

# Create retriever for similarity using ColBERT

compression_retriever = ContextualCompressionRetriever(

base_compressor=RAG.as_langchain_document_compressor(k=3),

base_retriever=base_retriever,

)

# Testing the retrieval

compressed_docs = compression_retriever.get_relevant_documents(

"What treatment does this contract give to intellectual property rights?"

)

compressed_docs

# Step IV: Initialize Transformers Using Open-Chat

from transformers import AutoModelForCausalLM, AutoTokenizer

from transformers_chat import ChatHuggingFaceModel

model_name_or_path = "TheBloke/openchat-3.5-0106-AWQ"

tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)

generator = AutoModelForCausalLM.from_pretrained(

model_name_or_path,

low_cpu_mem_usage=True,

device_map="cuda:0"

)

# Step V: Invoke LCEL

from transformers_chat import ChatHuggingFaceModel

from langchain_core.prompts import ChatPromptTemplate

from langchain_core.output_parsers import StrOutputParser

from langchain_core.prompts.chat import (

AIMessagePromptTemplate,

HumanMessagePromptTemplate,

)

from langchain_core.runnables import RunnablePassthrough, RunnableLambda

# Prompt template for Q&A using context

prompt_template = """Answer the question based only on the following context:

{context}

Question: {question}

"""

# Create a chat prompt

prompt = ChatPromptTemplate.from_messages(

[

HumanMessagePromptTemplate.from_template(prompt_template),

AIMessagePromptTemplate.from_template(""),

]

)

# Chat model configuration

chat_model = ChatHuggingFaceModel(

generator=generator,

tokenizer=tokenizer,

human_message_template="User: {}",

ai_message_template="Assistant: {}",

repetition_penalty=1.2,

temperature=0.1,

max_new_tokens=400,

)

# Chain 1: Regular RAG with simple retriever

simple_retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

chain1 = (

{"context": simple_retriever, "question": RunnablePassthrough()}

prompt

chat_model

StrOutputParser()

)

# Chain 2: RAG with ColBERT for reranking

rerank_retriever = ContextualCompressionRetriever(

base_retriever=vectorstore.as_retriever(search_kwargs={"k": 15}),

base_compressor=RAG.as_langchain_document_compressor(k=5),

)

chain2 = (

{"context": rerank_retriever, "question": RunnablePassthrough()}

prompt

chat_model

StrOutputParser()

)

Resources:

• ColBERT-Stanford
• Langchain-ColBERT-Notebook

Stay connected and support my work through various platforms:

• Github
• Patreon
• Kaggle
• Hugging-Face
• YouTube
• GumRoad

If you appreciate my content, consider buying me a coffee ☕! If you have questions or project ideas, feel free to reach out. Your support through likes and shares greatly motivates me to keep creating quality content. Thank you!

This video discusses the rise of voter registration among young people and features insights from Kamala Harris.

In this video, RuPaul engages with Stephen Colbert, answering fun and revealing questions about his life and career.