 README.mdSokoban Environment - NYU CS-GY6613PrerequisitesRequires python3 to runInstall liaries$...

Question

 README.mdSokoban Environment - NYU CS-GY6613PrerequisitesRequires python3 to runInstall liaries$ pip install -r requirements.txtRun the GameSolve as a human$ python3 game.py --play $ python3 game.py --agent HumanSolve with an agent$ python3 game.py --agent [AGENT-NAME-HERE]$ python3 game.py --agent BFS #run game with BFS agent$ python3 game.py --agent AStar --no_render #run game with AStar agent without renderingParameters--play  - run the game as a human playe--no_render  - run the AI solver without showing the game screen--agent [NAME] - the type of agent to use [Human, DoNothing, Random, BFS, DFS, AStar, HillClimber, Genetic, MCTS]--level [#]  - which level to test XXXXXXXXXXor 'random' for a randomly selected level that an agent can solve in at most 2000 iterations.These levels can be found in the 'assets/gen_levels/' folder (default=0)--iterations [#]  - how many iterations to allow the agent to search for (default=3000)--solve_speed [#]  - how fast (in ms) to show each step of the solution being executed on the game screenCode FunctionsThese are the only functions you need to concern yourselves with to complete the assignments.WARNING: DO NOT MODIFY THESEFUNCTIONS!Sokoban_pystate.clone() - creates a full copy of the cuent state (for use in initializing Nodes or for feedforward simulation of states withoutmodifying the original) Use with HillClimber to test sequencesstate.checkWin() - checks if the game has been won in this state (return type: bool)state.update(x,y) - updates the state with the given direction in the form x,y where x is the change in x axis position and y is thechange in y axis position. Used to feed-forward a state. Use with HillClimber Agent to test sequences.Agent_pyAgent() - base class for the AgentsRandomAgent() - agent that returns list of 20 random directionsDoNothingAgent() - agent that makes no movement for 20 stepsBFSAgent() - agent that solves the level using Breadth First SearchDFSAgent() - agent that solves the level using Depth First SearchAStarAgent() - agent that solves the level using A* SearchHillClimberAgent() - agent that solves the level using HillClimber Search algorithmGeneticAgent() - agent that solves the level using Genetic Search algorithmMCTSAgent() - agent that solves the level using Monte Carlo Tree Search algorithmHelper_pyOther functionsgetHeuristic(state) - returns the remaining heuristic cost for the cuent state - a.k.a. distance to win condition (return type:int). Use with HillClimber Agent to compare states at the end of sequence simulationsdirections - list of all possible directions (x,y) the agent/player can take Use with HillClimber Agent to mutate sequencesNode Class__init__(state, parent, action) - where state is the cuent layout of the game map, parent is the Node object preceding thestate, and action is the dictionary XY direction used to reach the state (return type: Node object)checkWin() - returns if the game is in a win state where all of the goals are covered by crates (return type: bool)getActions() - returns the sequence of actions taken from the initial node to the cuent node (return type: str list)getHeuristic() - returns the remaining heuristic cost for the cuent state - a.k.a. distance to win condition (return type: int)getHash() - returns a unique hash for the cuent game state consisting of the positions of the player, goals, and crates madeof a string of integers - for use of keeping track of visited states and comparing Nodes (return type: str)getChildren() - retrieves the next consecutive Nodes of the cuent state by expanding all possible directional actions (returntype: Node list)getCost() - returns the depth of the node in the search tree (return type: int)MCTSNode Class (extension of Node() for use with the MCTSAgent only)__init__(state, parent, action, maxDist) - modified to include variable to keep track of number of times visited (self.n), variableto keep track of score (self.q), and variable to keep make score value larger as solution gets nearer (self.maxDist)getChildren(visited) - returns the node's children if already made - otherwise creates new children based on whether stateshave been visited yet and saves them for use later (self.children)calcEvalScore(state) - calculates the evaluation score for a state compared to the node by examining the heurstic valuecompared to the starting heuristic value (larger = better = higher score) - for use with the rollout and general MCTS algorithmfunctionsFAQsWhat is iterations  and max_iterations ?iterations  keeps track of how many nodes you can expand upon in the tree, and max_iterations  is the number of nodesyou are allowed to search. In the case of evolutionary search, this is the number of times the solution is allowed to evolve. Thisvariable is implemented to prevent infinite loops from occuring in case your algorithm has an eor. Each level in the Sokobanframework should be able to be solved in 3000 iterations (the default number) or less for every AI solver.Can I use other liaries?No. All the functions you need are already included in the code template. Do not import any internal or external liaries for anyeason.I get infinite loops / My agent is running in circles. / My agent keeps going back to the same place.Make sure you are using node_a.getHash() == node_b.getHash()  to check the equivalency of 2 nodes and NOT node_a ==node_Is it ok if my agent's solution is less than 50 steps but returned a solution length of 50 anyways?Yes, as long as it reaches the win state of the level.My HillclimbeMCTS Agent doesn't win the level, is this ok?That's fine, as long as the final solution gets somewhat close to the win state. Because of the stochastic nature of Hillclimbeand MCTS, around 70%-80% of levels should be solved. screenshot XXXXXXXXXXat XXXXXXXXXXikkgusyk.pngscreenshot XXXXXXXXXXat XXXXXXXXXXf2px315y.pngsokoban-y1ejkzaf.pyfrom PIL import Imageimport os#Cuent Sokoban Stateclass State:    #Empty Sokoban Level    def __init__(self): XXXXXXXXXXself.solid=[] XXXXXXXXXXself.targets=[] XXXXXXXXXXself.crates=[] XXXXXXXXXXself.player=None    #Initialize a Sokoban level from lines    def stringInitialize(self, lines): XXXXXXXXXXself.solid=[] XXXXXXXXXXself.targets=[] XXXXXXXXXXself.crates=[] XXXXXXXXXXself.player=None        # clean the input XXXXXXXXXXfor i in range(len(lines)): XXXXXXXXXXlines[i]=lines[i].replace("
