Python में AI की अवधारणाएँ

Python में सर्च और गेम AI: A* और मिनिमैक्स

क्लासिक AI संभावित स्थितियों में खोज करके समस्याएँ हल करता है। A* अब तक की लागत और बची लागत के अनुमान को जोड़कर सबसे सस्ता रास्ता ढूँढता है, और मिनिमैक्स यह मानकर दो खिलाड़ियों वाले खेल में चाल चुनता है कि विरोधी अच्छा खेलेगा।

आसान शब्दों में अवधारणा

क्लासिक AI संभावित स्थितियों में खोज करके समस्याएँ हल करता है। A* अब तक की लागत और बची लागत के अनुमान को जोड़कर सबसे सस्ता रास्ता ढूँढता है, और मिनिमैक्स यह मानकर दो खिलाड़ियों वाले खेल में चाल चुनता है कि विरोधी अच्छा खेलेगा।

A* सर्च से ग्रिड पर सबसे छोटा रास्ता ढूँढें और मिनिमैक्स से खेल में सबसे अच्छी चाल चुनें।

मुख्य बातें

  • जब अनुमान (heuristic) असली लागत से कभी ज़्यादा न हो, तब A* सबसे अच्छा रास्ता ढूँढता है।
  • मिनिमैक्स गेम ट्री को एक तय गहराई तक या खेल खत्म होने तक खोजता है।
  • अल्फ़ा-बीटा प्रूनिंग उन शाखाओं को छोड़ देती है जो फ़ैसला नहीं बदल सकतीं।
  • जेनेटिक एल्गोरिदम अलग तरह से खोजते हैं: वे संभावित हलों की आबादी को विकसित करते हैं।

इसका उपयोग कब करें?

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

इसे काम करते देखें

A* को ग्रिड खोजते देखने के लिए चलाएँ दबाएँ; दीवारें जोड़ने या हटाने के लिए खानों पर क्लिक करें। गेम ट्री में किसी पत्ते पर क्लिक करके उसका स्कोर बदलें।

उदाहरण कोड

कोड चलाएँ →
main.py
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 की जाँच करें।

  1. इनपुट या वेट बदलें और रन करने से पहले आउटपुट का अनुमान लगाएँ।
  2. हर गणना चरण को देखने के लिए बीच के मान प्रिंट करें।
  3. नीचे दी गई चुनौतियाँ हल करके विचार को खुद लागू करें।
Python IDE में चलाएँ →

चैलेंज से अभ्यास करें

इस पाठ में सीखी बात से एक असली समस्या हल करें। हर चैलेंज ब्राउज़र में चलता है, तुरंत टेस्ट और AI रिव्यू के साथ।

सभी चैलेंज