රූපයක් සහ පෙළ විස්තරයක් සමඟ යමක් සෙවීමට අවශ්‍යද? Multimodal RAG එකක් උත්සාහ කරන්න

මෙම ලිපිය Milvus භාවිතයෙන් බහුමාධ්‍ය RAG පද්ධතියක් ගොඩනගා ගන්නේ කෙසේද සහ AI පද්ධති සඳහා විවිධ හැකියාවන් විවෘත කරන්නේ කෙසේද යන්න පිළිබඳ ගැඹුරු මාර්ගෝපදේශයක් සපයයි.

තනි දත්ත ආකෘතියකට සීමා වීම තවදුරටත් ප්‍රමාණවත් නොවේ. තීරණාත්මක තීරණ ගැනීම සඳහා ව්‍යාපාර තොරතුරු මත දැඩි ලෙස රඳා පවතින බැවින්, ඒවාට වෙනස් ආකෘතිවලින් දත්ත සංසන්දනය කිරීමේ හැකියාව අවශ්‍ය වේ. වාසනාවකට මෙන්, තනි දත්ත වර්ගයකට සීමා වූ සාම්ප්‍රදායික AI පද්ධති සංකීර්ණ තොරතුරු අවබෝධ කර ගැනීමට සහ සැකසීමට හැකි බහුමාධ්‍ය පද්ධතිවලට මග පෑදී ඇත.

Multimodal search සහ multimodal retrieval-augmented Generation (RAG) පද්ධති මෑතකදී මෙම ක්ෂේත්‍රයේ විශාල දියුණුවක් පෙන්නුම් කර ඇත. සන්දර්භය-දැනුවත් ප්‍රතිචාර සැපයීම සඳහා මෙම පද්ධති පෙළ, රූප සහ ශ්‍රව්‍ය ඇතුළු බහුවිධ දත්ත සකසයි.

මෙම බ්ලොග් සටහනෙන්, අපි සංවර්ධකයින්ට මිල්වස් භාවිතයෙන් තමන්ගේම බහුමාධ්‍ය RAG පද්ධතියක් ගොඩනගා ගත හැකි ආකාරය සාකච්ඡා කරමු. විශේෂයෙන් පෙළ සහ රූප දත්ත හැසිරවිය හැකි, සමානතා සෙවීම් සිදු කළ හැකි, සහ ප්‍රතිදානය පිරිපහදු කිරීම සඳහා භාෂා ආකෘතියක් භාවිතා කළ හැකි එවැනි පද්ධතියක් ගොඩ නැගීම හරහා අපි ඔබව ගෙන යන්නෙමු. ඉතින්, අපි පටන් ගනිමු.

Milvus යනු කුමක්ද?

දෛශික දත්ත සමුදායක් යනු දෛශික කාවැද්දීම් ගබඩා කිරීම, සුචිගත කිරීම සහ ලබා ගැනීම සඳහා භාවිතා කරන විශේෂ දත්ත සමුදායක් වන අතර, දත්තවල ගණිතමය නිරූපණයන් වන අතර එය ඔබට සමානාත්මතාවයට පමණක් නොව අර්ථකථන සමානකම් සඳහා දත්ත සංසන්දනය කිරීමට ඉඩ සලසයි. මිල්වුස් පරිමාණය සඳහා ගොඩනගා ඇති විවෘත මූලාශ්‍ර, ඉහළ ක්‍රියාකාරී දෛශික දත්ත සමුදායකි. ඔබට එය Apache-2.0 බලපත්‍රයක් සහ තරු 30K වඩා වැඩි GitHub මත සොයා ගත හැක.

මහා පරිමාණ දෛශික දත්ත කළමනාකරණය කිරීම සහ විමසීම සඳහා නම්‍යශීලී විසඳුමක් සැපයීමට Milvus සංවර්ධකයින්ට උදවු කරයි. එහි කාර්යක්‍ෂමතාවය නිසා නැවත ලබාගැනීමේ වර්ධක උත්පාදනය (RAG), බහුමාධ්‍ය සෙවීම්, නිර්දේශ එන්ජිම සහ විෂමතා හඳුනාගැනීම් වැනි ගැඹුරු ඉගෙනුම් ආකෘති භාවිතා කරමින් යෙදුම් ගොඩනඟන්නන් සඳහා Milvus කදිම තේරීමක් කරයි.

