Python में सर्च और गेम AI: A* और मिनिमैक्स
क्लासिक AI संभावित स्थितियों में खोज करके समस्याएँ हल करता है। A* अब तक की लागत और बची लागत के अनुमान को जोड़कर सबसे सस्ता रास्ता ढूँढता है, और मिनिमैक्स यह मानकर दो खिलाड़ियों वाले खेल में चाल चुनता है कि विरोधी अच्छा खेलेगा।
आसान शब्दों में अवधारणा
क्लासिक AI संभावित स्थितियों में खोज करके समस्याएँ हल करता है। A* अब तक की लागत और बची लागत के अनुमान को जोड़कर सबसे सस्ता रास्ता ढूँढता है, और मिनिमैक्स यह मानकर दो खिलाड़ियों वाले खेल में चाल चुनता है कि विरोधी अच्छा खेलेगा।
A* सर्च से ग्रिड पर सबसे छोटा रास्ता ढूँढें और मिनिमैक्स से खेल में सबसे अच्छी चाल चुनें।
मुख्य बातें
- जब अनुमान (heuristic) असली लागत से कभी ज़्यादा न हो, तब A* सबसे अच्छा रास्ता ढूँढता है।
- मिनिमैक्स गेम ट्री को एक तय गहराई तक या खेल खत्म होने तक खोजता है।
- अल्फ़ा-बीटा प्रूनिंग उन शाखाओं को छोड़ देती है जो फ़ैसला नहीं बदल सकतीं।
- जेनेटिक एल्गोरिदम अलग तरह से खोजते हैं: वे संभावित हलों की आबादी को विकसित करते हैं।
इसका उपयोग कब करें?
- समझें कि न्यूरल नेटवर्क और AI लाइब्रेरी के अंदर क्या होता है।
- संबंधित चुनौतियों में खुद लागू करने से पहले विचार को समझें।
- मशीन लर्निंग कोर्स, इंटरव्यू और प्रोजेक्ट की तैयारी करें।
इसे काम करते देखें
A* को ग्रिड खोजते देखने के लिए चलाएँ दबाएँ; दीवारें जोड़ने या हटाने के लिए खानों पर क्लिक करें। गेम ट्री में किसी पत्ते पर क्लिक करके उसका स्कोर बदलें।
उदाहरण कोड
import heapq
# A* finds the cheapest path using cost so far + a guess of the cost left.
grid = ["S..#",
".#..",
"...G"]
start, goal = (0, 0), (2, 3)
guess = lambda r, c: abs(r - goal[0]) + abs(c - goal[1]) # Manhattan distance
frontier = [(guess(*start), 0, start, [start])]
seen = set()
while frontier:
_, cost, (r, c), path = heapq.heappop(frontier)
if (r, c) == goal:
print("path:", path, "cost:", cost)
break
if (r, c) in seen:
continue
seen.add((r, c))
for dr, dc in ((0, 1), (1, 0), (0, -1), (-1, 0)):
nr, nc = r + dr, c + dc
if 0 <= nr < 3 and 0 <= nc < 4 and grid[nr][nc] != "#":
heapq.heappush(frontier, (cost + 1 + guess(nr, nc), cost + 1, (nr, nc), path + [(nr, nc)]))
# Minimax: the maximizer assumes the opponent always picks the worst for it.
def minimax(node, maximizing):
if isinstance(node, int):
return node
values = [minimax(child, not maximizing) for child in node]
return max(values) if maximizing else min(values)
tree = [[3, 5], [2, 9], [0, 7]] # our move, then the opponent's reply
print("best guaranteed score:", minimax(tree, True))
अपेक्षित आउटपुट
path: [(0, 0), (0, 1), (0, 2), (1, 2), (1, 3), (2, 3)] cost: 5
best guaranteed score: 3
यह कैसे काम करता है
प्राथमिकता कतार हमेशा उस खाने को आगे बढ़ाती है जिसकी लागत + अनुमान सबसे कम हो, और अनुमान लक्ष्य तक की मैनहैटन दूरी है, इसलिए A* दीवारों के चारों ओर घूमकर 5 कदमों में G तक पहुँचता है। minimax() हमारी बारी पर अधिकतम और विरोधी की बारी पर न्यूनतम लेता है; पहली चाल 3 की गारंटी देती है, जो तीनों सबसे बुरी स्थितियों में सबसे अच्छी है।
मान बदलें और Python इंस्टॉल किए बिना CodeUtility ऑनलाइन Python कंपाइलर में प्रोग्राम चलाएँ।
अभ्यास के कार्य
बड़े dataset पर जाने से पहले input बदलें और edge cases की जाँच करें।
- इनपुट या वेट बदलें और रन करने से पहले आउटपुट का अनुमान लगाएँ।
- हर गणना चरण को देखने के लिए बीच के मान प्रिंट करें।
- नीचे दी गई चुनौतियाँ हल करके विचार को खुद लागू करें।
चैलेंज से अभ्यास करें
इस पाठ में सीखी बात से एक असली समस्या हल करें। हर चैलेंज ब्राउज़र में चलता है, तुरंत टेस्ट और AI रिव्यू के साथ।
- भारित ग्रिड पर A* खोज गेम और रोबोट के पाथफ़ाइंडिंग के पीछे के खोज एल्गोरिदम A* से भू-भाग लागत वाले ग्रिड में सबसे सस्ता रास्ता खोजें। मध्यम
- मिनिमैक्स टिक-टैक-टो मिनिमैक्स से पूरे गेम ट्री को खोजकर टिक-टैक-टो की सबसे सही चाल चुनें। मध्यम
- अल्फ़ा-बीटा प्रूनिंग मिनिमैक्स और अल्फ़ा-बीटा प्रूनिंग से गेम ट्री का मूल्यांकन करें, और गिनें कि खोज वास्तव में कितनी पत्तियाँ देखती है। मध्यम
- जेनेटिक एल्गोरिदम की एक पीढ़ी टूर्नामेंट चयन, सिंगल-पॉइंट क्रॉसओवर और म्यूटेशन से बिट स्ट्रिंग की अगली पीढ़ी बनाएँ। मध्यम