def __init__(self, extractor='IdentityExtractor', **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
numpy.set_printoptions(precision=2, suppress=True)
# You might want to initialize weights here.
self.all_directions = [Directions.NORTH,
Directions.SOUTH,
Directions.EAST,
Directions.WEST,
Directions.STOP]
self.alpha = 0.01
self.areaRad = 5
self.biais = 1.0
self.features = ['food', 'ghost', 'wall']
self.out_of_map = {'ghost': 0, 'wall': 0, 'food': 0}
self.w = []
for feature in self.features:
temp = []
for i in range(0, 2 * self.areaRad + 1):
temp.append([])
for j in range(0, 2 * self.areaRad + 1):
temp[i].append(1.0)
self.w.append(temp)
# Try to load the weights
self.load_weights()
def registerInitialState(self, gameState):
"""
This method handles the initial setup of the
agent to populate useful fields (such as what team
we're on).
A distanceCalculator instance caches the maze distances
between each pair of positions, so your agents can use:
self.distancer.getDistance(p1, p2)
"""
self.red = gameState.isOnRedTeam(self.index)
self.distancer = distanceCalculator.Distancer(gameState.data.layout)
# comment this out to forgo maze distance computation and use manhattan distances
self.distancer.getMazeDistances()
import __main__
if '_display' in dir(__main__):
self.display = __main__._display
inferenceType = util.lookup('ParticleFilter', globals())
self.inferenceModules = [inferenceType(o,self.index) for o in self.getOpponents(gameState)]
for inference in self.inferenceModules: inference.initialize(gameState)
self.ghostBeliefs = [inf.getBeliefDistribution() for inf in self.inferenceModules]
self.firstMove = True
def __init__(
self, index=0, inference="ExactInference", ghostAgents=None, observeEnable=True, elapseTimeEnable=True
):
inferenceType = util.lookup(inference, globals())
self.inferenceModules = [inferenceType(a) for a in ghostAgents]
self.observeEnable = observeEnable
self.elapseTimeEnable = elapseTimeEnable
def __init__(self, extractor='IdentityExtractor', **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
# You might want to initialize weights here.
"*** YOUR CODE HERE ***"
self.weights = util.Counter()
self.globalvar = 1
# Define NN
self.model = Sequential()
self.model.add(Dense(300, init='lecun_uniform', input_shape=(5,)))
self.model.add(Activation('relu'))
self.model.add(Dense(300, init='lecun_uniform'))
self.model.add(Activation('relu'))
self.model.add(Dense(300, init='lecun_uniform'))
self.model.add(Activation('relu'))
self.model.add(Dense(5, init='lecun_uniform'))
self.model.add(Activation('linear'))
rms = RMSprop()
self.model.compile(loss='mse', optimizer=rms)
self.atoi = {'North': 0, 'South': 1, 'East': 2, 'West': 3, 'Stop': 4}
def __init__(self, extractor='IdentityExtractor', **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
# You might want to initialize weights here.
"*** YOUR CODE HERE ***"
self.weights = util.Counter()
def __init__(self, extractor='IdentityExtractor', **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
#self.epsilon = 0.05
#self.gamma = 0.8
#self.alpha = 0.2
# You might want to initialize weights here.
self.all_directions = [Directions.NORTH,
Directions.SOUTH,
Directions.EAST,
Directions.WEST,
Directions.STOP]
self.nb_states = 0
self.closest_food = None
self.featureQ = [self.ghost_west, self.ghost_east, self.ghost_north, self.ghost_south,
self.no_wall_west, self.no_wall_east, self.no_wall_north, self.no_wall_south,
#self.posx, self.posy, self.biais,
self.close_dot_west, self.close_dot_east, self.close_dot_north, self.close_dot_south]
self.w = {}
for action in self.all_directions:
temp = []
for i in range(0, len(self.featureQ)):
temp.append(1.0)
self.w[action] = temp
def __init__(self, index, fnStrategy='defaultstrategy'):
self.index=index
strategies = fnStrategy.split(';')
try:
self.strategy = util.lookup(strategies[index%len(strategies)], globals())
except:
print "Function "+strategies[index%len(strategies)]+" not defined!"
print "Loading defaultstrategy..."
self.strategy = defaultstrategy
def getattr(self, name):
ret = None
if self.path is not None:
ret = findOnPath(name, self.path)
if ret is not None:
ret.name = self.name+'.'+ret.name
return ret
if self.mod is None:
self.mod = lookup(self.name)
return Namespace.getattr(self, name)
def _process_batch(session, posts, dests, modes, **kwargs):
"""
Request commute distances and durations for a batch of posts.
"""
posts_latlon = [(_.latitude, _.longitude) for _ in posts]
for mode in modes:
response = gmaps.distance_matrix(posts_latlon, dests, mode, **kwargs)
for post, row in zip(posts, response['rows']):
post.commutes.extend([
Commute(dest=lookup(session, Destination, dest),
mode=lookup(session, Mode, mode),
distance=e['distance']['value'],
duration=e['duration']['value'])
for dest, e in zip(dests, row['elements'])
if e['status'] == 'OK'
])
def __init__(self, evalFn = 'scoreEvaluationFunction', depth = '2', a=0,b=0,c=0,d=0,e=0,f=0): self.index = 0 # Pacman is always agent index 0 self.depth = int(depth) storeConstants(a, b, c, d, e, f) # self.a = a # print "a: ", a # b = b # c = c # d = d # e = e # f = f self.evaluationFunction = util.lookup(evalFn, globals())
def __init__(self, extractor='IdentityExtractor', **args):
if extractor in args:
extractor = args['extractor']
self.featExtractor = util.lookup(extractor, globals())()
SarsaLambdaAgent.__init__(self, **args)
# You might want to initialize weights here.
"*** YOUR CODE HERE ***"
# we are not using values
self.weights = util.Counter()
self.workingWeights = util.Counter()
self.times = 0
def addPackage(self, package, skiplist=[]):
pkg = lookup(package)
base = package.replace(DOT, SLASH)
for cl in listAllClasses(pkg):
name = package + "." + cl
if name in skiplist:
# print 'skipping',name # ?? dbg
continue
entryname = base + "/" + cl + ".class"
self.zipfile.putNextEntry(ZipEntry(entryname))
instream = openResource(entryname)
copy(instream, self.zipfile)
instream.close()
def __init__(self, index, fnStrategy='defaultstrategy'):
self.index=index
self.xCapsule = self.yCapsule = -1
strategies = fnStrategy.split(';')
global ghostN
ghostN = "all" if len(strategies) > 1 else strategies[0]
try:
self.strategy = util.lookup(strategies[index%len(strategies)], globals())
except:
print "Function "+strategies[index%len(strategies)]+" not defined!"
self.strategy = default
def __init__(self, extractor='FeatureLearner', processFreq=processingFrequency, **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
# Weight Initialization
self.featuresWeights = util.Counter()
self.rewardCounter = util.Counter()
self.rewardDict = util.Counter()
# We use the processingFrequency only if we are in
# the featExtractor is a FeatureLearner (= we have a deep learning agent)
self.processingFrequency = processingFrequency #if self.featExtractor==FeatureLearner else 10e9
def __init__(self, numDecks=1, qvalues=util.Counter(), epsilon=0.05, gamma=0.8, alpha=0.2, numTraining=1000, extractor='SimpleExtractor'):
"""
Init appropriated from qlearningAgents.py from
pacman reinforcement assignment.
"""
self.epsilon = epsilon
self.discount = gamma
self.alpha = alpha
self.numTraining = numTraining
self.dealer = Dealer.Dealer(numDecks, True) # True = Silent Mode; Agent must be modified later to actually accept a dealer
self.qvalues = qvalues
self.weights = util.Counter()
self.featExtractor = util.lookup(extractor, globals())()
def __init__(self, extractor='IdentityExtractor', **args):
if extractor in args:
extractor = args['extractor']
self.featExtractor = util.lookup(extractor, globals())()
# You might want to initialize weights here.
"*** YOUR CODE HERE ***"
self.mdp = args['mdp']
self.discount = args['gamma']
self.iterations = args['iterations']
self.alpha = args['alpha']
self.weights = util.Counter()
self.times = 0
if False: #extractor == 'BairdsExtractor':
# doing evil thing here
self.weights[0] = 1
self.weights[1] = 1
self.weights[2] = 1
self.weights[3] = 1
self.weights[4] = 1
self.weights[5] = 1
self.weights[6] = 1
# do update, full backup (sweep every state)
for time in range(self.iterations):
for state in self.mdp.getStates():
if not self.mdp.isTerminal(state):
# find the best action
maxValue = None
bestAction = None
for action in self.mdp.getPossibleActions(state):
thisValue = self.getQValue(state, action)
if bestAction == None or thisValue > maxValue:
maxValue = thisValue
bestAction = action
for nextState, prob in self.mdp.getTransitionStatesAndProbs(state, bestAction):
self.update(state, action, nextState, self.mdp.getReward(state, action, nextState), prob)
self.outputWeights(time)
self.outputValues(time)
self.outputMSE(time)
def getFile(name):
dot = name.rfind('.')
if dot == -1:
return PkgEntry(name)
## return topFile(name)
package = lookup(name[:dot])
if isinstance(package, PyJavaPackage):
return PkgEntry(name)
## if hasattr(package, '__file__'):
## return ZipEntry(package.__file__, name)
## elif hasattr(package, '__path__') and len(package.__path__) == 1:
## return DirEntry(package.__path__[0], name)
elif isinstance(package, TypeType):
# this 'package' is a java class
f = getFile(name[:dot])
if f:
return f
def __init__(self, extractor='StateExtractor'):
# Feature extractor
self.featExtractor = util.lookup(extractor, globals())()
# Transition function (data structure required for the transition function)
#*** YOUR CODE STARTS HERE ***"
# Code to remove ---------- from here
self.frequencies = util.Counter()
# Code to remove ---------- to here
#"*** YOUR CODE FINISHES HERE ***"
# Dictionary with examples of a Low state for each High state: it serves to get possible actions
# and to check terminal states (though it is not required if the high level representation
# capture them)
self.states = util.Counter()
# Reward for each state at the high level representation
self.reward = util.Counter()
def __init__(self, **args):
"""Uses the SimpleExtractor feature extractor with a 2-layer network
(affine-relu-affine-relu) with an L2 loss to predict Q values."""
self.featExtractor = util.lookup("SimpleExtractor", globals())()
PacmanQAgent.__init__(self, **args)
self.sess = tf.Session()
self.allFeats = list(self.featExtractor.getFeatures(None, None))
numDims = len(self.allFeats)
self.x = tf.placeholder("float", shape=[None, numDims])
self.y_ = tf.placeholder("float", shape=[None, 1])
self.W1 = tf.Variable(tf.truncated_normal([numDims, 5], stddev=0.01))
self.b1 = tf.Variable(tf.constant(0.01, shape=[5]))
self.W2 = tf.Variable(tf.truncated_normal([5, 1]))
self.b2 = tf.Variable(tf.constant(0.01, shape=[1]))
self.h = tf.nn.relu(tf.matmul(self.x, self.W1) + self.b1)
self.out = tf.nn.relu(tf.matmul(self.h, self.W2) + self.b2)
self.l2_loss = tf.reduce_sum(tf.square(self.y_ - self.out))
self.train_step = tf.train.AdamOptimizer(1e-4).minimize(self.l2_loss)
self.sess.run(tf.initialize_all_variables())
def __init__(self, extractor='IdentityExtractor', **args):
if extractor in args:
extractor = args['extractor']
self.featExtractor = util.lookup(extractor, globals())()
TGLearningAgent.__init__(self, **args)
# You might want to initialize weights here.
"*** YOUR CODE HERE ***"
self.weights = util.Counter()
self.times = 0
if extractor == 'BairdsExtractor':
# doing evil thing here
self.weights[0] = 1
self.weights[1] = 1
self.weights[2] = 1
self.weights[3] = 1
self.weights[4] = 1
self.weights[5] = 10
self.weights[6] = 1
def __init__( self, index = 0, inference = "ExactInference", ghostAgents = None, observeEnable = True, elapseTimeEnable = True, obsOnStopOnly = False,
prior = False, rolloutPolicy='Uniform'):
inferenceType = util.lookup(inference, globals())
if prior:
self.inferenceModules = [inferenceType(a, prior) for a in ghostAgents]
else:
self.inferenceModules = [inferenceType(a) for a in ghostAgents]
self.observeEnable = observeEnable
self.elapseTimeEnable = elapseTimeEnable
self.ghostAgents = ghostAgents
self.obsOnStopOnly = obsOnStopOnly
self.lastAction = None
self.rolloutPolicy = rolloutPolicy
self.gamma = 0.99
self.epsilon = 0.01
self.c = 500.0
self.numSimulations = 200
self.depth = 10
self.searchTree = {}
self.searchTree[()] = [0,0]
def process_item(self, item, spider):
"""
Save items to the database.
"""
session = self.Session()
post = ApartmentPost(**item)
tags = item['tags'].split('|')
post.post_tags = [
ApartmentPostTag(tag=lookup(session, ApartmentTag, tag_name))
for tag_name in tags
]
try:
session.add(post)
session.commit()
except:
session.rollback()
raise
finally:
session.close()
return item
def __init__(self, evalFn="scoreEvaluation"): self.evaluationFunction = util.lookup(evalFn, globals()) assert self.evaluationFunction != None
# multiAgents.py
def __init__(self, extractor='IdentityExtractor', **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
"*** YOUR CODE HERE ***"
self.W = util.Counter()
def __init__(self, index=0, inference="ExactInference", ghostAgents=None):
inferenceType = util.lookup(inference, globals())
self.inferenceModules = [inferenceType(a) for a in ghostAgents]
def __init__(self, extractor='IdentityExtractor', **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
"*** YOUR CODE HERE ***"
self.W = util.Counter()
def __init__(self, evalFn = 'scoreEvaluationFunction', depth = '2'):
self.index = 0 # Pacman is always agent index 0
self.evaluationFunction = util.lookup(evalFn, globals())
self.depth = int(depth)
def __init__( self, index = 0, inference = "ExactInference", ghostAgents = None ): inferenceType = util.lookup(inference, globals()) self.inferenceModules = [inferenceType(a) for a in ghostAgents]
def __init__(self, evaluation_function='scoreEvaluationFunction', depth=2):
self.evaluation_function = util.lookup(evaluation_function, globals())
self.depth = depth
def __init__(self, evalFn="scoreEvaluationFunction", depth="2"):
self.index = 0 # Pacman is always agent index 0
self.evaluationFunction = util.lookup(evalFn, globals())
self.depth = int(depth)
self.nextagent = "max"
self.ghostidx = 1
def __init__(self, evalFn='scoreEvaluationFunction', depth='2'):
self.index = 0 # Pacman is always agent index 0
self.evaluationFunction = util.lookup(evalFn, globals())
self.depth = int(depth)
self.notFirstIteration = False
self.currentPlayer = 0
def __init__( self, index = 0, inference = "ExactInference", ghostAgents = None, observeEnable = True, elapseTimeEnable = True):
inferenceType = util.lookup(inference, globals())
self.inferenceModules = [inferenceType(a) for a in ghostAgents]
self.observeEnable = observeEnable
self.elapseTimeEnable = elapseTimeEnable
def __init__(self, extractor='IdentityExtractor', **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
self.weights = util.Counter()
def __init__(self, evalFn='scoreEvaluationFunction', depth='2'):
self.index = 0 # Pacman is always agent index 0
self.evaluationFunction = util.lookup(evalFn, globals())
self.depth = int(depth)
def __init__(self, extractor='IdentityExtractor', **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
# You might want to initialize weights here.
"*** YOUR CODE HERE ***"
def __init__(self, index, evalFun='scoreEvaluationFunctionGhost', depth=2):
self.index = index
self.evaluationFunction = util.lookup(evalFun, globals())
self.depth = int(depth)
def __init__(self, evalFn="scoreEvaluation"):
self.evaluationFunction = util.lookup(evalFn, globals())
assert self.evaluationFunction != None
def __init__(self, evalFn = 'betterEvaluationFunction', depth = '2'): self.index = 0 # Pacman is always agent index 0 self.evaluationFunction = util.lookup(evalFn, globals()) self.depth = int(depth) self._turn_durations = []
def __init__(self, evalFn='contest'):
self.index = 0
self.evaluationFunction = util.lookup(evalFn, globals())
self.depth = 3
def __init__(self, extractor="IdentityExtractor", **args):
self.featExtractor = util.lookup(extractor, globals())()
PacmanQAgent.__init__(self, **args)
self.weights = util.Counter()
def main():
parser = argparse.ArgumentParser(description='2048 game.')
parser.add_argument('--random_seed',
help='The seed for the random state.',
default=numpy.random.randint(100),
type=int)
displays = ['GUI', 'SummaryDisplay']
agents = [
'KeyboardAgent', 'ReflexAgent', 'MinmaxAgent', 'AlphaBetaAgent',
'ExpectimaxAgent'
]
parser.add_argument('--display',
choices=displays,
help='The game ui.',
default=displays[0],
type=str)
parser.add_argument('--agent',
choices=agents,
help='The agent.',
default=agents[0],
type=str)
parser.add_argument(
'--depth',
help='The maximum depth for to search in the game tree.',
default=2,
type=int)
parser.add_argument('--sleep_between_actions',
help='Should sleep between actions.',
default=False,
type=bool)
parser.add_argument('--num_of_games',
help='The number of games to run.',
default=1,
type=int)
parser.add_argument(
'--num_of_initial_tiles',
help='The number non empty tiles when the game started.',
default=2,
type=int)
parser.add_argument('--initial_board',
help='Initial board for new games.',
default=None,
type=str)
parser.add_argument('--evaluation_function',
help='The evaluation function for ai agent.',
default='score_evaluation_function',
type=str)
args = parser.parse_args()
numpy.random.seed(args.random_seed)
if args.display != displays[0]:
display = util.lookup('displays.' + args.display, globals())()
else:
display = None
if args.agent != agents[0]:
agent = create_agent(args)
else:
agent = None
initial_state = None
if args.initial_board is not None:
with open(os.path.join('layouts', args.initial_board), 'r') as f:
lines = f.readlines()
initial_board = numpy.array([
list(map(lambda x: int(x), line.split(','))) for line in lines
])
initial_state = GameState(board=initial_board)
game_runner = GameRunner(display=display,
agent=agent,
num_of_initial_tiles=args.num_of_initial_tiles,
sleep_between_actions=args.sleep_between_actions)
for i in range(args.num_of_games):
score = game_runner.new_game(initial_state=initial_state)
if display is not None:
display.print_stats()