Milvus සංවර්ධකයින්ගේ අවශ්‍යතාවලට ගැලපෙන බහුවිධ යෙදවුම් විකල්ප ඉදිරිපත් කරයි. මිල්වස් ලයිට් පයිතන් යෙදුමක් තුළ ධාවනය වන සැහැල්ලු අනුවාදයක් වන අතර දේශීය පරිසරයක් තුළ යෙදුම් මූලාකෘති කිරීම සඳහා පරිපූර්ණ වේ. Milvus Standalone සහ Milvus Distributed යනු පරිමාණය කළ හැකි සහ නිෂ්පාදනයට සූදානම් විකල්ප වේ.

Multimodal RAG: පාඨයෙන් ඔබ්බට පුළුල් කිරීම

පද්ධතිය ගොඩනැගීමට පෙර, සාම්ප්‍රදායික පෙළ-පාදක RAG සහ Multimodal RAG දක්වා එහි පරිණාමය තේරුම් ගැනීම වැදගත් වේ.

Retrieval Augmented Generation (RAG) යනු බාහිර මූලාශ්‍රවලින් සන්දර්භීය තොරතුරු ලබා ගැනීම සහ විශාල භාෂා ආකෘතිවලින් (LLMs) වඩාත් නිවැරදි ප්‍රතිදානය ජනනය කිරීමේ ක්‍රමයකි. සාම්ප්‍රදායික RAG යනු LLM ප්‍රතිදානය වැඩි දියුණු කිරීම සඳහා ඉතා ඵලදායී උපාය මාර්ගයකි, නමුත් එය පාඨමය දත්ත වලට සීමා වේ. බොහෝ සැබෑ ලෝකයේ යෙදුම්වල, දත්ත පෙළෙන් ඔබ්බට විහිදේ - රූප, ප්‍රස්ථාර සහ වෙනත් ක්‍රම ඇතුළත් කිරීම තීරණාත්මක සන්දර්භය සපයයි.

Multimodal RAG විවිධ දත්ත වර්ග භාවිතය සක්‍රීය කරමින්, LLM වලට වඩා හොඳ සන්දර්භයක් ලබා දීමෙන් ඉහත සීමාව ආමන්ත්‍රණය කරයි.

සරලව කිවහොත්, බහුමාධ්‍ය RAG පද්ධතියක, ප්‍රතිසාධන සංරචකය විවිධ දත්ත ක්‍රම හරහා අදාළ තොරතුරු සොයන අතර, උත්පාදන සංරචකය ලබා ගත් තොරතුරු මත පදනම්ව වඩාත් නිවැරදි ප්‍රතිඵල ජනනය කරයි.

දෛශික කාවැද්දීම සහ සමානතා සෙවීම අවබෝධ කර ගැනීම

දෛශික කාවැද්දීම සහ සමානතා සෙවීම බහුමාධ්‍ය RAG හි මූලික සංකල්ප දෙකකි. අපි දෙන්නම තේරුම් ගනිමු.

දෛශික කාවැද්දීම

සාකච්ඡා කළ පරිදි, දෛශික කාවැද්දීම යනු දත්තවල ගණිතමය/සංඛ්‍යාත්මක නිරූපණයන් වේ. පෙළ, රූප සහ ශ්‍රව්‍ය වැනි විවිධ දත්ත වර්ගවල අර්ථකථන අර්ථය තේරුම් ගැනීමට යන්ත්‍ර මෙම නිරූපණය භාවිත කරයි.

ස්වභාවික භාෂා සැකසුම් (NLP) භාවිතා කරන විට, ලේඛන කුට්ටි දෛශික බවට පරිවර්තනය වන අතර, දෛශික අවකාශයේ ආසන්න ස්ථාන වෙත අර්ථකථන වශයෙන් සමාන වචන සිතියම්ගත කරනු ලැබේ. රූප සඳහාද එසේම වේ, එහිදී කාවැද්දීම අර්ථකථන ලක්ෂණ නියෝජනය කරයි. වර්ණ, වයනය සහ වස්තු හැඩතල වැනි ප්‍රමිතික සංඛ්‍යාත්මක ආකෘතියකින් තේරුම් ගැනීමට මෙය අපට ඉඩ සලසයි.

