फैसटेड सर्च

फैसटेड सर्च

प्रकाशित: May 07, 2020
स्वत: अनुवाद: Faceted search

फैसटेड सर्च एक महत्वपूर्ण कार्यक्षमता है जो एक सूती में सुई खोजने और सभी प्रकार के अनुप्रयोगों के लिए बेहतर उपयोगकर्ता खोज अनुभव के लिए है। इस ट्यूटोरियल में हम यह जानेंगे कि फैसटेड सर्च क्या है और एक साधारण कैसे बनानी है।

फैसटेड सर्च आधुनिक खोज अनुप्रयोग का एक आवश्यक कार्य है जैसे कि ऑटोकम्प्लीट , स्पेल सुधार और खोज कुंजी शब्दों को हाइलाइट करना। विशेषकर ई-कॉमर्स उत्पादों में।

यह तब सहायता करता है जब हम बड़े आंकड़ों और एक-दूसरे से संबंधित विभिन्न गुणों के साथ काम कर रहे होते हैं, चाहे वह आकार हो, रंग, निर्माता या कुछ और। जब बड़े आंकड़ों को क्वेरी किया जाता है, तो खोज परिणाम अक्सर बड़ी संख्या में प्रविष्टियों को शामिल करते हैं जो उपयोगकर्ता की अपेक्षाओं के अनुरूप नहीं होती। फैसटेड सर्च उपयोगकर्ता को स्पष्ट रूप से उन आयामों को निर्दिष्ट करने की अनुमति देता है जो वे चाहते हैं कि उनके खोज परिणाम मिलें।

साधारण शब्दों में, यह खोजे गए आइटम के गुणों द्वारा खोज परिणामों का फ़िल्टर करने की क्षमता देता है।

चलो मान लेते हैं कि उपयोगकर्ता निकोलस केज की प्रमुख भूमिका वाली कुछ फिल्में खोजता है, इसलिए वह खोज बार में उसका नाम टाइप करता है। इससे विभिन्न वर्षों, विभिन्न निर्देशकों और विभिन्न IMDB के स्कोर और रेटिंग के साथ फिल्मों के साथ खोज परिणाम लौटेंगे।

यह ऐसा दिख सकता है:

हम देख सकते हैं कि उपयोगकर्ता के पास अपने पसंदीदा अभिनेता के साथ 34 विभिन्न फिल्में हैं, लेकिन वह इतनी बड़ी संख्या में फिल्मों में से देखने के लिए कैसे चुन सकता है?

यहां फैसटेड सर्च काम में आती है। हम उपयोगकर्ता को यह फिल्म खोजने की अनुमति दे सकते हैं जिसे वह देखना चाहता है, उसे “वर्ष”, “रेटिंग”, “निर्देशक का नाम” और “IMDB स्कोर” जैसे अतिरिक्त पैरामीटर चुनने की क्षमता देकर।

यह फैसटेड सर्च परिणामों की तरह दिखेगा:

फैसटेड सर्च के साथ हम यह निर्धारित करने की अनुमति देते हैं कि उपयोगकर्ता वास्तव में क्या चाहता है। फ़ैसट्स का चयन करके उपयोगकर्ता अधिक प्रासंगिक खोज परिणाम प्राप्त करते हैं, जिससे खोज बेहतर, अधिक सुविधाजनक और उपयोगकर्ता अनुभव और व्यापार लक्ष्यों के संदर्भ में उपयोगी होती है।

तो चलो देखते हैं कि फैसटेड सर्च कैसे काम करता है और आप इसे अपने खोज अनुप्रयोग के लिए स्वयं कैसे बना सकते हैं।

फिल्मों के फैसटेड सर्च का कार्यान्वयन

Manticore Search में एक अनुकूलन है जो मूल क्वेरी के परिणाम सेट को बनाए रखता है और प्रत्येक फैट की गणना के लिए पुन: उपयोग करता है। चूंकि समाहारण पहले से गणना की गई दस्तावेजों के उपसमुच्चय पर लागू होते हैं, वे तेज होते हैं और कुल निष्पादन समय कई मामलों में प्रारंभिक क्वेरी से केवल कुछ हद तक बड़ा हो सकता है। किसी भी क्वेरी में फैट्स जोड़े जा सकते हैं और फैट किसी भी विशेषता या अभिव्यक्ति हो सकती है। एक फैट परिणाम में फैट मानों के साथ फैट गिनतियां शामिल होती हैं। फैट्स उपलब्ध हैं SQL SELECT बयान का उपयोग करके उन्हें क्वेरी के अंत में निम्नलिखित प्रारूप में घोषित करके:

FACET {expr_list} [BY {expr_list}] [ORDER BY {expr | FACET()} {ASC | DESC}] [LIMIT [offset,] count]

बिल्कुल, आप एक ही मल्टी-क्वेरी में जितनी चाहें क्वेरी भेज सकते हैं, लेकिन यदि आप एक अधिक सुरुचिपूर्ण समाधान की तलाश कर रहे हैं, तो FACET क्लॉज़ है।

अब हम मूवी फैट्स के साथ कई क्वेरी चलाने जा रहे हैं जैसे:

Title_year
Content_rating
Director_name

और IMDB स्कोर के लिए पूर्णांक सीमा के भीतर मान प्राप्त करने के लिए interess का उपयोग करेंगे।

आइए हम ऑटोकम्प्लीट पाठ्यक्रम से ‘मूवीज’ इंडेक्स पर कुछ सरल फैट्स का प्रयास करें और विभिन्न गुणों पर सरल फैट्स करें। उदाहरण के लिए, हम ‘निर्देशक का नाम’ विशेषताओं में ‘रोबर्ट डी नीरो’ का चयन करते हैं।

SELECT * FROM movies WHERE MATCH('robert de niro') LIMIT 10 FACET title_year FACET content_rating FACET director_name;

यह एकाधिक परिणाम सेट देता है, जहां पहला हमारे मुख्य क्वेरी से है और बाकी फैट्स हैं। प्रत्येक फैट परिणाम में विशेषता मान और समूह गिनती शामिल होती है।

+------------+----------+
| title_year | count(*) |
+------------+----------+
|       1987 |        1 |
|       1991 |        1 |
|       2005 |        1 |
|       1997 |        3 |
|       1974 |        1 |
|       2001 |        2 |
|       2002 |        2 |
|       1999 |        2 |
|       1985 |        1 |
|       1995 |        1 |
|       2016 |        2 |
|       2009 |        1 |
|       2004 |        4 |
|       1990 |        1 |
|       2013 |        3 |
|       2015 |        3 |
|       2011 |        2 |
|       2010 |        3 |
|       1996 |        3 |
|       1973 |        1 |
+------------+----------+
20 rows in set (0.10 sec)
+----------------+----------+
| content_rating | count(*) |
+----------------+----------+
| R              |       37 |
| PG-13          |       12 |
| PG             |        4 |
+----------------+----------+
3 rows in set (0.10 sec)
+----------------------+----------+
| director_name        | count(*) |
+----------------------+----------+
| Brian De Palma       |        1 |
| Martin Scorsese      |        7 |
| John Polson          |        1 |
| Quentin Tarantino    |        1 |
| Francis Ford Coppola |        1 |
| John Herzfeld        |        1 |
| Harold Ramis         |        2 |
| Terry Gilliam        |        1 |
| Michael Caton-Jones  |        1 |
| James Mangold        |        1 |
| Dan Mazer            |        1 |
| Kirk Jones           |        1 |
| Joel Schumacher      |        1 |
| Nick Hamm            |        1 |
| Peter Segal          |        1 |
| Jonathan Jakubowicz  |        1 |
| Scott Mann           |        1 |
| David O. Russell     |        2 |
| Gary McKendry        |        1 |
| Jon Turteltaub       |        1 |
+----------------------+----------+
20 rows in set (0.10 sec)

डिफ़ॉल्ट रूप से FACETS के परिणाम सॉर्ट नहीं होते हैं और 20 पंक्तियों तक सीमित होते हैं। प्रत्येक FACET की अपनी सीमा क्लॉज हो सकती है। यह इस तरह किया जा सकता है:

SELECT * FROM movies WHERE MATCH('robert de niro') LIMIT 10 FACET title_year LIMIT 5 FACET content_rating LIMIT 1 FACET director_name LIMIT 100;
+------------+----------+
| title_year | count(*) |
+------------+----------+
|       1987 |        1 |
|       1991 |        1 |
|       2005 |        1 |
|       1997 |        3 |
|       1974 |        1 |
+------------+----------+
5 rows in set (0.19 sec)
+----------------+----------+
| content_rating | count(*) |
+----------------+----------+
| R              |       37 |
+----------------+----------+
1 row in set (0.19 sec)
+----------------------+----------+
| director_name        | count(*) |
+----------------------+----------+
| Brian De Palma       |        1 |
| Martin Scorsese      |        7 |
| John Polson          |        1 |
| Quentin Tarantino    |        1 |
| Francis Ford Coppola |        1 |
 .................................
