Redis Sorted Sets के साथ इंटेलिजेंट ऑटोकंप्लीट बनाएं

क्या आपने कभी ध्यान दिया है कि खोज बॉक्स टाइप करते ही शब्दों का सुझाव कैसे देते हैं? पता चला, इनमें से अधिकांश सुझाव सरल वर्णमाला क्रम में दिखाई देते हैं और सुपर मददगार नहीं होते।

लेकिन क्या होगा अगर एक खोज बॉक्स समय के साथ स्मार्ट हो जाए?

यह सीखना कि लोग वास्तव में क्या क्लिक करते हैं और सबसे लोकप्रिय परिणाम पहले दिखाना?

यही हम बनाएंगे:

हम देखेंगे कि कैसे Redis Sorted Sets एक इंटेलिजेंट ऑटोकंप्लीट सिस्टम को शक्ति दे सकते हैं जो उपयोगकर्ता व्यवहार से सीखता है और समय के साथ अधिक सटीक हो जाता है (लोकप्रिय परिणाम पहले दिखाता है)।

स्मार्ट ऑटोकंप्लीट सिस्टम का विचार

एक बुनियादी खोज बॉक्स यह तय करने के लिए प्रीफिक्स मिलान नामक एक विधि का उपयोग करेगा कि कौन से परिणाम पहले दिखाने हैं।

जैसे-जैसे आप टाइप करते हैं, यह A-Z क्रम में मिलान दिखाता है। यह वास्तव में परवाह नहीं करता कि लोग किन परिणामों पर सबसे अधिक क्लिक करते हैं।

हम इसे स्मार्ट बनाने जा रहे हैं। हमारा खोज बॉक्स लोगों की पसंद से सीखेगा। जब लोग खोज परिणाम पर क्लिक करते हैं, तो हम अगली बार उस परिणाम को पहले दिखाएंगे।

इसका मतलब है कि हमारा खोज समय के साथ बेहतर और अधिक सहायक होता जाता है, स्वचालित रूप से सबसे लोकप्रिय सुझावों को शीर्ष पर दिखाकर।

यह खोज एप्लिकेशन के लिए क्यों मायने रखता है

एक मूवी खोज एप्लिकेशन पर विचार करें: जब उपयोगकर्ता "int" टाइप करते हैं। वे देख सकते हैं:

• "Interceptor"
• "Interstate 60"
• "Interstellar"

"पारंपरिक" सिस्टम में, ये वर्णमाला क्रम में दिखाई देंगे। हालांकि, यदि उपयोगकर्ता लगातार "Interstellar" पर क्लिक करते हैं, तो हम इसे ऑटोकंप्लीट सुझावों के शीर्ष पर प्रोमोट करना चाहेंगे।

यह स्मार्ट रैंकिंग सिस्टम वास्तव में अच्छी तरह से काम करता है:

• स्ट्रीमिंग सेवाएं जैसे Netflix या YouTube यह दिखाने के लिए कि लोग सबसे अधिक क्या देख रहे हैं
• ऑनलाइन स्टोर खोज करते समय पहले लोकप्रिय उत्पाद दिखाने के लिए
• सहायता केंद्र सबसे सामान्य प्रश्न दिखाने के लिए जो लोग पूछते हैं
• खोज वाली कोई भी वेबसाइट यह दिखाने के लिए कि ज्यादातर लोग पहले क्या क्लिक करते हैं

Redis Sorted Sets को समझना

आइए समझें कि Redis Sorted Sets ऑटोकंप्लीट सिस्टम बनाने के लिए क्यों महान हैं।

एक Redis Sorted Set एक स्मार्ट सूची की तरह है जहां:

• प्रत्येक आइटम अद्वितीय है (एक सेट की तरह)
• प्रत्येक आइटम का एक स्कोर है (क्रम के लिए)
• आइटम को उनके स्कोर द्वारा जल्दी से क्रमबद्ध किया जा सकता है

हमारे ऑटोकंप्लीट सिस्टम के लिए, हम दो सॉर्टेड सेट्स का उपयोग करेंगे:

1. टेक्स्ट प्रीफिक्स मिलान के लिए एक (उदाहरण: "int" "interstellar" से मेल खाता है)
2. प्रत्येक सुझाव की लोकप्रियता को ट्रैक करने के लिए एक और

ये दो सेट उपयोगकर्ताओं के टाइप करते समय सबसे प्रासंगिक परिणाम सुझाने के लिए मिलकर काम करते हैं।

फाउंडेशन: वर्णमाला क्रम

Redis Sorted Sets वर्णमाला क्रम को बनाए रखते हैं जब सभी सदस्यों का समान स्कोर होता है। यह खोज सुझाव बनाने के लिए एकदम सही है क्योंकि यह हमें अनुमति देता है:

1. खोज योग्य शब्दों के सभी प्रीफिक्स को एक ही डेटा संरचना में स्टोर करें
2. किसी भी प्रीफिक्स की प्रारंभिक स्थिति खोजने के लिए ZRANK का उपयोग करें O(log N) समय में
3. उस स्थिति से शुरू होने वाले सभी मिलान को कुशलतापूर्वक पुनः प्राप्त करने के लिए ZSCAN का उपयोग करें
4. प्रत्येक मिलान का लोकप्रियता स्कोर प्राप्त करने के लिए ZMSCORE का उपयोग करें
5. प्रत्येक मिलान का लोकप्रियता स्कोर बढ़ाने के लिए ZINCRBY का उपयोग करें