දෛශික කාවැද්දීම භාවිතා කිරීමේ ප්‍රධාන අරමුණ වන්නේ විවිධ දත්ත කොටස් අතර සම්බන්ධතා සහ සමානකම් ආරක්ෂා කර ගැනීමයි.

සමානතා සෙවීම

දී ඇති දත්ත කට්ටලයක දත්ත සෙවීමට සහ ස්ථානගත කිරීමට සමානතා සෙවීම භාවිතා කරයි. දෛශික කාවැද්දීමේ සන්දර්භය තුළ, සමානතා සෙවීම විමසුම් දෛශිකයට ආසන්නතම දත්ත කට්ටලයේ දෛශික සොයා ගනී.

දෛශික අතර සමානකම් මැනීම සඳහා බහුලව භාවිතා වන ක්‍රම කිහිපයක් පහත දැක්වේ.

1. යුක්ලීඩියානු දුර : දෛශික අවකාශයේ ලක්ෂ්‍ය දෙකක් අතර සරල රේඛා දුර මැනීම.
2. කෝසයින් සමානතාව : දෛශික දෙකක් අතර කෝණයේ කෝසයිනය මැනීම (විශාලත්වයට වඩා ඒවායේ දිශාවට අවධානය යොමු කරමින්).
3. තිත් නිෂ්පාදනය : සාරාංශගත අනුරූප මූලද්‍රව්‍යවල සරල ගුණ කිරීමක්.

සමානතා මිනුමක් තෝරාගැනීම සාමාන්‍යයෙන් යෙදුම්-විශේෂිත දත්ත සහ සංවර්ධකයා ගැටලුවට ප්‍රවේශ වන ආකාරය මත රඳා පවතී.

මහා පරිමාණ දත්ත කට්ටලවල සමානතා සෙවීම සිදු කරන විට, අවශ්‍ය ගණනය කිරීමේ බලය සහ සම්පත් ඉතා ඉහළ ය. ආසන්නතම අසල්වැසි (ANN) ඇල්ගොරිතම පැමිණෙන්නේ මෙහිදීය. සැලකිය යුතු වේගයක් උත්ශ්‍රේණි කිරීම සඳහා කුඩා ප්‍රතිශතයක් හෝ නිරවද්‍යතාවයක් වෙළඳාම් කිරීමට ANN ඇල්ගොරිතම භාවිතා වේ. මෙය මහා පරිමාණ යෙදුම් සඳහා සුදුසු තේරීමක් කරයි.

Milvus විසින් HNSW සහ DiskANN ඇතුළු උසස් ANN ඇල්ගොරිතම ද භාවිතා කරයි, විශාල දෛශික කාවැද්දීමේ දත්ත කට්ටලවල කාර්යක්ෂම සමානතා සෙවීම් සිදු කරයි, සංවර්ධකයින්ට අදාළ දත්ත ලක්ෂ්‍ය ඉක්මනින් සොයා ගැනීමට ඉඩ සලසයි. මීට අමතරව, Milvus HSNW, IVF, CAGRA වැනි අනෙකුත් සුචිගත කිරීමේ ඇල්ගොරිතම සඳහා සහය දක්වයි, එය වඩාත් කාර්යක්ෂම දෛශික සෙවුම් විසඳුමක් බවට පත් කරයි.

Milvus සමඟ Multimodal RAG ගොඩනැගීම

දැන් අපි සංකල්ප ඉගෙන ගත්තා, මිල්වුස් භාවිතයෙන් බහුමාධ්‍ය RAG පද්ධතියක් තැනීමට කාලයයි. මෙම උදාහරණය සඳහා, අපි දෛශික ගබඩා කිරීම සහ නැවත ලබා ගැනීම සඳහා Milvus Lite (Milvus හි සැහැල්ලු අනුවාදය, අත්හදා බැලීම් සහ මූලාකෘති කිරීම සඳහා වඩාත් සුදුසු), නිරවද්‍ය රූප සැකසීම සහ කාවැද්දීම සඳහා BGE, සහ උසස් ප්‍රතිඵල නැවත ශ්‍රේණිගත කිරීම සඳහා GPT-4o භාවිතා කරන්නෙමු.

