Membuat Aplikasi Tanya Jawab dengan RAG Multi-Modal menggunakan Gemini Pro

1. Pengantar

Apa yang dimaksud dengan RAG

Retrieval Augmented Generation (RAG) adalah teknik yang menggabungkan kekuatan model bahasa besar (LLM) dengan kemampuan untuk mengambil informasi yang relevan dari sumber pengetahuan eksternal. Artinya, LLM tidak hanya mengandalkan data pelatihan internalnya, tetapi juga dapat mengakses dan menggabungkan informasi spesifik terbaru saat membuat respons.

RAG semakin populer karena beberapa alasan:

• Peningkatan akurasi dan relevansi: RAG memungkinkan LLM memberikan respons yang lebih akurat dan relevan dengan mendasarkannya pada informasi faktual yang diambil dari sumber eksternal. Hal ini sangat berguna dalam skenario yang memerlukan pengetahuan terbaru, seperti menjawab pertanyaan tentang peristiwa terkini atau memberikan informasi tentang topik tertentu.
• Mengurangi halusinasi: LLM terkadang dapat menghasilkan respons yang tampak masuk akal, tetapi sebenarnya salah atau tidak masuk akal. RAG membantu memitigasi masalah ini dengan memverifikasi informasi yang dihasilkan terhadap sumber eksternal.
• Kemampuan adaptasi yang lebih besar: RAG membuat LLM lebih mudah beradaptasi dengan berbagai domain dan tugas. Dengan memanfaatkan berbagai sumber pengetahuan, LLM dapat disesuaikan dengan mudah untuk memberikan informasi tentang berbagai topik.
• Pengalaman pengguna yang ditingkatkan: RAG dapat meningkatkan pengalaman pengguna secara keseluruhan dengan memberikan respons yang lebih informatif, andal, dan relevan.

Mengapa Multi-Mode

Di dunia yang kaya data saat ini, dokumen sering kali menggabungkan teks dan gambar untuk menyampaikan informasi secara komprehensif. Namun, sebagian besar sistem Retrieval Augmented Generation (RAG) mengabaikan insight berharga yang terkunci dalam gambar. Seiring dengan semakin populernya Model Bahasa Besar (LLM) multimodal, penting untuk mempelajari cara memanfaatkan konten visual bersama teks di RAG, sehingga dapat membuka pemahaman yang lebih mendalam tentang lanskap informasi.

Dua opsi untuk RAG Multimodal

• Embedding Multimodal - Model embedding multimodal menghasilkan vektor dimensi 1408* berdasarkan input yang Anda berikan, yang dapat mencakup kombinasi data gambar, teks, dan video. Vektor embedding gambar dan vektor embedding teks berada dalam ruang semantik yang sama dengan dimensi yang sama. Oleh karena itu, vektor ini dapat digunakan secara bergantian untuk kasus penggunaan seperti menelusuri gambar berdasarkan teks, atau menelusuri video berdasarkan gambar. Lihat Demo ini.

1. Menggunakan embedding multi-mode untuk menyematkan teks dan gambar
2. Mengambil keduanya menggunakan penelusuran kemiripan
3. Teruskan gambar mentah dan potongan teks yang diambil ke LLM multimodal untuk sintesis jawaban

• Embedding Teks -

1. Menggunakan LLM multi-modal untuk membuat ringkasan teks gambar
2. Menyematkan dan mengambil teks
3. Meneruskan potongan teks ke LLM untuk sintesis jawaban

Apa yang dimaksud dengan Multi-Vector Retriever

Pengambilan multi-vektor menggunakan ringkasan bagian dokumen untuk mengambil konten asli guna sintesis jawaban. Hal ini meningkatkan kualitas RAG terutama untuk tugas intensif tabel, grafik, diagram, dll. Temukan detail selengkapnya di blog Langchain.

Yang akan Anda bangun

