def __init__(self, module, dataset=None, learningrate=0.01, lrdecay=1.0,
momentum=0., verbose=False, batchlearning=False,
weightdecay=0.):
"""Create a BackpropTrainer to train the specified `module` on the
specified `dataset`.
The learning rate gives the ratio of which parameters are changed into
the direction of the gradient. The learning rate decreases by `lrdecay`,
which is used to to multiply the learning rate after each training
step. The parameters are also adjusted with respect to `momentum`, which
is the ratio by which the gradient of the last timestep is used.
If `batchlearning` is set, the parameters are updated only at the end of
each epoch. Default is False.
`weightdecay` corresponds to the weightdecay rate, where 0 is no weight
decay at all.
"""
Trainer.__init__(self, module)
self.setData(dataset)
self.verbose = verbose
self.batchlearning = batchlearning
self.weightdecay = weightdecay
self.epoch = 0
self.totalepochs = 0
# set up gradient descender
self.descent = GradientDescent()
self.descent.alpha = learningrate
self.descent.momentum = momentum
self.descent.alphadecay = lrdecay
self.descent.init(module.params)
def __init__(
self,
task_name,
isdebug,
threshold=0.7,
gtformat='yxyx',
gen_box_by_gt=False,
ol_score=False,
draw_gt=False,
logs_path=LOGS_PATH,
model_path=MODEL_PATH,
):
Trainer.__init__(
self,
task_name=task_name,
isdebug=isdebug,
logs_path=logs_path,
model_path=model_path,
)
self.cur_loss = 0.0
self.threshold = threshold
gtformat = gtformat.lower()
self.gtformat = gtformat
if (not (gtformat in ['yxyx', 'xywh', 'mask'])): self.gtformat = 'yxyx'
self.gen_box_by_gt = gen_box_by_gt
self.ol_score = ol_score
self.draw_gt = bool(draw_gt)
def __init__(self, task_name,isdebug, logs_path = LOGS_PATH, model_path = MODEL_PATH, log_ft = True, log_grad = True): Trainer.__init__(self,task_name=task_name,isdebug=isdebug,logs_path = logs_path,model_path = model_path,) self.cur_loss = 0 self.log_ft = bool(log_ft) self.log_grad = bool(log_grad) self.log_img_sec = ['ScoreMask','EdgeMask','GTMask','Image',]
def __init__(self, module, ds_train=None, ds_val=None, gtol = 1e-05, norm = inf,
verbose = False, **kwargs):
"""
Create a BFGSTrainer to train the specified `module` on the
specified `dataset`.
"""
Trainer.__init__(self, module)
self.setData(ds_train)
self.ds_val = ds_val
self.verbose = verbose
self.epoch = 0
self.totalepochs = 0
self.train_errors = []
self.test_errors = []
self.optimal_params = None
self.optimal_epoch = 0
self.module = module
def __init__(self, module, dataset, totalIterations = 100,
xPrecision = finfo(float).eps, fPrecision = finfo(float).eps,
init_scg=True, **kwargs):
"""Create a SCGTrainer to train the specified `module` on the
specified `dataset`.
"""
Trainer.__init__(self, module)
self.setData(dataset)
self.input_sequences = self.ds.getField('input')
self.epoch = 0
self.totalepochs = 0
self.module = module
#self.tmp_module = module.copy()
if init_scg:
self.scg = SCG(self.module.params, self.f, self.df, self,
totalIterations, xPrecision, fPrecision,
evalFunc = lambda x: str(x / self.ds.getLength()))
else:
print "Warning: SCG trainer not initialized!"
def __init__(
self,
task_name,
isdebug=False,
logs_path=LOGS_PATH,
model_path=MODEL_PATH,
):
Trainer.__init__(
self,
task_name=task_name,
isdebug=isdebug,
logs_path=logs_path,
model_path=model_path,
)
self.cur_rpn_cross_entropy = 0.0
self.cur_rpn_loss_box = 0.0
self.cur_cross_entropy = 0.0
self.cur_loss_box = 0.0
self.cur_loss = 0.0
self.cur_gtbox_num = 0.0
def __init__(self,
module,
dataset=None,
learningrate=0.01,
lrdecay=1.0,
momentum=0.,
verbose=False,
batchlearning=False,
weightdecay=0.):
"""Create a BackpropTrainer to train the specified `module` on the
specified `dataset`.
The learning rate gives the ratio of which parameters are changed into
the direction of the gradient. The learning rate decreases by `lrdecay`,
which is used to to multiply the learning rate after each training
step. The parameters are also adjusted with respect to `momentum`, which
is the ratio by which the gradient of the last timestep is used.
If `batchlearning` is set, the parameters are updated only at the end of
each epoch. Default is False.
`weightdecay` corresponds to the weightdecay rate, where 0 is no weight
decay at all. weightdecay is regularisation parameter
"""
Trainer.__init__(self, module)
self.setData(dataset)
self.verbose = verbose
self.batchlearning = batchlearning
self.weightdecay = weightdecay
self.epoch = 0
self.totalepochs = 0
# set up gradient descender
self.descent = GradientDescent()
self.descent.alpha = learningrate
self.descent.momentum = momentum
self.descent.alphadecay = lrdecay
self.descent.init(module.params)
self.bestepoch = 0 #xuewen
def __init__(self, evolino_network, dataset, **kwargs):
"""
:key subPopulationSize: Size of the subpopulations.
:key nCombinations: Number of times each chromosome is built into an individual. default=1
:key nParents: Number of individuals left in a subpopulation after selection.
:key initialWeightRange: Range of the weights of the RNN after initialization. default=(-0.1,0.1)
:key weightInitializer: Initializer object for the weights of the RNN. default=Randomization(...)
:key mutationAlpha: The mutation's intensity. default=0.01
:key mutationVariate: The variate used for mutation. default=CauchyVariate(...)
:key wtRatio: The quotient: washout-time/training-time. Needed to
split the sequences into washout phase and training phase.
:key nBurstMutationEpochs: Number of epochs without increase of fitness in a row,
before burstmutation is applied. default=Infinity
:key backprojectionFactor: Weight of the backprojection. Usually
supplied through evolino_network.
:key selection: Selection object for evolino
:key reproduction: Reproduction object for evolino
:key burstMutation: BurstMutation object for evolino
:key evaluation: Evaluation object for evolino
:key verbosity: verbosity level
"""
Trainer.__init__(self, evolino_network)
self.network = evolino_network
self.setData(dataset)
ap = KWArgsProcessor(self, kwargs)
# misc
ap.add('verbosity', default=0)
# population
ap.add('subPopulationSize', private=True, default=8)
ap.add('nCombinations', private=True, default=4)
ap.add('nParents', private=True, default=None)
ap.add('initialWeightRange', private=True, default=(-0.1, 0.1))
ap.add('weightInitializer', private=True, default=Randomization(self._initialWeightRange[0], self._initialWeightRange[1]))
# mutation
ap.add('mutationAlpha', private=True, default=0.01)
ap.add('mutationVariate', private=True, default=CauchyVariate(0, self._mutationAlpha))
# evaluation
ap.add('wtRatio', private=True, default=(1, 3))
# burst mutation
ap.add('nBurstMutationEpochs', default=Infinity)
# network
ap.add('backprojectionFactor', private=True, default=float(evolino_network.backprojectionFactor))
evolino_network.backprojectionFactor = self._backprojectionFactor
# aggregated objects
ap.add('selection', default=EvolinoSelection())
ap.add('reproduction', default=EvolinoReproduction(mutationVariate=self.mutationVariate))
ap.add('burstMutation', default=EvolinoBurstMutation())
ap.add('evaluation', default=EvolinoEvaluation(evolino_network, self.ds, **kwargs))
self.selection.nParents = self.nParents
self._population = EvolinoPopulation(
EvolinoSubIndividual(evolino_network.getGenome()),
self._subPopulationSize,
self._nCombinations,
self._weightInitializer
)
filters = []
filters.append(self.evaluation)
filters.append(self.selection)
filters.append(self.reproduction)
self._filters = filters
self.totalepochs = 0
self._max_fitness = self.evaluation.max_fitness
self._max_fitness_epoch = self.totalepochs
