ఫిల్టర్ ఎక్స్ట్రాక్షన్: రెగెక్స్ వర్డ్ బౌండరీ మ్యాచింగ్

ఈ వ్యాసం వర్డ్ బౌండరీ రెగెక్స్ మ్యాచింగ్ ఉపయోగించి ఫ్రేజ్-టు-ఫిల్టర్ మ్యాపింగ్స్ వ్యతిరేకంగా ప్రకృతి భాషా శోధన ప్రశ్నల నుండి నిర్మాణాత్మక ఉత్పత్తి ఫిల్టర్లను మేము ఎలా సేకరిస్తామో వివరిస్తుంది.

సమస్య: ప్రకృతి భాష నుండి నిర్మాణాత్మక ఫిల్టర్లకు

ఒక వినియోగదారు "16gb ram తో mini pc" కోసం శోధించినప్పుడు, మనం సేకరించాలి:

{
  "Form Factor": "Mini PC",
  "Main Memory": "16"
}

ఈ నిర్మాణాత్మక ఫిల్టర్లు ఇవి చేయడానికి అనుమతిస్తాయి:

• ఉత్పత్తి ఫిల్టరింగ్: సరిపోలే ఉత్పత్తులను మాత్రమే చూపించు

• ఫేసెటెడ్ నావిగేషన్: అందుబాటులో ఉన్న ఫిల్టర్ ఎంపికలను ప్రదర్శించు

• క్వెరీ పేజీ జనరేషన్: SEO-ఆప్టిమైజ్డ్ పేజీలను సృష్టించు

• సంబంధిత శోధనలు: ఇలాంటి ప్రశ్నలను కనుగొను

సవాల్ ఏమిటంటే, వినియోగదారులు ఒకే ఉద్దేశ్యాన్ని వ్యక్తీకరించే అన్ని మార్గాలను నిర్వహించడం.

అల్గోరిథం: వర్డ్ బౌండరీ రెగెక్స్ మ్యాచింగ్

స్టెప్ 1: ఫ్రేజ్ మ్యాపింగ్స్ లోడ్ చేయండి

మేము SEO పైప్లైన్ ద్వారా రూపొందించబడిన ఫ్రేజ్-టు-ఫిల్టర్ మ్యాపింగ్స్ లోడ్ చేస్తాము. ఈ మ్యాపింగ్స్ ఫ్రేజ్లను ఫిల్టర్ విలువలకు కనెక్ట్ చేస్తాయి, ఫ్రేజ్ నుండి సంబంధిత ఫిల్టర్ కీ మరియు విలువను చూడటానికి అనుమతిస్తాయి.

వేగవంతమైన లుకప్ కోసం మేము ఈ నిర్మాణాన్ని విలోమం చేస్తాము, కాబట్టి మనం ఫిల్టర్ కంటే ఫ్రేజ్ ద్వారా శోధించవచ్చు:

phrase_to_filter = {
    "16gb ram": ("Main Memory", "16"),
    "16 gb ram": ("Main Memory", "16"),
    "mini pc": ("Form Factor", "Mini PC"),
    "mini computer": ("Form Factor", "Mini PC")
}

స్టెప్ 2: క్వెరీని సాధారణీకరించండి

కేస్-ఇన్సెన్సిటివ్ మ్యాచింగ్ కోసం క్వెరీని లోయర్ కేస్కి మార్చండి.

స్టెప్ 3: వర్డ్ బౌండరీలతో ఫ్రేజ్లను మ్యాచ్ చేయండి

మ్యాపింగ్స్లోని ప్రతి ఫ్రేజ్ కోసం, రెగ్యులర్ ఎక్స్ప్రెషన్స్లో వర్డ్ బౌండరీ యాంకర్లను ఉపయోగించి అది క్వెరీలో కనిపిస్తుందో లేదో మేము తనిఖీ చేస్తాము.

