def getSensors(self):
""" the currently visible state of the world (the observation may be
stochastic - repeated calls returning different values)
@rtype: by default, this is assumed to be a numpy array of doubles
@note: This function is abstract and has to be implemented.
"""
abstractMethod()
def performAction(self, action):
""" perform an action on the world that changes it's internal state (maybe stochastically)
@param action: an action that should be executed in the Environment, by an agent.
@type action: tuple: (agentID, action value)
@note: This function is abstract and has to be implemented.
"""
abstractMethod()
def performAction(self, action):
""" perform an action on the world that changes it's internal state (maybe stochastically)
@param action: an action that should be executed in the Environment, by an agent.
@type action: tuple: (agentID, action value)
@note: This function is abstract and has to be implemented.
"""
abstractMethod()
def performAction(self, action):
""" perform an action on the world that changes it's internal state (maybe stochastically)
@param action: an action that should be executed in the Environment.
@type action: by default, this is assumed to be a numpy array of doubles
@note: This function is abstract and has to be implemented.
"""
abstractMethod()
def getSensors(self):
""" the currently visible state of the world (the observation may be
stochastic - repeated calls returning different values)
@rtype: by default, this is assumed to be a numpy array of doubles
@note: This function is abstract and has to be implemented.
"""
abstractMethod()
def performAction(self, action):
""" perform an action on the world that changes it's internal state (maybe stochastically)
@param action: an action that should be executed in the Environment.
@type action: by default, this is assumed to be a numpy array of doubles
@note: This function is abstract and has to be implemented.
"""
abstractMethod()
def train(self):
"""Train on the current dataset, for a single epoch."""
abstractMethod()
def _backwardImplementation(self, outerr, inerr, inbuf):
abstractMethod()
def distributionLength(self):
abstractMethod()
def getActionValues(self, state):
abstractMethod()
def calculateGradient(self):
abstractMethod()
def updater(self, pos, neg, poshb, neghb, posvb, negvb):
abstractMethod()
def mutate(self, **args):
""" Vary some properties of the underlying module, so that it's behavior
changes, (but not too abruptly). """
abstractMethod()
def removeFromEnv(self, env): #Called upon removing
abstractMethod()
def sampler(self, probabilities):
abstractMethod()
def updateState(self, env, dt): #dt in seconds
abstractMethod()
def draw(self, env):
abstractMethod()
def position(self):
abstractMethod()
def color(self): #Tuple of r, g, b
abstractMethod()
def _initPhysics(self, *args): #Responsibility is on the superclasses to create a shape and body
abstractMethod()
def __call__(self, *args, **kwargs):
""" @rtype: float """
abstractMethod()
def updater(self, pos, neg, poshb, neghb, posvb, negvb):
abstractMethod()
def _updateWeights(self, state, action, reward, next_state):
'''
Expected to update Q-value approximator.
'''
abstractMethod()
def _forwardImplementation(self, inbuf, outbuf):
"""Actual forward transformation function. To be overwritten in
subclasses."""
abstractMethod()
def calculateGradient(self):
abstractMethod()
def f(self, x):
""" The function itself, to be defined by subclasses """
abstractMethod()
def _learnStep(self):
""" The core method to be implemented by all subclasses. """
abstractMethod()
def combine(self, classifiers, input):
"""Receives list of trained classifers """
abstractMethod()
def produceOffspring(self):
""" generate the new generation of offspring, given the current population, and their fitnesses """
abstractMethod()
def _build(self, dataset):
abstractMethod()
def learn(self):
""" The main method, that invokes a learning step. """
abstractMethod()
def _forwardImplementation(self, inbuf, outbuf):
abstractMethod()
def _getCombinedDistribution(self, distributionMatrix, numClassifiers):
abstractMethod()
def initPopulation(self):
""" initialize the population """
abstractMethod()
def getDistribution(self, input):
"""Returns NumPy array of posterior distributions for each class."""
abstractMethod()
def randomize(self):
""" Sets all variable parameters to random values. """
abstractMethod()
def isFinished(self):
""" Is the current episode over? """
abstractMethod()
def f(self, x):
""" The function itself, to be defined by subclasses """
abstractMethod()
def produceOffspring(self):
""" generate the new generation of offspring, given the current population, and their fitnesses """
abstractMethod()
def doMove(self, player, action):
""" the core method to be implemented bu all TwoPlayerGames:
what happens when a player performs an action. """
abstractMethod()
def _forwardImplementation(self, inbuf, outbuf):
"""Actual forward transformation function. To be overwritten in
subclasses."""
abstractMethod()
def _learnStep(self):
""" The core method to be implemented by all subclasses. """
abstractMethod()
def __call__(self, *args, **kwargs):
""" @rtype: float """
abstractMethod()
def _qValues(self, state):
""" Return vector of probability of policy for all actions,
given the state(-features). """
abstractMethod()
def isFinished(self):
""" Is the current episode over? """
abstractMethod()
def topologyMutate(self):
abstractMethod()
def sampler(self, probabilities):
abstractMethod()
def learn(self):
""" learn on the current dataset, for a single epoch
@note: has to be implemented by all subclasses. """
abstractMethod()
def getAction(self):
""" Return a chosen action.
:rtype: by default, this is assumed to ba a numpy array of doubles.
:note: This method is abstract and needs to be implemented.
"""
abstractMethod()
def doMove(self, player, action):
""" the core method to be implemented bu all TwoPlayerGames:
what happens when a player performs an action. """
abstractMethod()
def randomize(self):
""" randomly set all variable parameters """
abstractMethod()
def updateData(self):
""" overwrite this class to update whatever data the renderer needs to display the current
state of the world. """
abstractMethod()
def getAction(self):
""" return a chosen action.
@rtype: by default, this is assumed to ba a numpy array of doubles.
@note: This method is abstract and needs to be implemented.
"""
abstractMethod()
def _render(self):
""" Here, the render methods are called. This function has to be implemented by subclasses. """
abstractMethod()
def getMaxAction(self, state):
abstractMethod()
def learn(self):
""" The main method, that invokes a learning step. """
abstractMethod()
def getReward(self):
""" Compute and return the current reward (i.e. corresponding to the last action performed) """
return abstractMethod()
def initPopulation(self):
""" initialize the population """
abstractMethod()