Gemini Pro'yu kullanarak Multi-Modal RAG ile Soru-Cevap uygulaması geliştirme

1. Giriş

RAG nedir?

Alma için Artırılmış Oluşturma (RAG), büyük dil modellerinin (LLM) gücüyle harici bilgi kaynaklarından alakalı bilgileri alma kabiliyetini birleştiren bir tekniktir. Bu, LLM'nin yalnızca kendi dahili eğitim verilerine dayandığı değil, yanıt üretirken güncel, özel bilgilere de erişip bunları birleştirebileceği anlamına gelir.

RAG birkaç nedenden dolayı popülerlik kazanıyor:

• Daha yüksek doğruluk ve alaka düzeyi: RAG, LLM'lerin harici kaynaklardan alınan gerçek bilgileri temel alarak daha doğru ve alakalı yanıtlar sağlamasına olanak tanır. Bu, özellikle güncel olaylarla ilgili soruları yanıtlamak veya belirli konularda bilgi sağlamak gibi güncel bilgilerin büyük önem taşıdığı senaryolarda faydalıdır.
• Daha az halüsinasyon: LLM'ler bazen makul görünen ancak aslında yanlış veya anlamsız yanıtlar üretebilir. RAG, harici kaynaklardan elde edilen bilgileri doğrulayarak bu sorunun azaltılmasına yardımcı olur.
• Daha fazla uyarlanabilirlik: RAG, LLM'leri farklı alanlara ve görevlere daha uygun hale getirir. LLM, farklı bilgi kaynaklarından yararlanarak çok çeşitli konularda bilgi sağlayacak şekilde kolayca özelleştirilebilir.
• Gelişmiş kullanıcı deneyimi: RAG, daha bilgilendirici, güvenilir ve alakalı yanıtlar sağlayarak genel kullanıcı deneyimini iyileştirebilir.

Neden Multi-Modal?

Günümüzün zengin veri dünyasında, belgeler bilgileri kapsamlı bir şekilde aktarmak için genellikle metin ve resimleri birleştirir. Ancak çoğu Veri Alma Artırılmış Nesil (RAG) sistemi, resimlere gizlenmiş değerli analizleri göz ardı eder. Çok modlu Büyük Dil Modelleri (LLM) belirgin hale geldikçe, RAG'de metinlerin yanı sıra görsel içerikten nasıl yararlanabileceğimizi keşfetmek, böylece bilgi ortamının daha derin bir şekilde anlaşılmasını sağlamak hayati önem taşıyor.

Çok modlu RAG için iki seçenek

• Çok modlu yerleştirmeler: Çok modlu yerleştirme modeli, sağladığınız girişe bağlı olarak 1408 boyutlu vektörler* oluşturur. Bu vektörler resim, metin ve video verilerinin bir kombinasyonunu içerebilir. Resim yerleştirme vektörü ve metin yerleştirme vektörü, aynı boyuta sahip aynı anlamsal alanda bulunuyor. Sonuç olarak bu vektörler, metne göre görsel arama veya görselle video arama gibi kullanım alanlarında birbirlerinin yerine kullanılabilir. Bu demoya göz atın.

1. Metin ve resim yerleştirmek için çok modlu yerleştirmeyi kullanma
2. Benzerlik aramasını kullanarak her ikisini de alma
3. Yanıt sentezi için hem alınan ham görüntüyü hem de metin parçalarını çok modlu LLM'ye iletme

• Metin Yerleştirme -

1. Görsellerin metin özetlerini oluşturmak için çok modlu LLM (büyük dil modeli) kullanın
2. Yerleştirilmiş ve metin alınmış
3. Yanıt sentezi için metin yığınlarını LLM'ye iletme

Çok Vektörlü Retriever nedir?

Çok vektörlü alma, yanıt sentezi için orijinal içeriği almak üzere doküman bölümlerinin özetlerini kullanır. Özellikle tablo, grafik, tablo vb. yoğun görevlerde RAG’nin kalitesini artırır. Daha fazla bilgiyi Langchain'in blogunda bulabilirsiniz.

Oluşturacaklarınız

Kullanım alanı: Gemini Pro ile soru-cevap sistemi geliştirme

Bilgi dolu karmaşık grafikler veya diyagramlar içeren dokümanlarınız olduğunu düşünün. Soruları veya soruları yanıtlamak için bu verileri ayıklamak istiyorsunuz.

Bu codelab'de şunları gerçekleştireceksiniz:

• LangChain document_loaders kullanarak veri yükleme
• Google'ın gemini-pro modelini kullanarak metin özetleri oluşturun
• Google'ın gemini-pro-vision modelini kullanarak resim özetleri oluşturun
• Vektör deposu olarak Croma Db ile Google'ın textembedding-gecko modelini kullanarak çok vektörlü alma işlemi oluşturun
• Soru cevaplama için çok modlu RAG zinciri geliştirme