\b యాంకర్లు మనం పూర్తి పదాలను మ్యాచ్ చేస్తామని నిర్ధారిస్తాయి, సబ్స్ట్రింగ్స్ కాదు: "mini pc" "ram తో mini pc"ని మ్యాచ్ చేస్తుంది కానీ "minipc" (స్పేస్ లేదు)ని మ్యాచ్ చేయదు, మరియు "16gb" "16gb ram"ని మ్యాచ్ చేస్తుంది కానీ "216gb" (పాక్షిక మ్యాచ్)ని మ్యాచ్ చేయదు.

స్టెప్ 4: అన్ని మ్యాచ్లను సేకరించండి

మేము అన్ని ఫ్రేజ్ల ద్వారా పునరావృతమవుతాము మరియు మ్యాచింగ్ ఫిల్టర్లను సేకరిస్తాము. "mini pc with 16gb ram" కోసం, ఇది {"Form Factor": "Mini PC", "Main Memory": "16"} వంటి ఫిల్టర్లను ఉత్పత్తి చేస్తుంది.

వర్డ్ బౌండరీలు ఎందుకు?

వర్డ్ బౌండరీలు తప్పుడు మ్యాచ్లను నిరోధిస్తాయి:

వర్డ్ బౌండరీలు లేకుండా:

• "i5" "i5000"ని మ్యాచ్ చేస్తుంది (తప్పు)

• "ram" "program"ని మ్యాచ్ చేస్తుంది (తప్పు)

• "pc" "pcie"ని మ్యాచ్ చేస్తుంది (తప్పు)

వర్డ్ బౌండరీలతో: "i5" "i5 processor"ని మ్యాచ్ చేస్తుంది ✅ కానీ "i5000"ని మ్యాచ్ చేయదు ❌; "ram" "16gb ram"ని మ్యాచ్ చేస్తుంది ✅ కానీ "program"ని మ్యాచ్ చేయదు ❌. \b యాంకర్ మనం పదాల అంచుల వద్ద మాత్రమే మ్యాచ్ అవుతామని నిర్ధారిస్తుంది.

బహుళ మ్యాచ్లను నిర్వహించడం

బహుళ ఫ్రేజ్లు ఒకే ఫిల్టర్ను మ్యాచ్ చేస్తే, చివరి మ్యాచ్ గెలుస్తుంది:

# Query: "mini pc small computer"
# Both "mini pc" and "small computer" map to "Form Factor:Mini PC"
# Result: {"Form Factor": "Mini PC"} (deduplicated)

బహుళ ఫ్రేజ్లు ఒకే ఫిల్టర్ కోసం విభిన్న విలువలను మ్యాచ్ చేస్తే, చివరి మ్యాచ్ గెలుస్తుంది:

# Query: "8gb 16gb ram"
# "8gb" → Main Memory:8
# "16gb" → Main Memory:16
# Result: {"Main Memory": "16"} (last match wins)

ప్రాక్టీస్లో, వినియోగదారులు విరుద్ధమైన విలువలను అరుదుగా నిర్దేశిస్తారు, కాబట్టి ఇది సమస్య కాదు.

ఫ్రేజ్ ప్రాధాన్యత

ఫ్రేజ్లు మ్యాపింగ్స్లో కనిపించే క్రమంలో మ్యాచ్ అవుతాయి. మ్యాపింగ్స్ సారూప్యత (అత్యధికం మొదట) మరియు తర్వాత పొడవు (చిన్నది మొదట) ప్రకారం క్రమబద్ధీకరించబడినందున, అధిక-నాణ్యత మ్యాచ్లు మొదట తనిఖీ చేయబడతాయి. అయినప్పటికీ, మనం అన్ని ఫ్రేజ్ల ద్వారా పునరావృతమవుతాము కాబట్టి, క్రమం తుది ఫలితాన్ని ప్రభావితం చేయదు—చివరి మ్యాచ్ గెలుస్తుంది.

పనితీరు ఆప్టిమైజేషన్

క్యాచింగ్

ఫ్రేజ్-టు-ఫిల్టర్ మ్యాపింగ్ ప్రారంభంలో ఒకసారి లోడ్ చేయబడుతుంది మరియు మెమరీలో క్యాచ్ చేయబడుతుంది, ప్రతి అభ్యర్థనపై పునరావృత డిస్క్ I/O ను నివారిస్తుంది.