Kasus penggunaan: Mengembangkan sistem menjawab pertanyaan menggunakan Gemini Pro

Bayangkan Anda memiliki dokumen yang berisi grafik atau diagram kompleks yang penuh dengan informasi. Anda ingin mengekstrak data ini untuk menjawab pertanyaan atau kueri.

Dalam codelab ini, Anda akan melakukan hal berikut:

• Pemuatan data menggunakan LangChain document_loaders
• Membuat ringkasan teks menggunakan model gemini-pro Google
• Membuat ringkasan gambar menggunakan model gemini-pro-vision Google
• Membuat pengambilan multi-vektor menggunakan model textembedding-gecko Google dengan Croma Db sebagai penyimpanan vektor
• Mengembangkan rantai RAG Multimodal untuk menjawab pertanyaan

2. Sebelum memulai

1. Di Konsol Google Cloud, di halaman pemilih project, pilih atau buat project Google Cloud.
2. Pastikan penagihan diaktifkan untuk project Google Cloud Anda. Pelajari cara memeriksa apakah penagihan telah diaktifkan pada suatu project.
3. Mengaktifkan semua API yang direkomendasikan dari dasbor Vertex AI
4. Buka Notebook Colab dan login ke akun yang sama dengan akun Google Cloud aktif Anda saat ini.

3. Membuat RAG Multi-Modal

Codelab ini menggunakan Vertex AI SDK untuk Python dan Langchain untuk menunjukkan cara menerapkan 'Opsi 2' yang dijelaskan di sini dengan Google Cloud.

Anda dapat melihat kode lengkapnya dalam file Multi-modal RAG with Google Cloud dari repositori yang dirujuk.

4. Langkah 1: Instal dan Impor dependensi

!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

Masukkan project ID Anda dan selesaikan autentikasi

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

from google.colab import auth
auth.authenticate_user()

Melakukan inisialisasi platform Vertex AI

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

5. Langkah 2: Siapkan dan muat data

Kita menggunakan file zip dengan subkumpulan gambar dan pdf yang diekstrak dari postingan blog ini. Jika Anda ingin mengikuti alur lengkap, gunakan contoh asli.

Download data terlebih dahulu

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()

Memuat konten teks dari dokumen

from langchain_community.document_loaders import PyPDFLoader

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

Periksa konten dari halaman pertama

texts[0]

Anda akan melihat output

Total halaman dalam dokumen

len(texts)

Output yang diharapkan adalah

6. Langkah 3: Buat Ringkasan Teks

Mengimpor library yang diperlukan terlebih dahulu

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

Mendapatkan Ringkasan Teks

# 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]

Output yang diharapkan adalah

7. Langkah 4: Buat Ringkasan Gambar

Mengimpor library yang diperlukan terlebih dahulu

import base64
import os

from langchain_core.messages import HumanMessage

Membuat Ringkasan Gambar

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]

Anda akan melihat output seperti ini

8. Langkah 5: Buat Pengambilan Multi-Vektor

Mari kita buat ringkasan teks dan gambar, lalu simpan ke vectorstore ChromaDB.

Mengimpor library yang diperlukan

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

Membuat Pengambilan Multi-Vektor

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. Langkah 6: Membuat RAG Multi-Modal

1. Menentukan fungsi utilitas

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. Menentukan perintah gambar khusus domain

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. Menentukan Rantai RAG Multi-Modal

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. Langkah 7: Uji kueri Anda

1. Mengambil dokumen yang relevan

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. Menjalankan RAG pada kueri yang sama

result = chain_multimodal_rag.invoke(query)

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

Contoh Output (mungkin berbeda saat Anda mengeksekusi kode)

11. Pembersihan

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam codelab ini, ikuti langkah-langkah berikut:

1. Di konsol Google Cloud, buka halaman Manage resources.
2. Dalam daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
3. Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

12. Selamat

Selamat! Anda telah berhasil mengembangkan RAG Multi-Modal menggunakan Gemini.