| Tony Scott           |        1 |
| Nancy Meyers         |        1 |
| Frank Oz             |        1 |
| Neil Jordan          |        1 |
+----------------------+----------+
42 rows in set (0.19 sec)

जैसा कि आप देख सकते हैं, परिणाम डिफ़ॉल्ट रूप से सॉर्ट नहीं होते हैं। प्रत्येक FACET का अपना सॉर्टिंग नियम हो सकता है, उदाहरण के लिए हम COUNT(*) का उपयोग करके गिनती के आधार पर समूहों को सॉर्ट कर सकते हैं:

SELECT * FROM movies WHERE MATCH('robert de niro') LIMIT 10 FACET title_year ORDER BY COUNT(*) DESC;
+------------+----------+
| title_year | count(*) |
+------------+----------+
|       2004 |        4 |
|       2013 |        3 |
|       2015 |        3 |
|       1997 |        3 |
|       2010 |        3 |
|       1996 |        3 |
|       2000 |        3 |
|       2001 |        2 |
|       2002 |        2 |
|       1999 |        2 |
|       2016 |        2 |
|       2011 |        2 |
|       2012 |        2 |
|       2008 |        2 |
|       1985 |        1 |
|       1991 |        1 |
|       1995 |        1 |
|       2009 |        1 |
|       1990 |        1 |
|       2005 |        1 |
+------------+----------+
20 rows in set (0.09 sec)

या हम किसी विशेषता के आधार पर सॉर्ट कर सकते हैं, जैसे title_year:

SELECT * FROM movies WHERE MATCH('robert de niro') LIMIT 10 FACET title_year ORDER BY title_year DESC;
+------------+----------+
| title_year | count(*) |
+------------+----------+
|       2016 |        2 |
|       2015 |        3 |
|       2013 |        3 |
|       2012 |        2 |
|       2011 |        2 |
|       2010 |        3 |
|       2009 |        1 |
|       2008 |        2 |
|       2005 |        1 |
|       2004 |        4 |
|       2002 |        2 |
|       2001 |        2 |
|       2000 |        3 |
|       1999 |        2 |
|       1998 |        1 |
|       1997 |        3 |
|       1996 |        3 |
|       1995 |        1 |
|       1991 |        1 |
|       1990 |        1 |
+------------+----------+
20 rows in set (0.09 sec)

सबसे सरल उदाहरणों में हम FACET attr_name का उपयोग करते हैं और परिणाम सेट में attr_name और count कॉलम शामिल होंगे।

लेकिन एक FACET कई विशेषताओं से बनाया जा सकता है:

SELECT * FROM movies WHERE MATCH('robert de niro') LIMIT 10 FACET director_facebook_likes,director_name BY director_name ORDER BY director_facebook_likes DESC;
+-------------------------+---------------------+----------+
| director_facebook_likes | director_name       | count(*) |
+-------------------------+---------------------+----------+
|                   17000 | Martin Scorsese     |        7 |
|                   16000 | Quentin Tarantino   |        1 |
|                   12000 | Tony Scott          |        1 |
|                   11000 | Harold Ramis        |        2 |
|                     737 | David O. Russell    |        2 |
|                     541 | Joel Schumacher     |        1 |
|                     517 | Michael Cimino      |        1 |
|                     446 | James Mangold       |        1 |
|                     287 | John Frankenheimer  |        1 |
|                     278 | Nancy Meyers        |        1 |
|                     277 | Neil Jordan         |        1 |
|                     272 | Barry Levinson      |        3 |
|                     226 | Jon Turteltaub      |        1 |
|                     116 | Jay Roach           |        2 |
|                     105 | Michael Caton-Jones |        1 |
|                     102 | Martin Brest        |        1 |
|                      89 | Rodrigo Cortés      |        1 |
|                      88 | Peter Segal         |        1 |
|                      88 | George Tillman Jr.  |        1 |
|                      80 | Paul Weitz          |        1 |
+-------------------------+---------------------+----------+
20 rows in set (0.01 sec)

