વાક્ય-થી-ફિલ્ટર મેપિંગ: ઉત્પાદન ફિલ્ટર્સ માટે સિમેન્ટિક શોધ

આ લેખ સમજાવે છે કે આપણે કેવી રીતે વાક્ય-થી-ફિલ્ટર મેપિંગ બનાવીએ છીએ અને વિસ્તારીએ છીએ જે આપણી ફિલ્ટર નિષ્કર્ષણ સિસ્ટમને શક્તિ આપે છે. આ મેપિંગ શોધ ક્વેરીઓમાંથી કુદરતી ભાષાના વાક્યોને સંરચિત ઉત્પાદન ફિલ્ટર્સ સાથે જોડે છે.

સમસ્યા: કુદરતી ભાષામાંથી ફિલ્ટર્સ નિષ્કર્ષિત કરવા

જ્યારે વપરાશકર્તાઓ "mini pc with 16gb ram" માટે શોધ કરે છે, ત્યારે આપણે નિષ્કર્ષિત કરવાની જરૂર છે:

  • ફોર્મ ફેક્ટર: મિની પીસી

  • મુખ્ય મેમરી: 16

પરંતુ વપરાશકર્તાઓ સમાન ઉદ્દેશ ઘણી રીતે વ્યક્ત કરે છે:

  • "16gb ram mini pc"

  • "mini computer 16 gb memory"

  • "small pc 16gb"

  • "compact desktop with 16 gigs"

આપણને એક સિસ્ટમની જરૂર છે જે આ બધી વાક્ય વિવિધતાઓને યોગ્ય ફિલ્ટર મૂલ્યો સાથે મેપ કરે.

બે-પગલાં પ્રક્રિયા

આપણે બે પગલાંમાં વાક્ય મેપિંગ બનાવીએ છીએ:

  1. પગલું 3a: ક્રમચય અને ફીચર-વિશિષ્ટ નિયમોનો ઉપયોગ કરીને ઉત્પાદન ફીચર્સમાંથી આધાર વાક્યો બનાવો
  2. પગલું 4: એમ્બેડિંગ્સ નો ઉપયોગ કરીને સિમેન્ટિક સમાનતા સાથે વિસ્તૃત કરો

આ હાઇબ્રિડ અભિગમ નિયમ-આધારિત ચોકસાઈને સિમેન્ટિક લવચીકતા સાથે જોડે છે.

પગલું 3a: આધાર વાક્ય નિર્માણ

ફીચર મેટાડેટા

દરેક ઉત્પાદન ફીચરમાં ફીચર સિક્વન્સમાં મેટાડેટા હોય છે:

  • હેડિંગ: શ્રેણીનું નામ (દા.ત., પ્રોસેસર ફીચર્સ માટે "પ્રોસેસિંગ")

  • એકમ: માપન એકમ (દા.ત., મેમરી માટે "GB", આવર્તન માટે "GHz")

આ મેટાડેટા વાક્ય નિર્માણને માર્ગદર્શન આપે છે.

ક્રમચય-આધારિત નિર્માણ

દરેક ફીચર મૂલ્ય માટે, આપણે આના તમામ ક્રમચય બનાવીએ છીએ:

  • હેડિંગ: "પ્રોસેસર"

  • ફીચર કી: "સિરીઝ"

  • મૂલ્ય: "i5"

  • એકમ: (સિરીઝ માટે કોઈ નહીં)

આ ઉત્પન્ન કરે છે:

  • "processor series i5"

  • "series processor i5"

  • "i5 processor series"

  • "i5 series processor"

  • "processor i5"

  • "series i5"

  • "i5"

બધા ક્રમચયો સુનિશ્ચિત કરે છે કે આપણે શબ્દ ક્રમને ધ્યાનમાં લીધા વિના ક્વેરીઓ સાથે મેળ કરીએ.

મૂલ્ય + એકમ સંયોજનો

એકમો ધરાવતા ફીચર્સ (મેમરી, સ્ટોરેજ, આવર્તન) માટે, આપણે સ્પેસ સાથે અને સ્પેસ વિના બંને પ્રકારો બનાવીએ છીએ:

  • "16 gb" (સ્પેસ સાથે)

  • "16gb" (સ્પેસ વિના)