පූර්වාවශ්යතාවයන්

පළමුව, ඔබේ දත්ත ගබඩා කිරීමට ඔබට මිල්වස් අවස්ථාවක් අවශ්‍ය වේ. ඔබට Pip භාවිතයෙන් Milvus Lite පිහිටුවීමට, Docker භාවිතයෙන් දේශීය අවස්ථාවක් ධාවනය කිරීමට, හෝ Zilliz Cloud හරහා නොමිලේ සත්කාරක මිල්වස් ගිණුමක් සඳහා ලියාපදිංචි විය හැක.

දෙවනුව, ඔබට ඔබේ RAG නල මාර්ගය සඳහා LLM අවශ්‍ය වේ, එබැවින් වෙත යන්න OpenAI සහ API යතුරක් ලබා ගන්න. මෙම කේතය ක්‍රියාත්මක වීමට නිදහස් ස්ථරය ප්‍රමාණවත් වේ.

ඊළඟට, නව නාමාවලියක් සහ පයිතන් එකක් සාදන්න අතථ්‍ය පරිසරය (හෝ Python කළමනාකරණය කිරීමට ඔබ භාවිතා කරන ඕනෑම පියවරක් ගන්න).

මෙම නිබන්ධනය සඳහා, ඔබ ද ස්ථාපනය කිරීමට අවශ්ය වනු ඇත pymilvus මිල්වස්ගේ නිල Python SDK වන පුස්තකාලය සහ පොදු මෙවලම් අතලොස්සකි.

Milvus Lite සකසන්න

 pip install -U pymilvus

පරායත්තතා ස්ථාපනය කරන්න

 pip install --upgrade pymilvus openai datasets opencv-python timm einops ftfy peft tqdm git clone https://github.com/FlagOpen/FlagEmbedding.git pip install -e FlagEmbedding

දත්ත බාගන්න

පහත විධානය මඟින් උදාහරණ දත්ත බාගත කර "./images_folder" දේශීය ෆෝල්ඩරයකට උකහා ගනු ඇත, එයට ඇතුළත් වන්නේ:

• පින්තූර: උප කුලකයක් Amazon Reviews 2023 "උපකරණ", "Cell_Phones_and_Accessories", සහ "Electronics" යන කාණ්ඩවලින් රූප 900ක් පමණ අඩංගු වේ.
• උදාහරණ විමසුම් රූපයක්: leopard.jpg

 wget https://github.com/milvus-io/bootcamp/releases/download/data/amazon_reviews_2023_subset.tar.gz tar -xzf amazon_reviews_2023_subset.tar.gz

කාවැද්දීමේ ආකෘතිය පූරණය කරන්න

අපි රූප සහ පෙළ යන දෙකම සඳහා කාවැද්දීම් උත්පාදනය කිරීමට "bge-visualized-base-en-v1.5" දෘශ්‍යමාන BGE ආකෘතිය භාවිතා කරන්නෙමු.

දැන් HuggingFace එකෙන් බර බාගන්න.

 wget https://huggingface.co/BAAI/bge-visualized/resolve/main/Visualized_base_en_v1.5.pth

එහෙනම් අපි encoder එකක් හදමු.

 import torch from visual_bge.modeling import Visualized_BGE class Encoder:    def __init__(self, model_name: str, model_path: str):        self.model = Visualized_BGE(model_name_bge=model_name, model_weight=model_path)        self.model.eval()    def encode_query(self, image_path: str, text: str) -> list[float]:        with torch.no_grad():            query_emb = self.model.encode(image=image_path, text=text)        return query_emb.tolist()[0]    def encode_image(self, image_path: str) -> list[float]:        with torch.no_grad():            query_emb = self.model.encode(image=image_path)        return query_emb.tolist()[0] model_name = "BAAI/bge-base-en-v1.5" model_path = "./Visualized_base_en_v1.5.pth" # Change to your own value if using a different model path encoder = Encoder(model_name, model_path)

