ប្រវត្តិសាស្ត្រថ្មី។
ចង់ស្វែងរកអ្វីមួយដែលមានរូបភាព និងការពិពណ៌នាអត្ថបទ? សាកល្បងប្រើ Multimodal RAG
យូរពេក; អាន
ការណែនាំស៊ីជម្រៅអំពីរបៀបបង្កើតប្រព័ន្ធ RAG ពហុម៉ូឌុលដោយប្រើ Milvus និងរបៀបបើកលទ្ធភាពផ្សេងៗសម្រាប់ប្រព័ន្ធ AI ។
អត្ថបទនេះផ្តល់នូវការណែនាំស៊ីជម្រៅអំពីរបៀបបង្កើតប្រព័ន្ធ RAG ពហុម៉ូឌុលដោយប្រើ Milvus និងរបៀបបើកលទ្ធភាពផ្សេងៗសម្រាប់ប្រព័ន្ធ AI ។
ការដាក់កម្រិតលើទម្រង់ទិន្នន័យតែមួយគឺមិនល្អគ្រប់គ្រាន់ទៀតទេ។ ដោយសារអាជីវកម្មពឹងផ្អែកខ្លាំងលើព័ត៌មានដើម្បីធ្វើការសម្រេចចិត្តសំខាន់ៗ ពួកគេត្រូវការសមត្ថភាពក្នុងការប្រៀបធៀបទិន្នន័យក្នុងទម្រង់ផ្សេងគ្នា។ ជាសំណាងល្អ ប្រព័ន្ធ AI ប្រពៃណីដែលដាក់កម្រិតលើប្រភេទទិន្នន័យតែមួយបានផ្ដល់មធ្យោបាយដល់ប្រព័ន្ធពហុមុខងារដែលអាចយល់ និងដំណើរការព័ត៌មានស្មុគស្មាញ។
ប្រព័ន្ធស្វែងរកច្រើនម៉ូដ និង ការទាញយកច្រើនម៉ូដជំនាន់បន្ថែម (RAG) បានបង្ហាញពីការជឿនលឿនដ៏អស្ចារ្យក្នុងវិស័យនេះ។ ប្រព័ន្ធទាំងនេះដំណើរការទិន្នន័យច្រើនប្រភេទ រួមទាំងអត្ថបទ រូបភាព និងអូឌីយ៉ូ ដើម្បីផ្តល់នូវការឆ្លើយតបដែលដឹងពីបរិបទ។
នៅក្នុងការប្រកាសប្លក់នេះ យើងនឹងពិភាក្សាអំពីរបៀបដែលអ្នកអភិវឌ្ឍន៍អាចបង្កើតប្រព័ន្ធ RAG ពហុម៉ូឌុលផ្ទាល់ខ្លួនរបស់ពួកគេដោយប្រើ Milvus ។ យើងក៏នឹងណែនាំអ្នកតាមរយៈការបង្កើតប្រព័ន្ធបែបនេះដែលអាចគ្រប់គ្រងទិន្នន័យអត្ថបទ និងរូបភាព ជាពិសេសធ្វើការស្វែងរកភាពស្រដៀងគ្នា និងប្រើប្រាស់គំរូភាសាដើម្បីកែលម្អលទ្ធផល។ ដូច្នេះសូមចាប់ផ្តើម។
តើ Milvus ជាអ្វី?
មូលដ្ឋានទិន្នន័យវ៉ិចទ័រគឺជាប្រភេទមូលដ្ឋានទិន្នន័យពិសេសដែលប្រើសម្រាប់រក្សាទុក លិបិក្រម និងទាញយកការបង្កប់វ៉ិចទ័រ ដែលជាតំណាងគណិតវិទ្យានៃទិន្នន័យដែលអនុញ្ញាតឱ្យអ្នកប្រៀបធៀបទិន្នន័យសម្រាប់មិនត្រឹមតែសមមូលប៉ុណ្ណោះទេ ប៉ុន្តែភាពស្រដៀងគ្នានៃន័យធៀប។
Milvus ជួយអ្នកអភិវឌ្ឍន៍ផ្តល់នូវដំណោះស្រាយដែលអាចបត់បែនបានសម្រាប់ការគ្រប់គ្រង និងសាកសួរទិន្នន័យវ៉ិចទ័រខ្នាតធំ។ ប្រសិទ្ធភាពរបស់វាធ្វើឱ្យ Milvus ជាជម្រើសដ៏ល្អសម្រាប់អ្នកបង្កើតកម្មវិធីដែលបង្កើតកម្មវិធីដោយប្រើគំរូសិក្សាជ្រៅៗ ដូចជា ទាញយកជំនាន់បន្ថែម (RAG) ការស្វែងរកពហុម៉ូឌុល ម៉ាស៊ីនណែនាំ និងការរកឃើញភាពមិនធម្មតា។
Milvus ផ្តល់នូវជម្រើសនៃការដាក់ពង្រាយជាច្រើន ដើម្បីផ្គូផ្គងតម្រូវការរបស់អ្នកអភិវឌ្ឍន៍។
Multimodal RAG៖ ពង្រីកលើសពីអត្ថបទ
មុនពេលបង្កើតប្រព័ន្ធ វាជារឿងសំខាន់ក្នុងការយល់ដឹងអំពី RAG ដែលមានមូលដ្ឋានលើអត្ថបទបែបប្រពៃណី និងការវិវត្តរបស់វាទៅជា Multimodal RAG ។
Retrieval Augmented Generation (RAG) គឺជាវិធីសាស្រ្តសម្រាប់ការទាញយកព័ត៌មានបរិបទពីប្រភពខាងក្រៅ និងបង្កើតលទ្ធផលត្រឹមត្រូវជាងមុនពីគំរូភាសាធំ (LLMs)។ ប្រពៃណី RAG គឺជាយុទ្ធសាស្រ្តដ៏មានប្រសិទ្ធភាពខ្ពស់សម្រាប់ការកែលម្អទិន្នផល LLM ប៉ុន្តែវានៅតែមានកម្រិតចំពោះទិន្នន័យអត្ថបទ។ នៅក្នុងកម្មវិធីពិភពពិតជាច្រើន ទិន្នន័យលាតសន្ធឹងលើសពីអត្ថបទ—ការបញ្ចូលរូបភាព គំនូសតាង និងទម្រង់ផ្សេងៗទៀតផ្តល់នូវបរិបទសំខាន់។
Multimodal RAG ដោះស្រាយដែនកំណត់ខាងលើដោយបើកការប្រើប្រាស់ប្រភេទទិន្នន័យផ្សេងៗគ្នា ដោយផ្តល់បរិបទកាន់តែប្រសើរដល់ LLMs ។
និយាយឱ្យសាមញ្ញនៅក្នុងប្រព័ន្ធ RAG ពហុម៉ូឌុល សមាសធាតុទាញយកស្វែងរកព័ត៌មានដែលពាក់ព័ន្ធតាមទម្រង់ទិន្នន័យផ្សេងៗគ្នា ហើយសមាសធាតុជំនាន់បង្កើតលទ្ធផលត្រឹមត្រូវជាងមុនដោយផ្អែកលើព័ត៌មានដែលបានទាញយក។
ការយល់ដឹងពីការបង្កប់វ៉ិចទ័រ និងការស្វែងរកភាពស្រដៀងគ្នា
ការបង្កប់វ៉ិចទ័រ និង ការស្វែងរកភាពស្រដៀងគ្នា គឺជាគោលគំនិតជាមូលដ្ឋានពីរនៃ RAG ពហុម៉ូឌុល។ ចូរយើងយល់ពីពួកគេទាំងពីរ។
ការបង្កប់វ៉ិចទ័រ
ដូចដែលបានពិភាក្សា ការបង្កប់វ៉ិចទ័រគឺជាតំណាងគណិតវិទ្យា/លេខនៃទិន្នន័យ។ ម៉ាស៊ីនប្រើការតំណាងនេះដើម្បីយល់ពីអត្ថន័យអត្ថន័យនៃប្រភេទទិន្នន័យផ្សេងៗគ្នា ដូចជាអត្ថបទ រូបភាព និងសំឡេង។
នៅពេលប្រើដំណើរការភាសាធម្មជាតិ (NLP) កំណាត់ឯកសារត្រូវបានបំប្លែងទៅជាវ៉ិចទ័រ ហើយពាក្យដែលស្រដៀងគ្នាតាមន័យធៀបត្រូវបានផ្គូផ្គងទៅចំណុចក្បែរៗក្នុងចន្លោះវ៉ិចទ័រ។ ដូចគ្នាដែរចំពោះរូបភាព ដែលការបង្កប់តំណាងឱ្យលក្ខណៈអត្ថន័យ។ នេះអនុញ្ញាតឱ្យយើងយល់ពីម៉ែត្រដូចជាពណ៌ វាយនភាព និងរូបរាងវត្ថុក្នុងទម្រង់ជាលេខ។
គោលដៅចម្បងនៃការប្រើប្រាស់ការបង្កប់វ៉ិចទ័រគឺដើម្បីជួយរក្សាទំនាក់ទំនងនិងភាពស្រដៀងគ្នារវាងបំណែកនៃទិន្នន័យផ្សេងៗគ្នា។
ការស្វែងរកភាពស្រដៀងគ្នា
ការស្វែងរកភាពស្រដៀងគ្នាត្រូវបានប្រើដើម្បីស្វែងរក និងកំណត់ទីតាំងទិន្នន័យនៅក្នុងសំណុំទិន្នន័យដែលបានផ្តល់ឱ្យ។ នៅក្នុងបរិបទនៃការបង្កប់វ៉ិចទ័រ ការស្វែងរកភាពស្រដៀងគ្នានឹងរកឃើញវ៉ិចទ័រនៅក្នុងសំណុំទិន្នន័យដែលបានផ្តល់ឱ្យដែលនៅជិតបំផុតទៅនឹងវ៉ិចទ័រសំណួរ។
ខាងក្រោមនេះគឺជាវិធីសាស្ត្រមួយចំនួនដែលត្រូវបានប្រើជាទូទៅដើម្បីវាស់ស្ទង់ភាពស្រដៀងគ្នារវាងវ៉ិចទ័រ៖
- Euclidean Distance ៖ វាស់ចម្ងាយបន្ទាត់ត្រង់រវាងចំនុចពីរក្នុងចន្លោះវ៉ិចទ័រ។
- ភាពស្រដៀងគ្នានៃកូស៊ីនុស ៖ វាស់កូស៊ីនុសនៃមុំរវាងវ៉ិចទ័រពីរ (ដោយផ្តោតលើទិសដៅរបស់វាជាជាងរ៉ិចទ័រ)។
- ផលិតផលចំនុច ៖ គុណសាមញ្ញនៃធាតុដែលត្រូវគ្នាសរុបមក។
ជម្រើសនៃការវាស់វែងភាពស្រដៀងគ្នាជាធម្មតាអាស្រ័យលើទិន្នន័យជាក់លាក់នៃកម្មវិធី និងរបៀបដែលអ្នកអភិវឌ្ឍន៍ដោះស្រាយបញ្ហានេះ។
នៅពេលធ្វើការស្វែងរកភាពស្រដៀងគ្នាលើសំណុំទិន្នន័យខ្នាតធំ ថាមពលគណនា និងធនធានដែលត្រូវការគឺខ្ពស់ណាស់។ នេះជាកន្លែងដែលក្បួនដោះស្រាយជិតខាងបំផុត (ANN) ចូលមក។ ក្បួនដោះស្រាយ ANN ត្រូវបានប្រើដើម្បីដោះដូរភាគរយតូច ឬចំនួននៃភាពត្រឹមត្រូវសម្រាប់ការដំឡើងល្បឿនយ៉ាងសំខាន់។ នេះធ្វើឱ្យពួកគេក្លាយជាជម្រើសសមរម្យសម្រាប់កម្មវិធីខ្នាតធំ។
Milvus ក៏ប្រើក្បួនដោះស្រាយ ANN កម្រិតខ្ពស់ រួមទាំង HNSW និង DiskANN ដើម្បីធ្វើការស្វែងរកភាពស្រដៀងគ្នាប្រកបដោយប្រសិទ្ធភាពលើសំណុំទិន្នន័យបង្កប់វ៉ិចទ័រធំ ដែលអនុញ្ញាតឱ្យអ្នកអភិវឌ្ឍន៍ស្វែងរកចំណុចទិន្នន័យដែលពាក់ព័ន្ធបានយ៉ាងឆាប់រហ័ស។ លើសពីនេះទៀត Milvus គាំទ្រក្បួនដោះស្រាយការធ្វើលិបិក្រមផ្សេងទៀតដូចជា HSNW, IVF, CAGRA ជាដើម ដែលធ្វើឱ្យវាក្លាយជាដំណោះស្រាយស្វែងរកវ៉ិចទ័រដែលមានប្រសិទ្ធភាពជាង។
ការកសាង Multimodal RAG ជាមួយ Milvus
ឥឡូវនេះ យើងបានសិក្សាពីគោលគំនិត វាដល់ពេលហើយដើម្បីសាងសង់ប្រព័ន្ធ RAG ពហុម៉ូឌុលដោយប្រើ Milvus ។ សម្រាប់ឧទាហរណ៍នេះ យើងនឹងប្រើ Milvus Lite (កំណែទម្ងន់ស្រាលរបស់ Milvus ដែលល្អសម្រាប់ការពិសោធន៍ និងការបង្កើតគំរូ) សម្រាប់ការផ្ទុក និងទាញយកវ៉ិចទ័រ BGE សម្រាប់ដំណើរការ និងបង្កប់រូបភាពច្បាស់លាស់ និង GPT-4o សម្រាប់ចំណាត់ថ្នាក់លទ្ធផលកម្រិតខ្ពស់។
តម្រូវការជាមុន
ដំបូង អ្នកនឹងត្រូវការឧទាហរណ៍ Milvus ដើម្បីរក្សាទុកទិន្នន័យរបស់អ្នក។ អ្នកអាចដំឡើង Milvus Lite ដោយប្រើ pip ដំណើរការ instance ក្នុងស្រុកដោយប្រើ Docker ឬចុះឈ្មោះសម្រាប់គណនី Milvus ដែលបានបង្ហោះដោយឥតគិតថ្លៃតាមរយៈ Zilliz Cloud ។
ទីពីរ អ្នកត្រូវការ LLM សម្រាប់បំពង់ RAG របស់អ្នក ដូច្នេះសូមចូលទៅកាន់
បន្ទាប់មកបង្កើតថតឯកសារថ្មី និង Python
សម្រាប់មេរៀននេះ អ្នកនឹងត្រូវដំឡើងកម្មវិធីផងដែរ។
ដំឡើង 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 ឆ្នាំ 2023 មានរូបភាពប្រហែល 900 ពីប្រភេទ "ឧបករណ៍", "Cell_Phones_and_Accessories" និង "អេឡិចត្រូនិក"។ - រូបភាពសំណួរឧទាហរណ៍៖ 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ផ្ទុកគំរូបង្កប់
យើងនឹងប្រើគំរូ Visualized BGE “bge-visualized-base-en-v1.5” ដើម្បីបង្កើតការបង្កប់សម្រាប់ទាំងរូបភាព និងអត្ថបទ។
ឥឡូវនេះទាញយកទម្ងន់ពី HuggingFace ។
wget https://huggingface.co/BAAI/bge-visualized/resolve/main/Visualized_base_en_v1.5.pth
បន្ទាប់មក ចូរយើងបង្កើតកម្មវិធីបំប្លែងកូដ។
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)បង្កើតការបង្កប់ និងផ្ទុកទិន្នន័យទៅក្នុង 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. បង្កើតទិដ្ឋភាពបែប Panoramic ។
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. ផ្សំរូបភាពសំណួរ និងយករូបភាពដែលមានសន្ទស្សន៍ក្នុងទិដ្ឋភាពបែប Panoramic ។
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 ជា LLM អ្នកត្រូវរៀបចំរបស់អ្នក។
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 ពហុម៉ូឌុលដោយប្រើ
ដំណោះស្រាយពហុម៉ូឌុល RAG បើកលទ្ធភាពផ្សេងៗសម្រាប់ប្រព័ន្ធ AI ដែលអាចយល់បានយ៉ាងងាយស្រួល និងដំណើរការទម្រង់ទិន្នន័យច្រើន។ លទ្ធភាពទូទៅមួយចំនួនរួមមានម៉ាស៊ីនស្វែងរករូបភាពដែលប្រសើរឡើង លទ្ធផលដែលជំរុញដោយបរិបទកាន់តែប្រសើរ និងច្រើនទៀត។
L O A D I N G
. . . comments & more!
. . . comments & more!
