def __init__(self, evaluator, evaluable, **args):
""" The evaluator must be an episodic task, an the evaluable must be a module. """
assert isinstance(evaluator, EpisodicTask)
assert isinstance(evaluable, Module)
self.agent = self.subagent(evaluable.copy(), self.sublearner(**self.subargs))
self.agent.learner.setAlpha(self.learningRate)
self.agent.learner.gd.momentum = self.momentum
self.agent.copy = lambda: self.agent
self.module = evaluable.copy()
def wrappedEvaluator(module):
""" evaluate the internal agent (and changing its internal parameters),
and then transferring the parameters to the outside basenet """
self.agent.reset()
res = 0.
for dummy in range(self.learningBatches):
res += evaluator(self.agent)
res /= self.learningBatches
self.agent.learn()
module._setParameters(self.agent.module.params[:module.paramdim])
# the performance is measured on a greedy run:
res2 = evaluator(module)
if self.verbose:
print 'stoch', res, 'greedy', res2,
return res2
Learner.__init__(self, wrappedEvaluator, evaluable, **args)
def __init__(self, meta, layers=[], rate=.05, target=None, momentum=None, trans=None, wrange=100):
Learner.__init__(self, meta, target)
inputs = len(self.meta.names()) - 1
_, possible = self.meta[self.target]
self.outputs = possible
self.net = Net([inputs] + layers + [len(possible)], rate=rate, momentum=momentum, wrange=wrange, trans=trans)
def __init__(self, evaluator, evaluable, **args):
""" The evaluator must be an episodic task, an the evaluable must be a module. """
assert isinstance(evaluator, EpisodicTask)
assert isinstance(evaluable, Module)
self.agent = self.subagent(evaluable.copy(),
self.sublearner(**self.subargs))
self.agent.learner.setAlpha(self.learningRate)
self.agent.learner.gd.momentum = self.momentum
self.agent.copy = lambda: self.agent
self.module = evaluable.copy()
def wrappedEvaluator(module):
""" evaluate the internal agent (and changing its internal parameters),
and then transferring the parameters to the outside basenet """
self.agent.reset()
res = 0.
for dummy in range(self.learningBatches):
res += evaluator(self.agent)
res /= self.learningBatches
self.agent.learn()
module._setParameters(self.agent.module.params[:module.paramdim])
# the performance is measured on a greedy run:
res2 = evaluator(module)
if self.verbose:
print 'stoch', res, 'greedy', res2,
return res2
Learner.__init__(self, wrappedEvaluator, evaluable, **args)
def __init__(self, data, init_model, param): Learner.__init__(self, data, init_model, param) # print 'Hey, TheanoLearner is initializing!' ### mapping from input data to continuous integer indices # label_set['label'] = j self.label_map = get_label_map(self.labels) # feature_set['fea_id'] = k self.feature_map = get_feature_map(data.dat)
def __init__(self, name, selection_strategy):
"""
Initializes a new incremental learner
:param str name: The learner name
:param SelectionStrategy selection_strategy: The selection strategy
"""
Learner.__init__(self, "incremental_{}".format(name))
self.selection_strategy = selection_strategy
self.observer = observe.DispatchObserver()
def __init__(self, meta, rate, target=None):
Learner.__init__(self, meta, target)
length = len(meta.names())
_, possible = meta[self.target]
self.perceptrons = {}
for truthy, falsy in itertools.combinations(possible, 2):
self.perceptrons[(truthy, falsy)] = Perceptron(length, rate)
def __init__(self,
id,
quorum_size,
is_leader=False,
promised_id=None,
accepted_id=None,
accepted_value=None):
Proposer.__init__(self, id, quorum_size, is_leader)
Acceptor.__init__(self, id, promised_id, accepted_id, accepted_value)
Learner.__init__(self, id, quorum_size)
def __init__(self,
start,
goal,
Xrange,
Vrange,
num_actions=3,
max_memory=500,
hidden_size=200,
learning_rate=.001,
discount_factor=.99,
epsilon=.1):
Learner.__init__(self, start, goal, Xrange, Vrange, num_actions,
max_memory, hidden_size, learning_rate,
discount_factor, epsilon)
self.model1, self.model2 = self.build_model(), self.build_model()
def __init__(self,
kb,
n=None,
min_sup=1,
sim=1,
depth=4,
target=None,
use_negations=False,
optimal_subclass=True):
Learner.__init__(self,
kb,
n=n,
min_sup=min_sup,
sim=sim,
depth=depth,
target=target,
use_negations=use_negations)
def __init__(self, kb, n=None, min_sup=1, sim=1, depth=4, target=None,
use_negations=False, optimal_subclass=True):
Learner.__init__(self, kb, n=n, min_sup=min_sup, sim=sim, depth=depth,
target=target, use_negations=use_negations)
def __init__(self, rule_learner_name, max_hyperplanes_per_rule,
max_terms_per_rule):
Learner.__init__(self, "greedy_{}".format(rule_learner_name))
self.max_hyperplanes_per_rule = max_hyperplanes_per_rule
self.max_terms_per_rule = max_terms_per_rule
def __init__(self, module_properties, dao):
Learner.__init__(self, module_properties, dao, PassiveAggressiveClassifier(C=module_properties['C'],
loss=module_properties['loss'], shuffle=False))
def __init__(self, module_properties, dao):
Learner.__init__(self, module_properties, dao, SGDClassifier(loss=module_properties['loss'], penalty=module_properties['penalty'],
learning_rate=module_properties['step_policy'], eta0=module_properties['eta0'], average=module_properties['average'],
shuffle=False))
def __init__(self, k):
Learner.__init__(self)
self.k = k