2. Başlamadan önce

1. Google Cloud Console'daki proje seçici sayfasında bir Google Cloud projesi seçin veya oluşturun.
2. Google Cloud projeniz için faturalandırmanın etkinleştirildiğinden emin olun. Bir projede faturalandırmanın etkin olup olmadığını nasıl kontrol edeceğinizi öğrenin.
3. Vertex AI kontrol panelinden önerilen tüm API'leri etkinleştirin.
4. Colab Not Defteri'ni açın ve mevcut etkin Google Cloud hesabınızla aynı hesaba giriş yapın.

3. Çok Modlu RAG Oluşturma

Bu codelab'de, burada açıklanan "2. Seçeneği" Google Cloud ile nasıl uygulayacağınızı göstermek için Python için Vertex AI SDK ve Langchain kullanılır.

Referans verilen depodaki Multi-modal RAG with Google Cloud (Google Cloud ile çok modlu RAG) dosyasındaki kodun tamamına göz atabilirsiniz.

4. 1. Adım: Bağımlılıkları yükleyin ve içe aktarın

!pip install -U --quiet langchain langchain_community chromadb  langchain-google-vertexai
!pip install --quiet "unstructured[all-docs]" pypdf pillow pydantic lxml pillow matplotlib chromadb tiktoken

Proje kimliğinizi girin ve kimlik doğrulama işlemini tamamlayın

#TODO : ENter project and location
PROJECT_ID = ""
REGION = "us-central1"

from google.colab import auth
auth.authenticate_user()

Vertex AI platformunu başlatma

import vertexai
vertexai.init(project = PROJECT_ID , location = REGION)

5. 2. Adım: Verileri hazırlayın ve yükleyin

Bu blog yayınından çıkarılan resimlerin ve PDF'nin alt kümesini içeren bir zip dosyası kullanırız. Akışın tamamını takip etmek isterseniz lütfen orijinal örneği kullanın.

Önce verileri indirin

import logging
import zipfile
import requests

logging.basicConfig(level=logging.INFO)

data_url = "https://storage.googleapis.com/benchmarks-artifacts/langchain-docs-benchmarking/cj.zip"
result = requests.get(data_url)
filename = "cj.zip"
with open(filename, "wb") as file:
   file.write(result.content)

with zipfile.ZipFile(filename, "r") as zip_ref:
   zip_ref.extractall()

Dokümandan metin içeriğini yükleyin

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("./cj/cj.pdf")
docs = loader.load()
tables = []
texts = [d.page_content for d in docs]

İlk sayfadaki içeriği kontrol edin

texts[0]

Çıkışı göreceksiniz

Dokümandaki toplam sayfa sayısı

len(texts)

Beklenen çıkış:

6. 3. Adım: Metin özetleri oluşturun

Önce gerekli kitaplıkları içe aktarın

from langchain_google_vertexai import VertexAI , ChatVertexAI , VertexAIEmbeddings
from langchain.prompts import PromptTemplate
from langchain_core.messages import AIMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableLambda

Metin Özetleri Alma

# Generate summaries of text elements
def generate_text_summaries(texts, tables, summarize_texts=False):
   """
   Summarize text elements
   texts: List of str
   tables: List of str
   summarize_texts: Bool to summarize texts
   """

   # Prompt
   prompt_text = """You are an assistant tasked with summarizing tables and text for retrieval. \
   These summaries will be embedded and used to retrieve the raw text or table elements. \
   Give a concise summary of the table or text that is well optimized for retrieval. Table or text: {element} """
   prompt = PromptTemplate.from_template(prompt_text)
   empty_response = RunnableLambda(
       lambda x: AIMessage(content="Error processing document")
   )
   # Text summary chain
   model = VertexAI(
       temperature=0, model_name="gemini-pro", max_output_tokens=1024
   ).with_fallbacks([empty_response])
   summarize_chain = {"element": lambda x: x} | prompt | model | StrOutputParser()

   # Initialize empty summaries
   text_summaries = []
   table_summaries = []

   # Apply to text if texts are provided and summarization is requested
   if texts and summarize_texts:
       text_summaries = summarize_chain.batch(texts, {"max_concurrency": 1})
   elif texts:
       text_summaries = texts

   # Apply to tables if tables are provided
   if tables:
       table_summaries = summarize_chain.batch(tables, {"max_concurrency": 1})

   return text_summaries, table_summaries


# Get text summaries
text_summaries, table_summaries = generate_text_summaries(
   texts, tables, summarize_texts=True
)

text_summaries[0]

Beklenen çıkış:

7. 4. Adım: Resim özetleri oluşturun

Önce gerekli kitaplıkları içe aktarın

import base64
import os

from langchain_core.messages import HumanMessage

Resim Özetleri Oluştur

def encode_image(image_path):
   """Getting the base64 string"""
   with open(image_path, "rb") as image_file:
       return base64.b64encode(image_file.read()).decode("utf-8")


def image_summarize(img_base64, prompt):
   """Make image summary"""
   model = ChatVertexAI(model_name="gemini-pro-vision", max_output_tokens=1024)

   msg = model(
       [
           HumanMessage(
               content=[
                   {"type": "text", "text": prompt},
                   {
                       "type": "image_url",
                       "image_url": {"url": f"data:image/jpeg;base64,{img_base64}"},
                   },
               ]
           )
       ]
   )
   return msg.content


def generate_img_summaries(path):
   """
   Generate summaries and base64 encoded strings for images
   path: Path to list of .jpg files extracted by Unstructured
   """

   # Store base64 encoded images
   img_base64_list = []

   # Store image summaries
   image_summaries = []

   # Prompt
   prompt = """You are an assistant tasked with summarizing images for retrieval. \
   These summaries will be embedded and used to retrieve the raw image. \
   Give a concise summary of the image that is well optimized for retrieval."""

   # Apply to images
   for img_file in sorted(os.listdir(path)):
       if img_file.endswith(".jpg"):
           img_path = os.path.join(path, img_file)
           base64_image = encode_image(img_path)
           img_base64_list.append(base64_image)
           image_summaries.append(image_summarize(base64_image, prompt))

   return img_base64_list, image_summaries


# Image summaries
img_base64_list, image_summaries = generate_img_summaries("./cj")

len(img_base64_list)

len(image_summaries)

image_summaries[0]

Şuna benzer bir çıkış göreceksiniz:

8. 5. Adım: Çoklu Vektör Alma İşlemi Oluşturma

Metin ve resim özetleri oluşturup bunları bir ChromaDB vektör deposuna kaydedelim.

İçe aktarma için kitaplıklar gerekir

import uuid
from langchain.retrievers.multi_vector import MultiVectorRetriever
from langchain.storage import InMemoryStore
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document

Çok Vektörlü Alma İşlemi Oluşturma

def create_multi_vector_retriever(
   vectorstore, text_summaries, texts, table_summaries, tables, image_summaries, images
):
   """
   Create retriever that indexes summaries, but returns raw images or texts
   """

   # Initialize the storage layer
   store = InMemoryStore()
   id_key = "doc_id"

   # Create the multi-vector retriever
   retriever = MultiVectorRetriever(
       vectorstore=vectorstore,
       docstore=store,
       id_key=id_key,
   )

   # Helper function to add documents to the vectorstore and docstore
   def add_documents(retriever, doc_summaries, doc_contents):
       doc_ids = [str(uuid.uuid4()) for _ in doc_contents]
       summary_docs = [
           Document(page_content=s, metadata={id_key: doc_ids[i]})
           for i, s in enumerate(doc_summaries)
       ]
       retriever.vectorstore.add_documents(summary_docs)
       retriever.docstore.mset(list(zip(doc_ids, doc_contents)))

   # Add texts, tables, and images
   # Check that text_summaries is not empty before adding
   if text_summaries:
       add_documents(retriever, text_summaries, texts)
   # Check that table_summaries is not empty before adding
   if table_summaries:
       add_documents(retriever, table_summaries, tables)
   # Check that image_summaries is not empty before adding
   if image_summaries:
       add_documents(retriever, image_summaries, images)

   return retriever


# The vectorstore to use to index the summaries
vectorstore = Chroma(
   collection_name="mm_rag_cj_blog",
   embedding_function=VertexAIEmbeddings(model_name="textembedding-gecko@latest"),
)

# Create retriever
retriever_multi_vector_img = create_multi_vector_retriever(
   vectorstore,
   text_summaries,
   texts,
   table_summaries,
   tables,
   image_summaries,
   img_base64_list,
)
 

9. 6. Adım: Çok Modlu RAG oluşturma

1. Yardımcı program fonksiyonlarını tanımlama

import io
import re

from IPython.display import HTML, display
from langchain_core.runnables import RunnableLambda, RunnablePassthrough
from PIL import Image


def plt_img_base64(img_base64):
   """Disply base64 encoded string as image"""
   # Create an HTML img tag with the base64 string as the source
   image_html = f'<img src="data:image/jpeg;base64,{img_base64}" />'
   # Display the image by rendering the HTML
   display(HTML(image_html))


def looks_like_base64(sb):
   """Check if the string looks like base64"""
   return re.match("^[A-Za-z0-9+/]+[=]{0,2}$", sb) is not None