कुछ स्थितियों में, वास्तविक मूल्यों पर FACETING वह नहीं है जो हम चाहते हैं। सबसे आम उदाहरण उत्पाद की कीमतें हैं, क्योंकि हमारे पास मूल्यों की एक विस्तृत श्रृंखला हो सकती है। वास्तविक मूल्यों का FACET प्राप्त करने के बजाय, हम इसके बजाय रेंज की एक सूची प्राप्त करना चाहते हैं। यह INTERVAL() फ़ंक्शन के साथ आसानी से प्राप्त किया जा सकता है।

हमारे उदाहरण में, हम imdb_score का उपयोग करते हैं क्योंकि यह एक फ्लोट मान है जिसे हम स्पष्ट रूप से समूहबद्ध नहीं करना चाहते हैं, इसके बजाय हम केवल पूर्णांक मानों के बीच रेंज द्वारा समूहबद्ध कर रहे हैं:

SELECT * FROM movies WHERE MATCH('robert de niro') LIMIT 100 FACET title_year LIMIT 100 FACET content_rating LIMIT 100 FACET director_name LIMIT 100;
Empty set (0.09 sec)
+------------+----------+
| title_year | count(*) |
+------------+----------+
|       1987 |        1 |
|       1991 |        1 |
|       2005 |        1 |
|       1997 |        3 |
|       1974 |        1 |
|       2001 |        2 |
|       2002 |        2 |
|       1999 |        2 |
|       1985 |        1 |
|       1995 |        1 |
|       2016 |        2 |
|       2009 |        1 |
|       2004 |        4 |
|       1990 |        1 |
|       2013 |        3 |
|       2015 |        3 |
|       2011 |        2 |
|       2010 |        3 |
|       1996 |        3 |
|       1973 |        1 |
|       2000 |        3 |
|       1988 |        1 |
|       1977 |        1 |
|       1984 |        1 |
|       1980 |        1 |
|       2012 |        2 |
|       2008 |        2 |
|       1998 |        1 |
|       1976 |        1 |
|       1978 |        1 |
|       1989 |        1 |
+------------+----------+
31 rows in set (0.07 sec)
+----------------+----------+
| content_rating | count(*) |
+----------------+----------+
| R              |       37 |
| PG-13          |       12 |
| PG             |        4 |
+----------------+----------+
3 rows in set (0.08 sec)
+----------------------+----------+
| director_name        | count(*) |
+----------------------+----------+
| Brian De Palma       |        1 |
| Martin Scorsese      |        7 |
| John Polson          |        1 |
| Quentin Tarantino    |        1 |
| Francis Ford Coppola |        1 |
| John Herzfeld        |        1 |
| Harold Ramis         |        2 |
| Terry Gilliam        |        1 |
| Michael Caton-Jones  |        1 |
| James Mangold        |        1 |
| Dan Mazer            |        1 |
| Kirk Jones           |        1 |
| Joel Schumacher      |        1 |
| Nick Hamm            |        1 |
| Peter Segal          |        1 |
| Jonathan Jakubowicz  |        1 |
| Scott Mann           |        1 |
| David O. Russell     |        2 |
| Gary McKendry        |        1 |
| Jon Turteltaub       |        1 |
| Paul Weitz           |        1 |
| Ethan Maniquis       |        1 |
| Jerry Zaks           |        1 |
| Jay Roach            |        2 |
| George Tillman Jr.   |        1 |
| Martin Brest         |        1 |
| Garry Marshall       |        1 |
| Sergio Leone         |        1 |
| Rodrigo Cortés       |        1 |
| Jon Avnet            |        1 |
| John Frankenheimer   |        1 |
| Bibo Bergeron        |        1 |
| Barry Levinson       |        3 |
| John Curran          |        1 |
| Des McAnuff          |        1 |
| Justin Zackham       |        1 |
| Mary McGuckian       |        1 |
| Michael Cimino       |        1 |
| Tony Scott           |        1 |
| Nancy Meyers         |        1 |
| Frank Oz             |        1 |
| Neil Jordan          |        1 |
+----------------------+----------+
42 rows in set (0.08 sec)

Interactive Course

You can learn more about faceted search if you take our free “Manticore Faceting” interactive course which features a command line and web panel for easier learning.