","") XXXXXXXXXXfor i in range(len(lines)): XXXXXXXXXXif len(lines[i].strip()) != 0:                eak XXXXXXXXXXelse: XXXXXXXXXXdel lines[i] XXXXXXXXXXi-=1 XXXXXXXXXXfor i in range(len(lines)-1,0,-1): XXXXXXXXXXif len(lines[i].strip()) != 0:                eak XXXXXXXXXXelse: XXXXXXXXXXdel lines[i] XXXXXXXXXXi+=1        #get size of the map XXXXXXXXXXself.width=0 XXXXXXXXXXself.height=len(lines) XXXXXXXXXXfor l in lines: XXXXXXXXXXif len(l) > self.width: XXXXXXXXXXself.width = len(l)        #set the level XXXXXXXXXXfor y in range(self.height): XXXXXXXXXXl = lines[y] XXXXXXXXXXself.solid.append([]) XXXXXXXXXXfor x in range(self.width): XXXXXXXXXXif x > len(l)-1: XXXXXXXXXXself.solid[y].append(False) XXXXXXXXXXcontinue XXXXXXXXXXc=l[x] XXXXXXXXXXif c == "#": XXXXXXXXXXself.solid[y].append(True) XXXXXXXXXXelse: XXXXXXXXXXself.solid[y].append(False) XXXXXXXXXXif c == "@" or c=="+":     XXXXXXXXXXself.player={"x":x, "y":y} XXXXXXXXXXif c=="$" or c=="*":     XXXXXXXXXXself.crates.append({"x":x, "y":y}) XXXXXXXXXXif c=="." or c=="+" or c=="*":     XXXXXXXXXXself.targets.append({"x":x, "y":y})    # Make a clone of the cuent state    def clone(self): XXXXXXXXXXclone=State() XXXXXXXXXXclone.width = self.width XXXXXXXXXXclone.height = self.height        # since the solid is not changing then copy by value XXXXXXXXXXclone.solid = self.solid XXXXXXXXXXif hasattr(self, 'deadlocks'): XXXXXXXXXXclone.deadlocks =

Karthi · Accepted Answer

solution_92567/agent.py
#########################################
#                                       #
#                                       #
#  ==  SOKOBAN STUDENT AGENT CODE  ==   #
#                                       #
#      Written by: [YOUR FULL NAME]     #
#                                       #
#                                       #
#########################################
# SOLVER CLASSES WHERE AGENT CODES GO
from helper import *
import random
import math
# Base class of agent (DO NOT TOUCH!)
class Agent:
    def getSolution(self, state, maxIterations):
        '''
        EXAMPLE USE FOR TREE SEARCH AGENT:
        #expand the tree until the iterations runs out or a solution sequence is found
        while (iterations  0:
            iterations += 1
            [ POP NODE OFF OF QUEUE ]
            [ EVALUATE NODE AS WIN STATE]
                [ IF WIN STATE: BREAK AND RETURN NODE'S ACTION SEQUENCE]
            [ GET NODE'S CHILDREN ]
            [ ADD VALID CHILDREN TO QUEUE ]
            [ SAVE CURRENT BEST NODE ]
        '''
        '''
        EXAMPLE USE FOR EVOLUTION BASED AGENT:
        #expand the tree until the iterations runs out or a solution sequence is found
        while (iterations  0:
            iterations += 1
            [ MUTATE ]
            [ EVALUATE ]
                [ IF WIN STATE: BREAK AND RETURN ]
            [ SAVE CURRENT BEST ]
        '''
        return []       # set of actions
#####       EXAMPLE AGENTS      #####
# Do Nothing Agent code - the laziest of the agents
class DoNothingAgent(Agent):
    def getSolution(self, state, maxIterations):
        if maxIterations == -1:     # RIP your machine if you remove this block
            return []
        #make idle action set
        nothActionSet = []
        for i in range(20):
            nothActionSet.append({"x":0,"y":0})
        return nothActionSet