Embeddings උත්පාදනය කර Milvus වෙත දත්ත පැටවීම

අපගේ දත්ත ගබඩාවට අනුරූප කාවැද්දීම් සමඟ උදාහරණ රූප පූරණය කරන්නේ කෙසේදැයි මෙම කොටස ඔබට මග පෙන්වනු ඇත.

කාවැද්දීම උත්පාදනය කරන්න

පළමුව, අපි දත්ත කට්ටලයේ සියලුම පින්තූර සඳහා කාවැද්දීම සෑදිය යුතුය.

දත්ත නාමාවලියෙන් සියලුම පින්තූර පූරණය කර ඒවා කාවැද්දීම බවට පරිවර්තනය කරන්න.

 import os from tqdm import tqdm from glob import glob data_dir = (    "./images_folder" # Change to your own value if using a different data directory ) image_list = glob(    os.path.join(data_dir, "images", "*.jpg") ) # We will only use images ending with ".jpg" image_dict = {} for image_path in tqdm(image_list, desc="Generating image embeddings: "):    try:        image_dict[image_path] = encoder.encode_image(image_path)    except Exception as e:        print(f"Failed to generate embedding for {image_path}. Skipped.")        continue print("Number of encoded images:", len(image_dict))

බහුවිධ සෙවීම සිදු කර ප්‍රතිඵල නැවත ශ්‍රේණිගත කරන්න

මෙම කොටසේදී, අපි ප්‍රථමයෙන් බහුමාධ්‍ය විමසුමක් භාවිතයෙන් අදාළ රූප සොයන අතර පසුව ලබාගත් ප්‍රතිඵල නැවත ශ්‍රේණිගත කිරීමට සහ පැහැදිලි කිරීමක් සමඟ හොඳම එක සොයා ගැනීමට LLM සේවාවක් භාවිතා කරන්නෙමු.

බහු මාදිලි සෙවුම් ධාවනය කරන්න

දැන් අපි රූප සහ පෙළ උපදෙස් වලින් සමන්විත විමසුම සමඟ උසස් බහුමාධ්‍ය සෙවීම සිදු කිරීමට සූදානම්.

 query_image = os.path.join(    data_dir, "leopard.jpg" ) # Change to your own query image path query_text = "phone case with this image theme" query_vec = encoder.encode_query(image_path=query_image, text=query_text) search_results = milvus_client.search(    collection_name=collection_name,    data=[query_vec],    output_fields=["image_path"],    limit=9, # Max number of search results to return    search_params={"metric_type": "COSINE", "params": {}}, # Search parameters )[0] retrieved_images = [hit.get("entity").get("image_path") for hit in search_results] print(retrieved_images)

ප්රතිඵලය පහත දැක්වේ:

 ['./images_folder/images/518Gj1WQ-RL._AC_.jpg', './images_folder/images/41n00AOfWhL._AC_.jpg'

GPT-4o සමඟ ප්‍රතිඵල නැවත ශ්‍රේණිගත කරන්න

දැන්, අපි ලබා ගත් පින්තූර ශ්‍රේණිගත කිරීමට සහ හොඳම-ගැළපෙන ප්‍රතිඵල සොයා ගැනීමට GPT-4o භාවිත කරන්නෙමු. එය එසේ ශ්‍රේණිගත වන්නේ මන්දැයි LLM ද පැහැදිලි කරනු ඇත.

1. පරිදර්ශක දසුනක් සාදන්න.

 import numpy as np import cv2 img_height = 300 img_width = 300 row_count = 3 def create_panoramic_view(query_image_path: str, retrieved_images: list) -> np.ndarray:    """    creates a 5x5 panoramic view image from a list of images    args:        images: list of images to be combined    returns:        np.ndarray: the panoramic view image    """    panoramic_width = img_width * row_count    panoramic_height = img_height * row_count    panoramic_image = np.full(        (panoramic_height, panoramic_width, 3), 255, dtype=np.uint8    )    # create and resize the query image with a blue border    query_image_null = np.full((panoramic_height, img_width, 3), 255, dtype=np.uint8)    query_image = Image.open(query_image_path).convert("RGB")    query_array = np.array(query_image)[:, :, ::-1]    resized_image = cv2.resize(query_array, (img_width, img_height))    border_size = 10    blue = (255, 0, 0) # blue color in BGR    bordered_query_image = cv2.copyMakeBorder(        resized_image,        border_size,        border_size,        border_size,        border_size,        cv2.BORDER_CONSTANT,        value=blue,    )    query_image_null[img_height * 2 : img_height * 3, 0:img_width] = cv2.resize(        bordered_query_image, (img_width, img_height)    )    # add text "query" below the query image    text = "query"    font_scale = 1    font_thickness = 2    text_org = (10, img_height * 3 + 30)    cv2.putText(        query_image_null,        text,        text_org,        cv2.FONT_HERSHEY_SIMPLEX,        font_scale,        blue,        font_thickness,        cv2.LINE_AA,    )    # combine the rest of the images into the panoramic view    retrieved_imgs = [        np.array(Image.open(img).convert("RGB"))[:, :, ::-1] for img in retrieved_images    ]    for i, image in enumerate(retrieved_imgs):        image = cv2.resize(image, (img_width - 4, img_height - 4))        row = i // row_count        col = i % row_count        start_row = row * img_height        start_col = col * img_width        border_size = 2        bordered_image = cv2.copyMakeBorder(            image,            border_size,            border_size,            border_size,            border_size,            cv2.BORDER_CONSTANT,            value=(0, 0, 0),        )        panoramic_image[            start_row : start_row + img_height, start_col : start_col + img_width        ] = bordered_image        # add red index numbers to each image        text = str(i)        org = (start_col + 50, start_row + 30)        (font_width, font_height), baseline = cv2.getTextSize(            text, cv2.FONT_HERSHEY_SIMPLEX, 1, 2        )        top_left = (org[0] - 48, start_row + 2)        bottom_right = (org[0] - 48 + font_width + 5, org[1] + baseline + 5)        cv2.rectangle(            panoramic_image, top_left, bottom_right, (255, 255, 255), cv2.FILLED        )        cv2.putText(            panoramic_image,            text,            (start_col + 10, start_row + 30),            cv2.FONT_HERSHEY_SIMPLEX,            1,            (0, 0, 255),            2,            cv2.LINE_AA,        )    # combine the query image with the panoramic view    panoramic_image = np.hstack([query_image_null, panoramic_image])    return panoramic_image

2. විමසුම් රූපය සහ ලබාගත් රූප පරිදර්ශක දසුනක දර්ශක සමඟ ඒකාබද්ධ කරන්න.

 from PIL import Image combined_image_path = os.path.join(data_dir, "combined_image.jpg") panoramic_image = create_panoramic_view(query_image, retrieved_images) cv2.imwrite(combined_image_path, panoramic_image) combined_image = Image.open(combined_image_path) show_combined_image = combined_image.resize((300, 300)) show_combined_image.show() 

3. ප්‍රතිඵල නැවත ශ්‍රේණිගත කර පැහැදිලි කිරීමක් කරන්න

ලබා ගත් ප්‍රතිඵල පැහැදිලි කිරීමක් සමඟ ශ්‍රේණිගත කිරීමට නිසි විමසුම් සමඟ අපි සියලුම ඒකාබද්ධ රූප බහුමාධ්‍ය LLM සේවාව වෙත යවන්නෙමු. සටහන: එල්එල්එම් ලෙස GPT-4o සක්‍රීය කිරීමට, ඔබ සූදානම් විය යුතුය OpenAI API යතුර කලින්.

 import requests import base64 openai_api_key = "sk-***" # Change to your OpenAI API Key def generate_ranking_explanation(    combined_image_path: str, caption: str, infos: dict = None ) -> tuple[list[int], str]:    with open(combined_image_path, "rb") as image_file:        base64_image = base64.b64encode(image_file.read()).decode("utf-8")    information = (        "You are responsible for ranking results for a Composed Image Retrieval. "        "The user retrieves an image with an 'instruction' indicating their retrieval intent. "        "For example, if the user queries a red car with the instruction 'change this car to blue,' a similar type of car in blue would be ranked higher in the results. "        "Now you would receive instruction and query image with blue border. Every item has its red index number in its top left. Do not misunderstand it. "        f"User instruction: {caption} \n\n"    )    # add additional information for each image    if infos:        for i, info in enumerate(infos["product"]):            information += f"{i}. {info}\n"    information += (        "Provide a new ranked list of indices from most suitable to least suitable, followed by an explanation for the top 1 most suitable item only. "        "The format of the response has to be 'Ranked list: []' with the indices in brackets as integers, followed by 'Reasons:' plus the explanation why this most fit user's query intent."    )    headers = {        "Content-Type": "application/json",        "Authorization": f"Bearer {openai_api_key}",    }    payload = {        "model": "gpt-4o",        "messages": [            {                "role": "user",                "content": [                    {"type": "text", "text": information},                    {                        "type": "image_url",                        "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"},                    },                ],            }        ],        "max_tokens": 300,    }    response = requests.post(        "https://api.openai.com/v1/chat/completions", headers=headers, json=payload    )    result = response.json()["choices"][0]["message"]["content"]    # parse the ranked indices from the response    start_idx = result.find("[")    end_idx = result.find("]")    ranked_indices_str = result[start_idx + 1 : end_idx].split(",")    ranked_indices = [int(index.strip()) for index in ranked_indices_str]    # extract explanation    explanation = result[end_idx + 1 :].strip()    return ranked_indices, explanation

ශ්‍රේණිගත කිරීමෙන් පසු රූප දර්ශක ලබා ගන්න සහ හොඳම ප්‍රතිඵලය සඳහා හේතුව:

 ranked_indices, explanation = generate_ranking_explanation(    combined_image_path, query_text )

4. පැහැදිලි කිරීම සමඟ හොඳම ප්රතිඵලය පෙන්වන්න

 print(explanation) best_index = ranked_indices[0] best_img = Image.open(retrieved_images[best_index]) best_img = best_img.resize((150, 150)) best_img.show()

ප්රතිඵල:

 Reasons: The most suitable item for the user's query intent is index 6 because the instruction specifies a phone case with the theme of the image, which is a leopard. The phone case with index 6 has a thematic design resembling the leopard pattern, making it the closest match to the user's request for a phone case with the image theme. 

මෙම සටහන් පොතේ සම්පූර්ණ කේතය පරීක්ෂා කරන්න. මෙම නිබන්ධනය සමඟ සබැඳි ආදර්ශනයක් ආරම්භ කරන්නේ කෙසේද යන්න පිළිබඳ වැඩිදුර දැන ගැනීමට, කරුණාකර බලන්න උදාහරණ යෙදුම .

නිගමනය

මෙම බ්ලොග් සටහනේදී, අපි බහුමාධ්‍ය RAG පද්ධතියක් ගොඩනැගීම ගැන සාකච්ඡා කළෙමු මිල්වුස් (විවෘත මූලාශ්‍ර දෛශික දත්ත ගබඩාවක්). සංවර්ධකයින්ට Milvus පිහිටුවීම, රූප දත්ත පූරණය කිරීම, සමානතා සෙවීම් සිදු කිරීම සහ වඩාත් නිවැරදි ප්‍රතිචාර සඳහා ලබා ගත් ප්‍රතිඵල නැවත ශ්‍රේණිගත කිරීම සඳහා LLM භාවිතා කරන ආකාරය අපි ආවරණය කළෙමු.

බහුවිධ RAG විසඳුම් මඟින් AI පද්ධති සඳහා විවිධ හැකියාවන් විවර කර ඇති අතර එමඟින් විවිධ ආකාරයේ දත්ත පහසුවෙන් තේරුම් ගැනීමට සහ සැකසීමට හැකිය. සමහර පොදු හැකියාවන් අතර වැඩිදියුණු කළ රූප සෙවුම් යන්ත්‍ර, වඩා හොඳ සන්දර්භය-ධාවන ප්‍රතිඵල සහ තවත් දේ ඇතුළත් වේ.