समानार्थी चेन - आईओएस / स्क्लाइट के लिए कुशल रूटिंग एल्गोरिदम - आईओएस, एल्गोरिदम, एसक्लाइट, यात्रा-विक्रेता, थिसॉरस

समानार्थी श्रृंखला बारीकी से संबंधित शब्दों की एक श्रृंखला है जो दो एंकरों का विस्तार करती है। उदाहरण के लिए, अंग्रेजी शब्द "काला" और "सफेद" इस प्रकार से जुड़ सकते हैं:

काली-dark-अस्पष्ट-छुपा-छुपा-सुखद-सहज-आसान सरल-pure-सफेद

या, यहां "सत्य" और "झूठा" है:

सच-सिर्फ = निष्पक्ष = सुंदर = सुंदर-कलात्मक-कृत्रिम-sham-असत्य

मैं एक थिसॉरस आईओएस ऐप पर काम कर रहा हूं, और मैं चाहता हूंसमानार्थी चेन भी प्रदर्शित करना पसंद है। लक्ष्य शब्द संबंधों के भारित ग्राफ के भीतर से एक श्रृंखला को वापस करना है। मेरा स्रोत भारित डेटा वाला एक बहुत बड़ा थिसॉरस है, जहां वजन शब्दों के बीच समानता मापता है। (उदाहरण के लिए, "आउटला" "बैंडिट" से निकटता से संबंधित है, लेकिन "दुष्ट" से अधिक दूर से संबंधित है।) हमारे वास्तविक मूल्य 0.001 से ~ 50 तक हैं, लेकिन आप किसी भी भार सीमा को ग्रहण कर सकते हैं।

आप किस अनुकूलन रणनीतियों की सिफारिश करते हैंयह यथार्थवादी बनाएं, उदाहरण के लिए, एक विशिष्ट आईओएस डिवाइस पर प्रसंस्करण के 5 सेकंड के भीतर? मान लें कि थिसॉरस में आधा मिलियन शब्द हैं, प्रत्येक 20 संघों के साथ। मुझे यकीन है कि इस तरह की समस्याओं पर पूर्व शोध का एक टन है, और मैं इस बात पर विचार कर सकता हूं कि इस पर क्या लागू किया जा सकता है।

मेरे वर्तमान एल्गोरिदम में पुनरावर्ती शामिल हैशुरुआत और अंत शब्दों से कुछ स्तरों को अवरुद्ध करते हुए, और फिर शब्दों को रोकना चाहते हैं, लेकिन यह हजारों वर्गमीटर (या दायरे) के साथ बहुत धीमा हो जाता है।

उत्तर:

जवाब के लिए 2 № 1

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

काले काले अस्पष्ट-छुपा-छुपा-सुखद-सहज-आसान सरल शुद्ध सफेद

आइए शब्दों को एक नोड के रूप में सोचेंग्राफ, समानता के प्रत्येक संबंध एक शब्द के साथ दूसरे के साथ है उस ग्राफ पर एक पथ है। प्रत्येक पथ को लागत के साथ भारित किया जाता है, जो आपके पास स्रोत फ़ाइल पर वजन होता है। इसलिए एक शब्द से दूसरे में पथ खोजने का सबसे अच्छा समाधान है ए* (एक सितारा) पथ खोजना

मैं एक से यात्रा करने के लिए न्यूनतम "लागत" का उपयोग कर रहा हूंइसके उत्तराधिकारी के लिए शब्द 1. आप तदनुसार इसे समायोजित कर सकते हैं। सबसे पहले आपको उपयोग करने के लिए एक अच्छा ह्युरिस्टिक फ़ंक्शन की आवश्यकता होगी, क्योंकि यह एक लालची एल्गोरिदम है। यह ह्युरिस्टिक फ़ंक्शन दो शब्दों, किसी भी शब्द के बीच "लालची" दूरी को वापस कर देगा। आपको इस तथ्य का सम्मान करना चाहिए कि यह "दूरी" लौटाता है जो दो शब्दों के बीच वास्तविक दूरी से बड़ा नहीं हो सकता है। चूंकि मुझे थिसॉरस के लिए किसी भी शब्द के बीच कोई संबंध नहीं पता है, इसलिए मेरा हेरिस्टिक फ़ंक्शन हमेशा न्यूनतम लागत वापस कर देगा। दूसरे शब्दों में, यह हमेशा कहता है कि एक शब्द किसी अन्य के लिए सबसे समान शब्द है। उदाहरण के लिए, मेरा उत्तराधिकारी समारोह मुझे बताता है कि "काली" के लिए सबसे अच्छा पर्याय है "सफेद"