వాల్కీ ఫాల్బ్యాక్

మేము మ్యాపింగ్స్ను మొదట వాల్కీ (రెడిస్ ఫోర్క్) నుండి లోడ్ చేయడానికి ప్రయత్నిస్తాము, JSON ఫైల్లకు ఫాల్బ్యాక్ చేస్తాము:

1. వేగవంతమైన ఇన్-మెమరీ లుకప్ కోసం వాల్కీని తనిఖీ చేయండి
2. వాల్కీ మిస్ అయితే JSON నుండి లోడ్ చేయండి
3. క్యాచ్ గడువుతో వాల్కీలో నిల్వ చేయండి

ఇది తదుపరి అభ్యర్థనల కోసం లేటెన్సీని తగ్గిస్తుంది.

రెగెక్స్ మ్యాచింగ్

పాటర్న్లు తప్పుడు పాక్షిక మ్యాచ్లు లేకుండా పూర్తి పదాలను సమర్థవంతంగా మ్యాచ్ చేయడానికి వర్డ్ బౌండరీ యాంకర్లతో re.search()ని ఉపయోగిస్తాయి.

శోధన సేవతో ఇంటిగ్రేషన్

ఫిల్టర్ ఎక్స్ట్రాక్షన్ ఒక API సేవా ఎండ్పాయింట్గా అమలు చేయబడుతుంది, ఇది శోధన ప్రశ్నలను అంగీకరిస్తుంది మరియు సేకరించబడిన ఫిల్టర్లను తిరిగి ఇస్తుంది.

సేవ:

1. ఇన్పుట్గా శోధన ప్రశ్నను అంగీకరిస్తుంది
2. ఫ్రేజ్-టు-ఫిల్టర్ మ్యాపింగ్స్ను మెమరీలోకి లోడ్ చేస్తుంది
3. వర్డ్ బౌండరీలతో ఫ్రేజ్లను సాధారణీకరించి మ్యాచ్ చేస్తుంది
4. నిర్మాణాత్మక ఫిల్టర్ కీ-విలువ జతలను తిరిగి ఇస్తుంది

ప్రధాన వెబ్ సర్వర్ వినియోగదారు ప్రశ్నల నుండి ఫిల్టర్లను సేకరించడానికి ఈ సేవను కాల్ చేస్తుంది:

filters = extract_filters_from_query("mini pc 16gb ram")
# Returns: {"Form Factor": "Mini PC", "Main Memory": "16"}

ఈ ఆందోళనల విభజన ఇవి అనుమతిస్తుంది:

• స్వతంత్ర స్కేలింగ్: ఫిల్టర్ ఎక్స్ట్రాక్షన్ వేరే సర్వర్లో రన్ చేయవచ్చు

• క్యాచింగ్ ఐసోలేషన్: సేవ దాని స్వంత మ్యాపింగ్ క్యాచ్ను నిర్వహిస్తుంది

• సేవ రీస్టార్ట్: సేవ ప్రధాన వెబ్ సర్వర్ను ప్రభావితం చేయకుండా స్వతంత్రంగా రీస్టార్ట్ చేయబడుతుంది

వివరాల కోసం శోధన సేవా నిర్మాణం చూడండి.

క్వెరీ లాగింగ్

ప్రతి ఫిల్టర్ ఎక్స్ట్రాక్షన్ SEO పైప్లైన్ వినియోగం కోసం లాగ్ చేయబడుతుంది. ఈ లాగ్లు కాలక్రమేణా కొత్త క్వెరీ నమూనాలను కనుగొనడానికి మరియు ఫ్రేజ్ మ్యాపింగ్లను మెరుగుపరచడానికి SEO పైప్లైన్లోకి తిరిగి ఫీడ్ అవుతాయి.

ఉపయోగ కేసులు

క్వెరీ పేజీలు (/q/)

క్వెరీ పేజీలు URL స్లగ్ నుండి ఫిల్టర్లను సేకరించి, ఏ ఉత్పత్తులను ప్రద