આ અન્ય ઘટકો સાથે જોડાય છે:

  • "16gb ram"

  • "ram 16gb"

  • "processor 16gb"

પોર્ટ પ્રત્યય નિયમો

કનેક્ટિવિટી ફીચર્સ (USB, HDMI, DisplayPort) માટે, આપણે પોર્ટ પ્રત્યયો ઉમેરીએ છીએ:

  • "usb port"

  • "usb ports"

  • "2 usb ports"

  • "hdmi port"

આ "mini pc with 2 hdmi ports" જેવી ક્વેરીઓ સાથે મેળ ખાય છે.

ફીચર-વિશિષ્ટ નિયમો

દરેક ફીચર પ્રકારમાં કસ્ટમ વાક્ય નિર્માણ હોય છે:

પ્રોસેસર સિરીઝ (i3, i5, N-series):

  • કોર પ્રોસેસર હોદ્દાઓ વિવિધ રૂપો બનાવે છે: ઉત્પાદકનું નામ, કોર બ્રાન્ડ, સંયુક્ત સ્વરૂપો

  • N-series પ્રોસેસર્સ (N100, વગેરે) સમાન પેટર્ન સંયોજનો બનાવે છે

  • દરેક "પ્રોસેસર" સાથે બહુવિધ ક્રમચયો બનાવે છે

મુખ્ય મેમરી:

  • આંકડાકીય મૂલ્યો સ્પેસ સાથે અને વિના બંને GB વિવિધતાઓ બનાવે છે ("16gb","16 gb")

  • "ram" અને "memory" ક્વોલિફાયર્સ સાથે આપમેળે ઉમેરાય છે ("16gb memory","16 gb ram")

SSD સ્ટોરેજ:

  • આંકડાકીય મૂલ્યો GB વિવિધતાઓ બનાવે છે ("512gb", "512 gb")

  • ≥ 1024 મૂલ્યો માટે આપમેળે TB વિવિધતાઓ બનાવે છે (દા.ત., 1024GB → 1TB)

  • "ssd" અને "storage" ક્વોલિફાયર્સ સાથે આપમેળે ઉમેરાય છે ("512gb ssd", "512 gb storage")

ફોર્મ ફેક્ટર:

  • મિની PC → સ્પેસ વિનાના સ્વરૂપ સહિત બહુવિધ વિવિધતાઓ

  • ઓલ-ઇન-વન → "ઓલ ઇન વન", "aio", સંક્ષિપ્ત સ્વરૂપો

  • થિન ક્લાયંટ → સ્પેસ સાથે/વિના વિવિધતાઓ

  • ઇન્ડસ્ટ્રિયલ PC → સંક્ષિપ્ત અને સંપૂર્ણ સ્વરૂપો

જનરેશન:

  • આંકડાકીય જનરેશન મૂલ્યો આ બની જાય છે: "12th gen", "12th generation", "gen 12"

કોર્સ:

  • 2 → "ડ્યુઅલ કોર"

  • 4 → "ક્વાડ કોર"

  • 6 → "હેક્સા કોર"

  • 8 → "ઓક્ટા કોર"

  • બધા "[n] કોર પ્રોસેસર" વિવિધતાઓ બનાવે છે

ઇથરનેટ:

  • "1000" → ["gigabit ethernet", "gbe", "1gbps"]

  • "2500" → ["2.5gbe", "2.5 gigabit", "2.5gbps"]

ઓપરેટિંગ સિસ્ટમ:

  • "Windows 11" → ["windows", "windows 11", "win 11"]

  • "Ubuntu" → ["linux", "ubuntu"]

  • "FreeDOS" → ["freedos", "no os", "without os"]

સ્ટેન્ડઅલોન મૂલ્યો માટે વ્હાઇટલિસ્ટ

માત્ર ચોક્કસ ફીચર્સ ખોટા મેળને રોકવા માટે સ્ટેન્ડઅલોન મૂલ્ય મેચિંગની મંજૂરી આપે છે:

  • સિરીઝ: "i3", "i5", "N100" (પરંતુ એકલ અક્ષરો નહીં)

  • પ્રોસેસર મોડેલ: "N100", "1335U"

  • ઓપરેટિંગ સિસ્ટમ: "Windows", "Linux", "Ubuntu"

  • જનરેશન: "12th", "13th", "14th"

  • પ્રોસેસર બ્રાન્ડ: "Intel", "ARM"