# Random Agent code - completes random actions
class RandomAgent(Agent):
    def getSolution(self, state, maxIterations):
        #make random action set
        randActionSet = []
        for i in range(20):
            randActionSet.append(random.choice(directions))
        return randActionSet
#####    ASSIGNMENT 1 AGENTS    #####
# BFS Agent code
class BFSAgent(Agent):
    def getSolution(self, state, maxIterations=-1):
        intializeDeadlocks(state)
        iterations = 0
        bestNode = None
        queue = [Node(state.clone(), None, None)]
        visited = set()
        #expand the tree until the iterations runs out or a solution sequence is found
        while (iterations  0:
            # YOUR CODE HERE
            currentNode = queue.pop(0)
            iterations += 1
            # Check if already Visited
            if currentNode.getHash() not in visited:
                # Check if Winning State
                if currentNode.checkWin():
                    bestNode = currentNode
                    break
                visited.add(currentNode.getHash())
                queue.extend(currentNode.getChildren())
                if bestNode is None or currentNode.getHeuristic()  0:
            iterations += 1
            # YOUR CODE HERE
            currentNode = stackDFS.pop()
            # Check if already Visited
            if currentNode.getHash() not in visited:
                # Check if Winning State
                if currentNode.checkWin():
                    bestNode = currentNode
                    break
                visited.add(currentNode.getHash())
                stackDFS.extend(currentNode.getChildren())
                if bestNode is None or currentNode.getHeuristic()  0:
            iterations += 1
            ## YOUR CODE HERE ##
            currentNode = queue.get()
            # check if Node is not already visited
            if currentNode.getHash() not in visited:
                # check if Node is in goal state, then set node as bestNode and break while loop
                if currentNode.state.checkWin():
                    bestNode = currentNode
                    break
                # if not goal state continue and add node to set of visited node
                visited.add(currentNode.getHash())
                # extract the children of the node and put in an array
                nodeChildren = []
                nodeChildren.extend(currentNode.getChildren())
                # insert the children nodes into the priority queue
                for child in nodeChildren:
                    queue.put(child)
                # update bestNode if the Heuristics of currNode is better, break tie with Cost
                if bestNode is None or currentNode.getHeuristic()  0):
            return self.children
        children = []
        #check every possible movement direction to create another child
        for d in directions:
            childState = self.state.clone()
            crateMove = childState.update(d["x"], d["y"])
            #if the node is the same spot as the parent, skip
            if childState.player["x"] == self.state.player["x"] and childState.player["y"] == self.state.player["y"]:
                continue
            #if this node causes the game to be unsolvable (i.e. putting crate in a corner), skip
            if crateMove and checkDeadlock(childState):
                continue
            #if this node has already been visited (same placement of player and crates as another seen node), skip
            if getHash(childState) in visited:
                continue
            #otherwise add the node as a child
            children.append(MCTSNode(childState, self, d, self.maxDist))
        self.children = list(children)    #save node children to generated child
        return children
    #calculates the score the distance from the starting point to the ending point (closer = better = larger number)
    def calcEvalScore(self,state):
        return self.maxDist - getHeuristic(state)
    #compares the score of 2 mcts nodes
    def __lt__(self, other):
        return self.q  0):
            node = self.bestChildUCT(node)
        return node.getActions()
    ####  MCTS SPECIFIC FUNCTIONS BELOW  ####
    #determines which node to expand next
    def treePolicy(self, rootNode):
        curNode = rootNode
        visited = []
        ## YOUR CODE HERE ##
        while not curNode.checkWin():
            visited.append(getHash(curNode.state))
            curNodeChildren = curNode.getChildren(visited)
            unvisitedChildren = []
            for child in curNodeChildren:
                if child.n == 0:
                    unvisitedChildren.append(child)
            if len(unvisitedChildren) > 0:
                curNode = random.choice(unvisitedChildren)
                return curNode
            curNode = self.bestChildUCT(curNode)
        return curNode
    # uses the exploitation/exploration algorithm
    def bestChildUCT(self, node):
        c = 1               #c value in the exploration/exploitation equation
        bestChild = None
        ## YOUR CODE HERE ##
        # get all the children of the node
        children = node.getChildren([])
        # find the visited node to prevent zero
        # division for child's value
        visitedChildren = []
        for child in children:
            if child.n > 0:
                visitedChildren.append(child)
        valueChildren = []
        for child in visitedChildren:
            value = (child.q/child.n) + \
                (c * math.sqrt((2 * math.log(node.n))/child.n))
            valueChildren.append((child, value))
        if valueChildren:
            valueChildren.sort(key=lambda x: x[1],

 README.md Sokoban Environment - NYU CS-GY6613 Prerequisites Requires python3 to run Install libraries $ pip install -r requirements.txt Run the Game Solve as a human $ python3 game.py --play $...

Solution

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment