मैन्टिकोरे सर्च 6.3.0 से वेक्टर खोज का समर्थन करता है! आइए इसके बारे में और जानें - यह क्या है, यह क्या लाभ लाता है, और इसे GitHub मुद्दा खोज योगदान के उदाहरण के रूप में एकीकृत करने के तरीके पर उपयोग कैसे करें।
पूर्ण-टेक्स्ट खोज और वेक्टर खोज
पूर्ण-टेक्स्ट खोज उपयोगी है क्योंकि यह कीवर्ड के सटीक मिलानों को खोजकर कुशलता से खोजने की अनुमति देती है। हालांकि, यह मुख्य रूप से कीवर्ड पर निर्भर करती है, जो कभी-कभी सीमित हो सकती है। इसके विपरीत, सेमान्टिक खोज वेक्टर समानता और मशीन लर्निंग का उपयोग करके आपकी खोज के पीछे के अर्थ को समझती है और दस्तावेजों को खोजती है जो आप जिस चीज़ की तलाश कर रहे हैं, उसके समान हैं। यह विधि अक्सर बेहतर परिणाम देती है और अधिक प्राकृतिक और आरामदायक शैली में खोजों की अनुमति देती है।
हम मैन्टिकोरे सर्च में इस शक्तिशाली विशेषता को पेश करने के लिए उत्साहित हैं, जिसे Columnar library के एक हिस्से के रूप में कार्यान्वित किया गया है। आइए देखें कि इसे कैसे शुरू किया जाए।
वेक्टर खोज और मैन्टिकोरे के साथ शुरुआत करें
वेक्टर खोज पर एक त्वरित परिचय: वेक्टर खोज करने के लिए, पाठ को वेक्टर में परिवर्तित करना होगा, जो आमतौर पर फ्लोटिंग-पॉइंट संख्याओं की क्रमबद्ध सूचियाँ होती हैं। आप अपनी क्वेरी के साथ भी ऐसा ही करते हैं। फिर, अपनी क्वेरी के वेक्टर की तुलना अपने दस्तावेजों के वेक्टर से करें और उन्हें निकटता के आधार पर क्रमित करें। हमारे अन्य लेख के बारे में पढ़ें पुराने और आधुनिक डेटाबेस में वेक्टर खोज ।
हम थोड़ी देर में चर्चा करेंगे कि पाठ को वेक्टर में कैसे बदलें, लेकिन पहले, आइए देखें कि मैन्टिकोरे सर्च में वेक्टर के साथ कैसे काम करना है।
स्थापना
मैन्टिकोरे में वेक्टर खोज कार्यक्षमता संस्करण 6.3.0 से उपलब्ध है। सुनिश्चित करें कि मैन्टिकोरे Columnar library के साथ स्थापित है। यदि आपको स्थापना में मदद की आवश्यकता है, तो दस्तावेज़ की जाँच करें।
तालिका बनाना
सबसे पहले, हमें एक रीयल-टाइम तालिका बनानी होगी जो हमारे स्कीमा घोषणा को बनाए रखेगी। इसमें वेक्टर को स्टोर करने के लिए एक फ़ील्ड शामिल होगा, जिससे हम निर्दिष्ट वाक्यविन्यास का उपयोग करके उनका क्वेरी कर सकें। आइए एक सरल तालिका बनाते हैं। तालिका में float_vector प्रकार का एक फ़ील्ड होना चाहिए या विकल्पों के साथ कॉन्फ़िगर किया जाना चाहिए।
create table test ( title text, image_vector float_vector knn_type='hnsw' knn_dims='4' hnsw_similarity='l2' );
आप विस्तार से दस्तावेज़ यहाँ पढ़ सकते हैं।
डेटा डालना
एक बार तालिका सेट होने के बाद, हमें इसे कुछ डेटा से भरना होगा इससे पहले कि हम इसमें से कोई जानकारी पुनः प्राप्त कर सकें।
insert into test values ( 1, 'पीला बैग', (0.653448,0.192478,0.017971,0.339821) ), ( 2, 'सफेद बैग', (-0.148894,0.748278,0.091892,-0.095406) );
मैन्टिकोरे सर्च SQL का समर्थन करता है, जिससे यह SQL डेटाबेस से परिचित लोगों के लिए उपयोग में आसान हो जाता है। हालांकि, यदि आप साधारण HTTP अनुरोध का उपयोग करना पसंद करते हैं, तो यह विकल्प भी उपलब्ध है! यहाँ है कि आप HTTP का उपयोग करके पहले SQL ऑपरेशन को कैसे कर सकते हैं:
POST /insert
{
"index":"test_vec",
"id":1,
"doc": { "title" : "पीला बैग", "image_vector" : [0.653448,0.192478,0.017971,0.339821] }
}
POST /insert
{
"index":"test_vec",
"id":2,
"doc": { "title" : "सफेद बैग", "image_vector" : [-0.148894,0.748278,0.091892,-0.095406] }
}
डेटा क्वेरी करना
आखिरी चरण हमारे पूर्व-गणितीय अनुरोध वेक्टर का उपयोग करके परिणामों को क्वेरी करने में शामिल है, जो AI मॉडल के साथ तैयार किए गए दस्तावेजों के वेक्टर के समान है। हम इस प्रक्रिया को अपने लेख के अगले भाग में और विस्तार से समझाएंगे। अभी के लिए, यहाँ एक उदाहरण है कि हम अपनी तैयार वेक्टर का उपयोग करके तालिका से डेटा को कैसे क्वेरी कर सकते हैं:
mysql> select id, knn_dist() from test where knn ( image_vector, 5, (0.286569,-0.031816,0.066684,0.032926), 2000 );
आपको यह प्राप्त होगा:
+------+------------+
| id | knn_dist() |
+------+------------+
| 1 | 0.28146550 |
| 2 | 0.81527930 |
+------+------------+
2 rows in set (0.00 sec)
यानी, 2 दस्तावेज जो उनके वेक्टरों की निकटता के आधार पर क्वेरी वेक्टर के निकट क्रमबद्ध किए गए हैं।
मैन्टिकोरे वेक्टर खोज समर्थित क्लाइंटों में
मैन्टिकोरे सर्च विभिन्न भाषाओं के लिए क्लाइंट प्रदान करता है, सभी वेक्टर खोज का उपयोग करके डेटा क्वेरीिंग का समर्थन करते हैं। उदाहरण के लिए, यहाँ बताया गया है कि आप PHP क्लाइंट के साथ यह कैसे कर सकते हैं:
<?php
use Manticoresearch\Client;
use Manticoresearch\Search;
use Manticoresearch\Query\KnnQuery;
// पहले क्लाइंट बनाएं
$params = [
'host' => '127.0.0.1',
'port' => 9308,
];
$client = new Client($params);
// खोज वस्तु बनाएं और क्वेरी के लिए सूचकांक सेट करें
$search = new Search($client);
$search->setIndex('test');
// अब क्वेरी करें
$results = $search->knn('image_vector', [0.286569,-0.031816,0.066684,0.032926], 5);
आसान, है ना? यदि आप विभिन्न विकल्पों के बारे में अधिक जानना चाहते हैं, तो आप PHP क्लाइंट दस्तावेज़ की जाँच कर सकते हैं।
टेक्स्ट को वेक्टर में कैसे परिवर्तित करें?
आइए अब चर्चा करें कि हम पाठ से वेक्टर कैसे प्राप्त कर सकते हैं।
“एम्बेडिंग” एक वेक्टर है जो पाठ का प्रतिनिधित्व करता है और इसके अर्थ को कैद करता है। वर्तमान में, मैन्टिकोरे सर्च स्वचालित रूप से एम्बेडिंग नहीं बनाता है। हालाँकि, हम इस सुविधा को जोड़ने पर काम कर रहे हैं और इसके लिए एक खुला टिकट GitHub पर है। जब तक यह सुविधा उपलब्ध नहीं है, तब तक आपको बाहर से एम्बेडिंग तैयार करनी होगी। इसलिए, हमें टेक्स्ट को फ्लोट्स की सूची में परिवर्तित करने की एक विधि की आवश्यकता है जिसे स्टोर किया जा सके और बाद में वेक्टर खोज का उपयोग करके क्वेरी किया जा सके।
You can use various solutions for converting texts to embeddings. हम Hugging Face से वाक्य ट्रांसफॉर्मर का उपयोग करने की सिफारिश कर सकते हैं, जिसमें पूर्व-प्रशिक्षित मॉडल्स शामिल हैं जो टेक्स्ट को उच्च-आयामी वेक्टर में परिवर्तित करते हैं। ये मॉडल टेक्स्ट के बीच की अर्थसंबंधी समानताओं को प्रभावी ढंग से पकड़ते हैं।
The process of converting text to vectors using sentence transformers includes these steps:
- Load the pre-trained model: Begin by loading the desired sentence transformer model from the Hugging Face repository. ये मॉडल, जो व्यापक टेक्स्ट डेटा पर प्रशिक्षित होते हैं, शब्दों और वाक्यांशों के बीच के अर्थ संबंधों को प्रभावी ढंग से समझ सकते हैं।
- Tokenize and encode text: Use the model to break the text into tokens (words or subwords) and convert these tokens into numerical representations.
- Compute vector representations: The model calculates vector representations for the text. ये वेक्टर आमतौर पर उच्च-आयामी (जैसे, 768 आयाम) होते हैं और टेक्स्ट के अर्थ का संख्यात्मक प्रतिनिधित्व करते हैं।
- Store vectors in the database: Once you have the vector representations, store them in Manticore along with the corresponding text.
- Query: To find texts similar to a query, convert the query text into a vector using the same model. Use Manticore Vector Search to locate the nearest vectors (and their associated texts) in the database.
Semantic Search in the GitHub Demo
In a previous article , we built a demo showcasing the usage of Manticore Search in a real-world example: GitHub issue search . It worked well and already provided benefits over GitHub’s native search. With the latest update to Manticore Search, which includes vector search, we thought it would be interesting to add semantic search capability to our demo. आइए देखें कि इसे कैसे लागू किया गया।
Although most libraries that generate embeddings are written in Python, we’re using PHP in our demo. To integrate vector search into our demo application, we had two options:
- An API server (which can utilize Python but might be slower)
- A PHP extension, which we have chosen to implement.
While looking into how to create text embeddings quickly and directly, we discovered a few helpful tools that allowed us to achieve our goal. Consequently, we created an easy-to-use PHP extension that can generate text embeddings. यह एक्सटेंशन आपको HuggingFace पर Sentence Transformers से कोई भी मॉडल चुनने की अनुमति देता है। यह CandleML फ्रेमवर्क पर आधारित है, जो Rust में लिखा गया है और प्रसिद्ध HuggingFace पारिस्थितिकी तंत्र का हिस्सा है। PHP एक्सटेंशन भी php-ext-rs पुस्तकालय का उपयोग करके Rust में तैयार किया गया है। यह दृष्टिकोण सुनिश्चित करता है कि एक्सटेंशन तेजी से चल सके जबकि इसे विकसित करना भी आसान है।
Connecting all the different parts was challenging, but as a result, we have this extension that easily turns text into vectors directly within PHP code, simplifying the process significantly.
<?php
use Manticore\\Ext\\Model;
// One from <https://huggingface.co/sentence-transformers>
$model = Model::create("sentence-transformers/all-MiniLM-L12-v2");
var_dump($model->predict("Hello world"));
The great advantage is that the model is remarkably fast at generating embeddings, and it only needs to be loaded once. All subsequent calls are executed in just a few milliseconds, providing good performance for PHP and sufficient speed for the demo project. Consequently, we decided to proceed with this approach. You can check and use our extension on GitHub here .
The challenging part is done; next, we need to integrate it into the Demo project with minimal code changes.
Integration into existing code
To integrate vector search capability, we added a small switch to the header that allows users to change the search mode. By default, we use keyword search (also known as “full-text search”). इसे इस तरह से दिखता है:
The changes on the backend side were not hard. We added a call to the text-to-vector conversion extension mentioned above. That’s what the code block looks like:
// Add vector search embeddings if we have a query
if ($search_query) {
if ($search !== 'keyword-search') {
$embeddings = result(TextEmbeddings::get($query));
$filters['embeddings'] = $embeddings;
}
if ($search === 'vector-search') {
$filters['vector_search_only'] = true;
}
}
The Hybrid Search, which combines semantic search and keyword search, can be implemented in various ways. In this case, we simply added a full-text filter to the vector search results. You can see the updated code here . Here is how it looks:
protected static function getSearch(string $table, string $query, array $filters): Search {
$client = static::client();
$Index = $client->index($table);
$vector_search_only = $filters['vector_search_only'] ?? false;
$query = $vector_search_only ? '' : $query;
$Query = new BoolQuery();
if (isset($filters['embeddings'])) {
$Query = new KnnQuery('embeddings', $filters['embeddings'], 1000);
}
if ($query) {
$QueryString = new QueryString($query);
$Query->must($QueryString);
}
return $Index->search($Query);
}
जैसा कि हम देख सकते हैं, डेमो में अर्थपूर्ण खोज को एकीकृत करना सीधा था। अगला, देखते हैं कि हम वेक्टर खोज के साथ क्या हासिल करते हैं।
हमारे डेमो में अर्थपूर्ण खोज के साथ जो हमें मिला उसकी तुलना
आइए कुछ सरल परिणामों की तुलना करें जो हमारे डेमो पृष्ठ में डिफ़ॉल्ट कीवर्ड खोज बनाम अर्थपूर्ण खोज के साथ बनाए गए हैं।
मिसाल के तौर पर, "परफॉर्मेंस सुधारें" के लिए एक कीवर्ड खोज करने पर हमें ऐसे परिणाम मिल सकते हैं:
वह वैध और पर्याप्त रूप से ठीक लगता है। लेकिन यह मूल वाक्यांश का केवल एक सटीक मिलान खोज रहा है। आइए इसे एक अर्थपूर्ण खोज के साथ देखते और तुलना करते हैं:
वह कुछ हद तक लचीला लगता है, हालांकि बिल्कुल सही नहीं है। हालाँकि, हम सवाल भी पूछ सकते हैं जैसे Manticore Search के प्रदर्शन को कैसे सुधारें? और अतिरिक्त प्रासंगिक परिणाम प्राप्त कर सकते हैं।
यहाँ, आप देख सकते हैं कि वेक्टर खोज और इसके पीछे के मशीन लर्निंग मॉडल के लिए धन्यवाद, प्रणाली सटीक रूप से समझ सकती है कि हम क्या ढूंढ रहे हैं और प्रासंगिक परिणाम प्रदान कर सकती है। हालाँकि, यदि आप कीवर्ड मोड में वही खोज करने का प्रयास करते हैं, तो आपको कोई परिणाम नहीं मिलेगा।
निष्कर्ष
हम Manticore की नई क्षमताओं के बारे में उत्साहित हैं! अब, वेक्टर खोज और कुछ बाहरी उपकरणों की मदद से, अर्थपूर्ण खोज सेट करना आसान है। अर्थपूर्ण खोज एक स्मार्ट तरीका हैQueries को बेहतर ढंग से समझने के लिए। यह केवल सटीक शब्दों की तलाश करने के बजाय, यह समझता है कि लोग किस चीज़ का पूछ रहे हैं। इसका मतलब है कि यह अधिक प्रासंगिक उत्तर खोज सकता है, विशेषकर जटिल या विस्तृत प्रश्नों के लिए।
खोजों को प्राकृतिक बातचीत के समान बनाने के द्वारा, अर्थपूर्ण खोज उस अंतर को बंद कर देती है जो हम कैसे बात करते हैं और डेटा कैसे संगठित है। यह सटीक और उपयोगी परिणाम प्रदान करता है जो ठीक वही है जिसकी किसी को तलाश है, Manticore के साथ खोज करने को बहुत बेहतर बनाता है।
हम अब Manticore में ऑटो-एंबेडिंग कार्यक्षमता लाने पर काम कर रहे हैं। इससे टेक्स्ट को वेक्टर में स्वचालित रूप से रूपांतरित करना संभव होगा, जिससे सब कुछ सरल और तेज हो जाएगा। हमारी प्रगति पर नज़र रखें यहां GitHub पर । इन सुधारों के साथ, Manticore के साथ खोज करना और भी बेहतर होता जा रहा है!