यदि आप कर सकते हैं तो आपको हेरिस्टिक फ़ंक्शन को ट्यून करना होगा, इसलिए यह एल्गोरिदम तेजी से चलने वाली अधिक सटीक दूरी के साथ प्रतिक्रिया देगा। यह मुझे लगता है कि मुश्किल हिस्सा है।

आप भेजे गए विकिपीडिया आलेख पर एल्गोरिदम के लिए छद्म कोड देख सकते हैं। लेकिन यहां यह एक तेज व्याख्या के लिए है:

function A*(start,goal)
closedset := the empty set    -- The set of nodes already evaluated.
openset := {start}    -- The set of tentative nodes to be evaluated, initially containing the start node
came_from := the empty map    -- The map of navigated nodes.

g_score[start] := 0    -- Cost from start along best known path.
-- Estimated total cost from start to goal through y.
f_score[start] := g_score[start] + heuristic_cost_estimate(start, goal)

while openset is not empty
current := the node in openset having the lowest f_score[] value
if current = goal
return reconstruct_path(came_from, goal)

remove current from openset
add current to closedset
for each neighbor in neighbor_nodes(current)
if neighbor in closedset
continue
tentative_g_score := g_score[current] + dist_between(current,neighbor)

if neighbor not in openset or tentative_g_score < g_score[neighbor]
came_from[neighbor] := current
g_score[neighbor] := tentative_g_score
f_score[neighbor] := g_score[neighbor] + heuristic_cost_estimate(neighbor, goal)
if neighbor not in openset
add neighbor to openset

return failure

function reconstruct_path(came_from,current)
total_path := [current]
while current in came_from:
current := came_from[current]
total_path.append(current)
return total_path

अब, एल्गोरिदम के लिए आपके पास 2 एरे होंगेनोड्स, जिन्हें आप जा रहे हैं (खोला गया) और जिन्हें आप पहले से देख चुके हैं (बंद)। आपके पास प्रत्येक नोड के लिए दूरी के दो सरणी भी होंगी, जब आप ग्राफ के माध्यम से यात्रा करते हैं तो आप पूरा कर लेंगे।

एक सरणी (g_score) आपको शुरुआती नोड और निर्दिष्ट नोड के बीच वास्तविक न्यूनतम यात्रा दूरी बताएगा। उदाहरण के लिए, g_score [ "छिपा"] यात्रा करने के लिए सबसे कम भारित लागत वापस कर देगा "काली" सेवा मेरे "छिपा हुआ"

अन्य सरणी (f_score) आपको उस लक्ष्य के लिए निर्दिष्ट दूरी बताएगा जिसे आप उस लक्ष्य के लिए निर्दिष्ट करते हैं जिसे आप पहुंचना चाहते हैं। उदाहरण के लिए, f_score ["snug"] से यात्रा करने के लिए अनुमानित भारित लागत वापस कर देगा "सुखद" सेवा मेरे "सफेद" हेरिस्टिक फ़ंक्शन का उपयोग करना। याद रखें, यह लागत हमेशा शब्दों के बीच यात्रा करने के लिए वास्तविक लागत के बराबर या बराबर होगी, क्योंकि हमारे ह्युरिस्टिक फ़ंक्शन को उपर्युक्त नियम का सम्मान करने की आवश्यकता है।

जैसे ही एल्गोरिदम चलता है, आप यात्रा करेंगेनोड से नोड, शुरुआती शब्द से, आपके द्वारा यात्रा किए जाने वाले सभी नोड्स को सहेजना और यात्रा के लिए "उपयोग" की जाने वाली लागतें। जब आप यात्रा करने के लिए बेहतर लागत पाते हैं तो आप यात्रा पथ को बदल देंगे g_score सरणी। आप इसका उपयोग करेंगे f_score भविष्यवाणी करने के लिए कि "अनवरोधित" नोड्स की सरणी से पहले किस नोड का सबसे अच्छा दौरा किया जाएगा। यदि आप अपना बचाते हैं तो यह सबसे अच्छा है f_score के रूप में न्यूनतम ढेर

जब आप नोड पाते हैं तो आप एल्गोरिदम समाप्त कर देंगेयही वह लक्ष्य है जिसे आप चाहते हैं। फिर आप प्रत्येक पुनरावृत्ति पर सहेजते हुए नोड्स की सरणी का उपयोग करके न्यूनतम पथ का पुनर्निर्माण करेंगे। एक और तरीका एल्गोरिदम रुक जाएगा यदि यह सभी पड़ोसी नोड्स का दौरा करता है और लक्ष्य नहीं मिला। जब ऐसा होता है, तो आप कह सकते हैं कि प्रारंभिक नोड से लक्ष्य तक कोई रास्ता नहीं है।

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

- 7 एफ


संबंधित सवाल
सबसे लोकप्रिय