ઉદાહરણ તરીકે, જ્યારે ક્વેરી "2 hdmi ports" હોય ત્યારે "2" એ "2 cores" સાથે મેળ ન ખાવું જોઈએ. લંબાઈ તપાસ એકલ અક્ષરો અથવા ખૂબ ટૂંકા અસ્પષ્ટ મૂલ્યોને સ્ટેન્ડઅલોન મેચ થતા અટકાવે છે. સ્પષ્ટ એકમ ઘટકો ધરાવતા ફીચર્સ, જેમ કે ઇથરનેટ અથવા પોર્ટ્સ, માત્ર ત્યારે જ સ્ટેન્ડઅલોન સંયોજનો બનાવે છે જ્યારે તેમના એકમ સાથે લાયકાત ધરાવતા હોય.

અથડામણ નિવારણ

મેમરી અને સ્ટોરેજ મૂલ્યો ઓવરલેપ થાય છે (બંનેમાં 64, 128, 256, વગેરે છે). પગલું 4 અસ્પષ્ટતા દૂર કરવા માટે મૂલ્ય-શ્રેણી નિયમો લાગુ કરે છે:

  • ≤ 64 GB: મુખ્ય મેમરી (RAM)

  • ≥ 128 GB: SSD સ્ટોરેજ

  • 65-127 GB શ્રેણી: છોડી દેવામાં આવે છે (અસ્પષ્ટ)

સ્પષ્ટ ક્વોલિફાયર્સ ("ram"/"memory" અથવા "ssd"/"storage") ધરાવતા વાક્યો આ નિયમને ઓવરરાઇડ કરે છે અને કોઈપણ મૂલ્ય સાથે મેળ ખાઈ શકે છે.

વધુમાં, જે અસ્પષ્ટ સામાન્ય શબ્દો ઘણા બધા અસંબંધિત ફિલ્ટર્સ સાથે મેળ ખાય છે તે પોસ્ટ-પ્રોસેસિંગ દ્વારા અથડામણ નિરાકરણ દરમિયાન બાકાત રાખવામાં આવે છે: "connectivity", "audio", "display", "processor" અને "physical" જેવા શબ્દો બહુવિધ પાસાઓમાં ખૂબ અસ્પષ્ટતા ઊભી કરે છે.

પગલું 4: સિમેન્ટિક વિસ્તરણ

N-ગ્રામ નિષ્કર્ષણ

આપણે વાસ્તવિક શોધ ક્વેરીઓમાંથી વારંવાર આવતા વાક્યો કાઢીએ છીએ, જે એકલ શબ્દો ("mini" જેવા 1-ગ્રામ) થી લઈને લાંબી સિક્વન્સ ("mini pc with 16gb ram ssd" જેવા 6-ગ્રામ સુધી) સુધીના હોય છે. ઓછામાં ઓછા 3 વખત દેખાતા વાક્યો જ રાખવામાં આવે છે. આ ફિલ્ટરિંગ અભિગમ ઘોંઘાટ ઘટાડે છે જ્યારે વાસ્તવિક વપરાશકર્તા ભાષા પેટર્ન જાળવી રાખે છે.

ફિલ્ટર શોધ ટેક્સ્ટ નિર્માણ

દરેક ફિલ્ટર મૂલ્ય માટે, આપણે શોધ ટેક્સ્ટ બનાવીએ છીએ:

મુખ્ય મેમરી: 16:

  • "16gb ram memory"

  • "16 main memory"

  • "main memory 16"

SSD સ્ટોરેજ: 512:

  • "512gb storage ssd"

  • "512 ssd storage"

  • "ssd storage 512"

આ શોધ ટેક્સ્ટ ફિલ્ટરને એમ્બેડિંગ સ્પેસમાં રજૂ કરે છે.

એમ્બેડિંગ અને મેચિંગ

આપણે ક્વેરી વાક્યો અને ફિલ્ટર શોધ ટેક્સ્ટ બંનેને એમ્બેડિંગમાં રૂપાંતરિત કરીએ છીએ, પછી તેમની વચ્ચે કોસાઇન સમાનતા ગણતરી કરીએ છીએ. ગોઠવેલ થ્રેશોલ્ડથી ઉપર સમાનતા સ્કોર ધરાવતા વાક્યો તે ફિલ્ટરના મેપિંગમાં ઉમેરવામાં આવે છે.

