def __init__(self, game, **kwargs):
setAllArgs(self, kwargs)
self._game = game
self._avatar_types = []
self._abs_avatar_types = []
self._other_types = []
self._mortal_types = []
for skey in sorted(game.sprite_constr):
sclass, _, stypes = game.sprite_constr[skey]
if issubclass(sclass, Avatar):
self._abs_avatar_types += stypes[:-1]
self._avatar_types += [stypes[-1]]
if issubclass(sclass, RotatingAvatar) or issubclass(
sclass, ShootAvatar):
self.orientedAvatar = True
if skey not in game.sprite_groups:
continue
ss = game.sprite_groups[skey]
if len(ss) == 0:
continue
if isinstance(ss[0], Avatar):
assert issubclass(ss[0].physicstype, GridPhysics), \
'Not supported: Game must have grid physics, has %s'\
% (self._avatar.physicstype.__name__)
else:
self._other_types += [skey]
if not ss[0].is_static:
self.staticOther = False
assert self.staticOther, "not yet supported: all non-avatar sprites must be static. "
self._avatar_types = sorted(
set(self._avatar_types).difference(self._abs_avatar_types))
self.uniqueAvatar = (len(self._avatar_types) == 1)
#assert self.uniqueAvatar, 'not yet supported: can only have one avatar class'
# determine mortality
for skey, _, effect, _ in game.collision_eff:
if effect in kill_effects:
if skey in self._avatar_types + self._abs_avatar_types:
self.mortalAvatar = True
if skey in self._other_types:
self.mortalOther = True
self._mortal_types += [skey]
# retain observable features, and their colors
self._obstypes = {}
self._obscols = {}
for skey in self._other_types:
ss = game.sprite_groups[skey]
self._obstypes[skey] = [
self._sprite2state(sprite, oriented=False) for sprite in ss
if sprite.is_static
]
self._obscols[skey] = ss[0].color
if self.mortalOther:
self._gravepoints = {}
for skey in self._mortal_types:
for s in self._game.sprite_groups[skey]:
self._gravepoints[(skey, self._rect2pos(s.rect))] = True
def __init__(self, DS, **kwargs):
""" Initialize with the training data set DS. All keywords given are set as member variables.
The following are particularly important:
:key hidden: number of hidden units
:key TDS: test data set for checking convergence
:key VDS: validation data set for final performance evaluation
:key epoinc: number of epochs to train for, before checking convergence (default: 5)
"""
self.DS = DS
self.hidden = 10
self.maxepochs = 1000
self.Graph = None
self.TDS = None
self.VDS = None
self.epoinc = 5
setAllArgs(self, kwargs)
self.trainCurve = None
def __init__(self, evaluator = None, initEvaluable = None, **kwargs):
""" The evaluator is any callable object (e.g. a lambda function).
Algorithm parameters can be set here if provided as keyword arguments. """
# set all algorithm-specific parameters in one go:
self.__minimize = None
self.__evaluator = None
setAllArgs(self, kwargs)
# bookkeeping
self.numEvaluations = 0
self.numLearningSteps = 0
if self.storeAllEvaluated:
self._allEvaluated = []
self._allEvaluations = []
elif self.storeAllEvaluations:
self._allEvaluations = []
if evaluator is not None:
self.setEvaluator(evaluator, initEvaluable)
def set(self, **kwargs):
""" convenience method to set several member variables at once """
setAllArgs(self, kwargs)