आइए एक सरल उदाहरण देखें। जब हम "INTERSTELLAR" मूवी को अपने खोज सिस्टम में जोड़ते हैं, तो हम इसे इस तरह तोड़ते हैं:

• स्कोर: 0, सदस्य: "I"
• स्कोर: 0, सदस्य: "IN"
• स्कोर: 0, सदस्य: "INT"
• स्कोर: 0, सदस्य: "INTE"
• स्कोर: 0, सदस्य: "INTER"
• स्कोर: 0, सदस्य: "INTERSTELLAR$Interstellar" (डिस्प्ले फॉर्मेट के साथ पूर्ण प्रविष्टि)

देखें कि हम खोज संस्करण को डिस्प्ले संस्करण से विभाजित करने के लिए $ का उपयोग कैसे करते हैं? इस तरह, उपयोगकर्ता अपरकेस या लोअरकेस अक्षरों की चिंता किए बिना खोज सकते हैं, लेकिन हम अभी भी मूवी शीर्षक को ठीक वैसे ही दिखाते हैं जैसे इसे दिखना चाहिए।

हम डेटा कैसे स्टोर करते हैं

हम अपने ऑटोकंप्लीट को काम करने के लिए दो Redis सॉर्टेड सेट्स का उपयोग करते हैं:

1. मूवी शीर्षक सूची

आइए movies नामक एक सॉर्टेड सेट को ट्रैक करें। इसे एक डिक्शनरी की तरह समझें जो हमें मूवीज को जल्दी खोजने में मदद करती है। जब कोई "int" टाइप करता है, तो हम तुरंत उन सभी मूवीज को ढूंढ सकते हैं जो उन अक्षरों से शुरू होती हैं।

"int" की पहली घटना ZRANK द्वारा मिल जाएगी और फिर उस स्थिति से शुरू होकर वाइल्ड कार्ड INT*$* के साथ पूर्ण मूवी नाम प्राप्त किए जाएंगे।

2. लोकप्रिय मूवी सूची

आइए movie-popularity नामक एक सॉर्टेड सेट को भी ट्रैक करें। यह हमारी "ट्रेंडिंग मूवीज" सूची है।

हर बार जब कोई खोज परिणामों में एक मूवी पर क्लिक करता है, तो वह मूवी ZINCRBY का उपयोग करके अपने स्कोर को बढ़ाकर अधिक लोकप्रिय हो जाती है। सबसे अधिक क्लिक की गई मूवीज भविष्य की खोजों में पहले दिखाई देती हैं।

यह वैसे ही है जैसे Netflix आपको ट्रेंडिंग मूवीज दिखाता है - जितने अधिक लोग कुछ देखते हैं, उतना ही यह सिफारिशों में ऊपर दिखाई देता है।

हमारे मामले में, INT*$* के लिए सटीक मिलान ढूंढने के बाद, हम movie-popularity पर उनके स्कोर की जांच करने के लिए जाते हैं ताकि सबसे लोकप्रिय मिल सकें।

एल्गोरिदमिक प्रवाह

graph TD A[User types 'int'] --> B[ZRANK: Find lexicographic position of 'INT']
B --> C[ZSCAN: Retrieve matches starting from position (movies set)]
C --> D[Filter: Extract complete terms containing '$']
D --> E[ZMSCORE: Get popularity scores for all matches (movie-popularity set)]
E --> F[Rank: Return highest-scored suggestion]
G[User selects suggestion] --> H[ZINCRBY: Increment popularity score]
H --> I[Future searches: Higher scored items rank first]
I --> A

जैसे-जैसे उपयोगकर्ता खोजते हैं और सुझावों पर क्लिक करते हैं, सिस्टम सीखता है और सुधारता है। जितने अधिक लोग इसका उपयोग करते हैं, यह सबसे प्रासंगिक सुझावों को पहले दिखाने में उतना ही बेहतर होता जाता है।

आइए ऑटोकंप्लीट सिस्टम बनाएं

आइए देखें कि हम इस ऑटोकंप्लीट सिस्टम को चरण दर चरण कैसे बनाते हैं। हम इसे सुपर सरल रखेंगे!

चरण 1: मूवी शीर्षक को Redis में जोड़ना

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

