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])