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)