def _evaluateSequence(self, f, seq, verbose=False):
"""Return the ponderated MSE over one sequence."""
totalError = 0.
ponderation = 0.
for input, target in seq:
res = f(input)
e = 0.5 * sum((target - res).flatten()**2)
totalError += e
ponderation += len(target)
if verbose:
print('out: ', fListToString(list(res)))
print('correct:', fListToString(target))
print('error: % .8f' % e)
return totalError, ponderation
def _evaluateSequence(self, f, seq, verbose=False):
""" return the importance-ponderated MSE over one sequence. """
totalError = 0
ponderation = 0.
for input, target, importance in seq:
res = f(input)
e = 0.5 * dot(importance.flatten(), ((target - res).flatten()**2))
totalError += e
ponderation += sum(importance)
if verbose:
print('out: ', fListToString(list(res)))
print('correct: ', fListToString(target))
print('importance:', fListToString(importance))
print('error: % .8f' % e)
return totalError, ponderation
def _updateShaping(self):
""" Daan: "This won't work. I like it!" """
assert self.numberOfCenters == 1
possible = self.shapingFunction.getPossibleParameters(self.windowSize)
matchValues = []
pdfs = [
multivariateNormalPdf(s, self.mus[0], self.sigmas[0])
for s in self.samples
]
for p in possible:
self.shapingFunction.setParameter(p)
transformedFitnesses = self.shapingFunction(self.fitnesses)
#transformedFitnesses /= sum(transformedFitnesses)
sumValue = sum([
x * log(y) for x, y in zip(pdfs, transformedFitnesses) if y > 0
])
normalization = sum(
[x * y for x, y in zip(pdfs, transformedFitnesses) if y > 0])
matchValues.append(sumValue / normalization)
self.shapingFunction.setParameter(possible[argmax(matchValues)])
if len(self.allsamples) % 100 == 0:
print(possible[argmax(matchValues)])
print(fListToString(matchValues, 3))
def _oneGeneration(self):
self.oldPops.append(self.pop)
self.generation += 1
fitnesses = self._evaluatePopulation()
# store best in hall of fame
besti = argmax(array(fitnesses))
best = self.pop[besti]
bestFits = sorted(fitnesses)[::-1][:self._numSelected()]
self.hallOfFame.append(best)
self.hallOfFitnesses.append(bestFits)
if self.verbose:
print('Generation', self.generation)
print(' relat. fits:', fListToString(sorted(fitnesses), 4))
if len(best.params) < 20:
print(' best params:', fListToString(best.params, 4))
self.pop = self._selectAndReproduce(self.pop, fitnesses)
def trainUntilConvergence(self,
dataset=None,
maxEpochs=None,
verbose=None,
continueEpochs=10,
validationProportion=0.25):
"""Train the module on the dataset until it converges.
Return the module with the parameters that gave the minimal validation
error.
If no dataset is given, the dataset passed during Trainer
initialization is used. validationProportion is the ratio of the dataset
that is used for the validation dataset.
If maxEpochs is given, at most that many epochs
are trained. Each time validation error hits a minimum, try for
continueEpochs epochs to find a better one."""
epochs = 0
if dataset == None:
dataset = self.ds
if verbose == None:
verbose = self.verbose
# Split the dataset randomly: validationProportion of the samples for
# validation.
trainingData, validationData = (
dataset.splitWithProportion(1 - validationProportion))
if not (len(trainingData) > 0 and len(validationData)):
raise ValueError(
"Provided dataset too small to be split into training " +
"and validation sets with proportion " +
str(validationProportion))
self.ds = trainingData
bestweights = self.module.params.copy()
bestverr = self.testOnData(validationData)
trainingErrors = []
validationErrors = [bestverr]
while True:
trainingErrors.append(self.train())
validationErrors.append(self.testOnData(validationData))
if epochs == 0 or validationErrors[-1] < bestverr:
# one update is always done
bestverr = validationErrors[-1]
bestweights = self.module.params.copy()
if maxEpochs != None and epochs >= maxEpochs:
self.module.params[:] = bestweights
break
epochs += 1
if len(validationErrors) >= continueEpochs * 2:
# have the validation errors started going up again?
# compare the average of the last few to the previous few
old = validationErrors[-continueEpochs * 2:-continueEpochs]
new = validationErrors[-continueEpochs:]
if min(new) > max(old):
self.module.params[:] = bestweights
break
trainingErrors.append(self.testOnData(trainingData))
self.ds = dataset
if verbose:
print('train-errors:', fListToString(trainingErrors, 6))
print('valid-errors:', fListToString(validationErrors, 6))
return trainingErrors, validationErrors
def writeDoubles(self, node, l, precision=6):
self.addTextNode(node, fListToString(l, precision)[2:-1])