def is_image_data(b64data):
   """
   Check if the base64 data is an image by looking at the start of the data
   """
   image_signatures = {
       b"\xFF\xD8\xFF": "jpg",
       b"\x89\x50\x4E\x47\x0D\x0A\x1A\x0A": "png",
       b"\x47\x49\x46\x38": "gif",
       b"\x52\x49\x46\x46": "webp",
   }
   try:
       header = base64.b64decode(b64data)[:8]  # Decode and get the first 8 bytes
       for sig, format in image_signatures.items():
           if header.startswith(sig):
               return True
       return False
   except Exception:
       return False


def resize_base64_image(base64_string, size=(128, 128)):
   """
   Resize an image encoded as a Base64 string
   """
   # Decode the Base64 string
   img_data = base64.b64decode(base64_string)
   img = Image.open(io.BytesIO(img_data))

   # Resize the image
   resized_img = img.resize(size, Image.LANCZOS)

   # Save the resized image to a bytes buffer
   buffered = io.BytesIO()
   resized_img.save(buffered, format=img.format)

   # Encode the resized image to Base64
   return base64.b64encode(buffered.getvalue()).decode("utf-8")


def split_image_text_types(docs):
   """
   Split base64-encoded images and texts
   """
   b64_images = []
   texts = []
   for doc in docs:
       # Check if the document is of type Document and extract page_content if so
       if isinstance(doc, Document):
           doc = doc.page_content
       if looks_like_base64(doc) and is_image_data(doc):
           doc = resize_base64_image(doc, size=(1300, 600))
           b64_images.append(doc)
       else:
           texts.append(doc)
   if len(b64_images) > 0:
       return {"images": b64_images[:1], "texts": []}
   return {"images": b64_images, "texts": texts}

2. Alana özgü resim istemini tanımla

def img_prompt_func(data_dict):
   """
   Join the context into a single string
   """
   formatted_texts = "\n".join(data_dict["context"]["texts"])
   messages = []

   # Adding the text for analysis
   text_message = {
       "type": "text",
       "text": (
           "You are financial analyst tasking with providing investment advice.\n"
           "You will be given a mixed of text, tables, and image(s) usually of charts or graphs.\n"
           "Use this information to provide investment advice related to the user question. \n"
           f"User-provided question: {data_dict['question']}\n\n"
           "Text and / or tables:\n"
           f"{formatted_texts}"
       ),
   }
   messages.append(text_message)
   # Adding image(s) to the messages if present
   if data_dict["context"]["images"]:
       for image in data_dict["context"]["images"]:
           image_message = {
               "type": "image_url",
               "image_url": {"url": f"data:image/jpeg;base64,{image}"},
           }
           messages.append(image_message)
   return [HumanMessage(content=messages)]

3. Çok Modlu RAG Zincirini Tanımlayın

def multi_modal_rag_chain(retriever):
   """
   Multi-modal RAG chain
   """

   # Multi-modal LLM
   model = ChatVertexAI(
       temperature=0, model_name="gemini-pro-vision", max_output_tokens=1024
   )

   # RAG pipeline
   chain = (
       {
           "context": retriever | RunnableLambda(split_image_text_types),
           "question": RunnablePassthrough(),
       }
       | RunnableLambda(img_prompt_func)
       | model
       | StrOutputParser()
   )

   return chain


# Create RAG chain
chain_multimodal_rag = multi_modal_rag_chain(retriever_multi_vector_img)

10. 7. Adım: Sorgularınızı test edin

1. İlgili belgeleri alın

query = "What are the EV / NTM and NTM rev growth for MongoDB, Cloudflare, and Datadog?"
docs = retriever_multi_vector_img.get_relevant_documents(query, limit=1)

# We get relevant docs
len(docs)

docs

         You may get similar output 

plt_img_base64(docs[3])

2. RAG'imizi aynı sorgu üzerinde çalıştırın

result = chain_multimodal_rag.invoke(query)

from IPython.display import Markdown as md
md(result)

Örnek Çıkış (kodu yürütürken değişiklik gösterebilir)

11. Temizleme

Bu codelab'de kullanılan kaynaklar için Google Cloud hesabınızın ücretlendirilmesini istemiyorsanız aşağıdaki adımları uygulayın:

1. Google Cloud konsolunda Kaynakları yönetin sayfasına gidin.
2. Proje listesinden silmek istediğiniz projeyi seçin ve ardından Sil'i tıklayın.
3. İletişim kutusuna proje kimliğini yazın ve projeyi silmek için Kapat'ı tıklayın.

12. Tebrikler

Tebrikler! Gemini'ı kullanarak başarıyla Çok Modlu RAG geliştirdiniz.