import { Redis } from "@upstash/redis";
const redis = new Redis({
  url: process.env.UPSTASH_REDIS_URL!,
  token: process.env.UPSTASH_REDIS_TOKEN!,
});
// उदाहरण: शीर्षकों की आपकी सूची
const titles = [
  "Interceptor",
  "Interstate 60",
  "Interstellar",
  // ... अधिक शीर्षक
];
async function populateAutocomplete() {
  // 'movies' सॉर्टेड सेट में प्रीफिक्स और पूर्ण शीर्षक डालें
  for (const title of titles) {
    let term = title.toUpperCase();
    let terms = [];
    for (let i = 1; i < term.length; i++) {
      terms.push({ score: 0, member: term.substring(0, i) });
    }
    terms.push({ score: 0, member: term });
    terms.push({ score: 0, member: term + "$" + title });
    await redis.zadd("movies", ...terms);
  }
  // लोकप्रियता ट्रैकिंग के लिए 'movie-popularity' सॉर्टेड सेट में सभी शीर्षक डालें
  await redis.zadd(
    "movie-popularity",
    ...titles.map((title) => ({ score: 0, member: title.toUpperCase(), })),
  );
}
populateAutocomplete();

आइए देखें कि उपरोक्त कोड क्या करता है:

1. प्रत्येक मूवी शीर्षक के लिए, हम स्टोर करते हैं:

   • सभी संभावित आंशिक मिलान (जैसे "INT", "INTE", "INTER" "Interstellar" के लिए)
   • पूर्ण शीर्षक स्वयं
   • डिस्प्ले के लिए एक फॉर्मेटेड संस्करण

2. हम एक अलग सूची भी बनाते हैं जो प्रत्येक मूवी की लोकप्रियता को ट्रैक करती है, जो शून्य व्यूज से शुरू होती है

यह हमें उपयोगकर्ताओं के टाइप करते ही स्मार्ट सुझाव दिखाने और उनके क्लिक से सीखने के लिए आवश्यक सब कुछ देता है।

चरण 2: सर्वोत्तम मिलान ढूंढना

अब, हम देखेंगे कि हम मिलान ढूंढने के लिए इन मूवी शीर्षकों के माध्यम से कैसे खोज करते हैं। हमारा matchQuery फ़ंक्शन सभी भारी काम करता है:

export const matchQuery = async (query: string): Promise => {
  const upperQuery = query.toUpperCase();
  // चरण 1: वर्णमाला क्रम का उपयोग करके प्रारंभिक स्थिति खोजें
  let rank = await redis.zrank("movies", upperQuery);
  if (rank === null) return null;
  // चरण 2: उस स्थिति से मिलान के लिए कुशलतापूर्वक स्कैन करें
  const scanResult = await redis.zscan("movies", rank, {
    match: `${upperQuery}*$*`,
    count: 1000,
  });
  // चरण 3: पूर्ण प्रविष्टियां निकालें और उनके लोकप्रियता स्कोर प्राप्त करें
  const completeTitles = scanResult[1].filter(
    (el, idx) => idx % 2 === 0 && el.includes("$"),
  );
  const baseNames = completeTitles.map((title) => title.split("$")[0]);
  const scores = await redis.zmscore("movie-popularity", baseNames);
  // चरण 4: उच्चतम-स्कोर (सबसे लोकप्रिय) मिलान लौटाएं
  const maxScore = Math.max(...scores);
  const bestMatchIndex = scores.indexOf(maxScore);
  return completeTitles[bestMatchIndex].split("$")[1];
};

उपयोगकर्ता विकल्पों से सीखना

जब कोई मूवी शीर्षक चुनता है, तो हम उसके स्कोर में 1 पॉइंट जोड़ते हैं। अधिक पॉइंट्स वाली मूवीज सुझाव सूची में ऊपर दिखाई देती हैं। यह इतना सरल है!

सिस्टम समय के साथ स्मार्ट होता जाता है कि लोग वास्तव में क्या चुनते हैं उसका ट्रैक रखकर।

const onSubmit = async (title: string) => {
  // यहां सबमिट लॉजिक संभालें
  await redis.zincrby("movie-popularity", 1, title.toUpperCase());
};

यह कितना तेज़ है?

आइए देखें कि प्रत्येक ऑपरेशन में लगने वाले समय को तोड़कर यह समाधान कितना तेज़ है:

• ZRANK: O(log N) - लॉगरिदमिक लुकअप समय
• ZSCAN: O(log N + M) - जहां M लौटाए गए तत्वों की संख्या है
• ZMSCORE: O(N) - जहां N मिलान परिणामों की संख्या है, कुल डेटासेट आकार नहीं
• ZINCRBY: O(log N) - लॉगरिदमिक जटिलता के साथ एटॉमिक इंक्रीमेंट

जैसे-जैसे हम अधिक मूवी शीर्षक जोड़ते हैं, प्रदर्शन सुसंगत रहता है।

निष्कर्ष: हमने मिलकर क्या बनाया

आपने अभी सीखा है कि बिना किसी AI के समय के साथ बेहतर होने वाला एक स्मार्ट खोज बॉक्स कैसे बनाया जाए!

हमारा ऑटोकंप्लीट लोगों की पसंद से सीखता है और बेहतर सुझाव दिखाने के लिए उस जानकारी का उपयोग करता है।

यह तेज़, सरल है, और जितने अधिक लोग इसका उपयोग करते हैं, उतना ही अधिक सहायक होता जाता है।

Redis ऑप्टिमाइज़ेशन रणनीतियों के बारे में बात करना चाहते हैं या अपने स्वयं के कार्यान्वयन साझा करना चाहते हैं? Discord पर हमसे जुड़ें!