મેન્યુઅલ સીડ વાક્યો

વિસ્તરણ પહેલાં આપણે ઉચ્ચ-વિશ્વાસ મેન્યુઅલ સીડ્સ દાખલ કરીએ છીએ:

"Series:i5": [
    "i5",
    "core i5",
    "intel i5",
    "intel core i5",
    "i5 processor",
    "cpu i5",
]

આ સીડ્સ મુખ્ય વાક્યો રજૂ કરે છે જે આપણે જાણીએ છીએ કે દરેક ફિલ્ટર માટે સાચા છે. તેમને મહત્તમ સમાનતા સ્કોર સાથે સામેલ કરીને, તેઓ વિસ્તરણ અલ્ગોરિધમને સમાન અર્થવાળા સંબંધિત વાક્યો શોધવા માટે માર્ગદર્શન આપે છે. આ સીડ્સને હંમેશા સમાનતા 1.0 મળે છે અને વિસ્તરણને માર્ગદર્શન આપે છે.

વધારાત્મક એમ્બેડિંગ

આપણે વાક્યો અને ફિલ્ટર શોધ ટેક્સ્ટ બંને માટે એમ્બેડિંગ કેશ કરીએ છીએ. જ્યારે નવી ક્વેરીઓ આવે છે:

  1. હાલના એમ્બેડિંગ લોડ કરો
  2. ફક્ત નવા વાક્યો એમ્બેડ કરો
  3. કેશમાં ઉમેરો

આ યથાવત ડેટાને ફરીથી એમ્બેડ કરવાનું ટાળે છે. વિગતો માટે એમ્બેડિંગ સ્ટ્રેટેજી જુઓ.

અથડામણ નિરાકરણ

સમાનતા મેચિંગ પૂર્ણ થયા પછી, આપણે મેમરી અને સ્ટોરેજ ફિલ્ટર્સ વચ્ચેની અથડામણો ઉકેલીએ છીએ:

સંખ્યા-આધારિત અસ્પષ્ટતા નિવારણ:

  • સંખ્યાઓ ધરાવતા અસ્પષ્ટ વાક્યો માટે: જો વાક્યનું મૂલ્ય ≤ 64 હોય, તો ફક્ત મેમરી માટે રાખો; જો > 64 હોય, તો ફક્ત સ્ટોરેજ માટે રાખો

  • આ "16gb" ને SSD સ્ટોરેજ ફિલ્ટર્સ સાથે અને "512gb" ને મેમરી ફિલ્ટર્સ સાથે મેળ ખાતા અટકાવે છે

સ્પષ્ટ ક્વોલિફાયર્સ નિયમોને ઓવરરાઇડ કરે છે:

  • "ram", "memory", "cpu", "processor" કીવર્ડ ધરાવતા વાક્યો → ફક્ત મેમરી

  • "ssd", "storage", "disk", "nvme", "drive" કીવર્ડ ધરાવતા વાક્યો → ફક્ત સ્ટોરેજ

  • ઉદાહરણ: "processor 8gb" આંકડાકીય હોવા છતાં મેમરીમાં મેપ થાય છે

અસ્પષ્ટ શબ્દો:

  • "connectivity", "audio", "display" જેવા વાક્યો છોડી દો જે બહુવિધ અસંબંધિત ફિલ્ટર્સ સાથે મેળ ખાય છે

આઉટપુટ ફોર્મેટ

અંતિમ મેપિંગ સમાનતા (સૌથી વધુ પ્રથમ), પછી લંબાઈ (સૌથી ટૂંકું પ્રથમ) દ્વારા સૉર્ટ કરવામાં આવે છે:

{
  "Main Memory:16": [
    {"phrase": "16gb ram", "similarity": 1.0},
# ... (implementation details omitted)

ફિલ્ટર નિષ્કર્ષણ સાથે એકીકરણ

આ મેપિંગ ફિલ્ટર નિષ્કર્ષણ અલ્ગોરિધમને શક્તિ આપે છે:

  1. ક્વેરી આવે છે: "mini pc with 16gb ram"
  2. વાક્યો કાઢો: ["mini pc", "16gb ram", "mini", "pc", "16gb", "ram"]
  3. મેપિંગનો ઉપયોગ કરીને વાક્યોને ફિલ્ટર્સ સાથે મેચ કરો
  4. ફિલ્ટર્સ પરત કરો: {"Form Factor": ["Mini PC"], "Main Memory": ["16"]}

વિગતો માટે ફિલ્ટર નિષ્કર્ષણ અલ્ગોરિધમ જુઓ.

સંગ્રહ અને વિતરણ

વાક્ય મેપિંગ JSON ફાઇલો તરીકે સંગ્રહિત થાય છે અને સિસ્ટમમાં ઉપયોગમાં લેવાય છે:

  • આધાર મેપિંગ ફાઇલ: પગલું 3a માં બનાવેલ, નિયમ-આધારિત વાક્યો ધરાવે છે

  • વિસ્તૃત મેપિંગ ફાઇલ: પગલું 4 માં બનાવેલ, સિમેન્ટિક વિસ્તરણ પરિણામો ધરાવે છે

વિસ્તૃત મેપિંગનો ઉપયોગ આના દ્વારા થાય છે:

  • ક્વેરી પેજ નિર્માણ: ક્વેરી ટેક્સ્ટમાંથી ફિલ્ટર્સ કાઢો

  • શોધ સેવા: રીઅલ-ટાઇમ ફિલ્ટર નિષ્કર્ષણ API

  • ઉત્પાદન મેચિંગ: કાઢેલા ફિલ્ટર્સ દ્વારા ઉત્પાદનો ફિલ્ટર કરો

પ્રદર્શન લાક્ષણિકતાઓ

આધાર નિર્માણ (પગલું 3a):

  • પ્રોસેસિંગ સમય ફિલ્ટર મૂલ્યોની સંખ્યા સાથે વધે છે

  • મોટી સંખ્યામાં આધાર વાક્ય વિવિધતાઓ બનાવે છે

  • નિર્માણ દરમિયાન મેમરી વપરાશ મધ્યમ રહે છે

સિમેન્ટિક વિસ્તરણ (પગલું 4):

  • પ્રોસેસિંગ સમય ક્વેરી વોલ્યુમ અને એમ્બેડિંગ કદ સાથે વધે છે

  • આઉટપુટમાં આધાર નિર્માણ કરતાં નોંધપાત્ર રીતે વધુ વાક્યો હોય છે

  • એમ્બેડિંગ સંગ્રહને કારણે મેમરી જરૂરિયાતો વધે છે

વિસ્તરણ સમાનતા ગણતરીને કારણે CPU-બાઉન્ડ છે. BLAS પ્રવેગક સાથે NumPy નો ઉપયોગ મેટ્રિક્સ કામગીરીને નોંધપાત્ર રીતે ઝડપી બનાવે છે.

SEO પાઇપલાઇન સાથે એકીકરણ

વાક્ય મેપિંગ નિર્માણ એ SEO પાઇપલાઇનમાં પગલાં 3a અને 4 છે:

  1. પગલું 0: સ્ત્રોત ડેટા એમ્બેડ કરો - ઉત્પાદનો, ભાગો, લેખો
  2. પગલું 1: ક્વેરીઓ લાવો - GSC, Google Ads, લાઇવ, Algolia
  3. પગલું 2: ક્વેરીઓ ભેગી કરો - બધા સ્ત્રોતો મર્જ કરો
  4. પગલું 3a: આધાર વાક્ય મેપિંગ બનાવો ← તમે અહીં છો
  5. પગલું 3b: ક્વેરીઓ એમ્બેડ કરો - વેક્ટરમાં રૂપાંતરિત કરો
  6. પગલું 4: વાક્ય મેપિંગ વિસ્તૃત કરો ← તમે અહીં છો
  7. પગલું 5: ક્વેરી ક્લસ્ટરિંગ - પેજીસમાં જૂથ બનાવો
  8. પગલું 6: ઉત્પાદનો મેચ કરો - ક્વેરી-ઉત્પાદન મેચિંગ
  9. પગલું 7: ક્વેરી પેજીસ બનાવો - HTML જનરેટ કરો
  10. પગલું 8: સંબંધિત શોધો જનરેટ કરો - સંબંધિત ક્વેરીઓ શોધો
  11. પગલું 11: Valkey માં સ્થાનાંતરિત કરો - શોધ સેવામાં લોડ કરો

સંપૂર્ણ ફ્લો માટે SEO પાઇપલાઇન ઓવરવ્યૂ જુઓ.

બે પગલાં કેમ?

આધાર નિર્માણ (પગલું 3a) પ્રદાન કરે છે:

  • ચોકસાઈ: નિયમ-આધારિત વાક્યો આપણે જે અપેક્ષા રાખીએ છીએ તે બરાબર મેળ ખાય છે

  • કવરેજ: ક્રમચયો સુનિશ્ચિત કરે છે કે બધા શબ્દ ક્રમ આવરી લેવામાં આવ્યા છે

  • નિયંત્રણ: ફીચર-વિશિષ્ટ નિયમો ડોમેન જ્ઞાનને સંભાળે છે

સિમેન્ટિક વિસ્તરણ (પગલું 4) પ્રદાન કરે છે:

  • લવચીકતા: આપણે અપેક્ષા ન કરેલા વાક્યો શોધે છે

  • વાસ્તવિક વપરાશકર્તા ભાષા: વાસ્તવિક શોધ ક્વેરીઓમાંથી શીખે છે

  • સમાનાર્થી: સમકક્ષ વાક્યો શોધે છે ("16gb" માટે "16 gigs")

સાથે મળીને, તેઓ ચોકસાઈ અને રિકોલ વચ્ચે સંતુલન જાળવે છે.

સંદર્ભો

તકનીકી ખ્યાલો

  • Permutation - વિકિપીડિયા

  • Cosine Similarity - વિકિપીડિયા

  • N-gram - વિકિપીડિયા

  • NumPy - સત્તાવાર દસ્તાવેજીકરણ

  • BLAS - વિકિપીડિયા

મોડેલ દસ્તાવેજીકરણ

સંબંધિત લેખો

સારાંશ

આપણે બે પગલાંમાં વાક્ય-થી-ફિલ્ટર મેપિંગ બનાવીએ છીએ:

પગલું 3a (આધાર નિર્માણ):

  • હેડિંગ, કી, મૂલ્ય, એકમના તમામ ક્રમચયો બનાવો

  • ફીચર-વિશિષ્ટ નિયમો લાગુ કરો (પ્રોસેસર સિરીઝ, મેમરી, સ્ટોરેજ, ફોર્મ ફેક્ટર)

  • કનેક્ટિવિટી ફીચર્સ માટે પોર્ટ પ્રત્યયો ઉમેરો

  • ચોક્કસ ફીચર્સ માટે સ્ટેન્ડઅલોન મૂલ્યોને વ્હાઇટલિસ્ટ કરો

  • નિયમોમાંથી આધાર વાક્ય સેટ આઉટપુટ કરો

પગલું 4 (સિમેન્ટિક વિસ્તરણ):

  • વાસ્તવિક શોધ ક્વેરીઓમાંથી n-ગ્રામ વાક્યો કાઢો

  • વાક્યો અને ફિલ્ટર શોધ ટેક્સ્ટ એમ્બેડ કરો

  • થ્રેશોલ્ડથી ઉપર સમાનતા સ્કોર ધરાવતા વાક્યો મેચ કરો

  • વિસ્તરણને માર્ગદર્શન આપવા માટે મેન્યુઅલ સીડ વાક્યો દાખલ કરો

  • મેમરી/સ્ટોરેજ અથડામણો ઉકેલો

  • વિસ્તૃત અને અસ્પષ્ટતા-મુક્ત વાક્ય સેટ આઉટપુટ કરો

પરિણામ એક વ્યાપક મેપિંગ છે જે અપેક્ષિત વાક્યો (નિયમો દ્વારા) અને અણધારી વિવિધતાઓ (સિમેન્ટિક સમાનતા દ્વારા) બંનેને સંભાળે છે. આ મેપિંગ ક્વેરી પેજીસ, શોધ અને ઉત્પાદન મેચિંગમાં ફિલ્ટર નિષ્કર્ષણને શક્તિ આપે છે.

← દસ્તાવેજીકરણ અનુક્રમણિકામાં પાછા જાઓ