def test_n_parameters(self): # Create error measure error = pints.ProbabilityBasedError(self.problem) # Get number of parameters n_parameters = error.n_parameters() # Check number of parameters self.assertEqual(n_parameters, 3)
def test_call(self): # Create error measure error = pints.ProbabilityBasedError(self.problem) # Evaluate likelihood for test parameters test_parameters = [1, 2, 3] score = error(test_parameters) # Check that error returns expected value self.assertEqual(score, -10)
def test_probability_based_error(self): """ Tests :class:`pints.ProbabilityBasedError`. """ p = MiniLogPDF() e = pints.ProbabilityBasedError(p) self.assertEqual(e.n_parameters(), 3) self.assertEqual(e([1, 2, 3]), -10) p = MiniProblem() self.assertRaises(ValueError, pints.ProbabilityBasedError, p) # Test derivatives x = [1, 2, 3] y, dy = e.evaluateS1(x) self.assertEqual(y, e(x)) self.assertEqual(dy.shape, (3, )) self.assertTrue(np.all(dy == [-1, -2, -3]))
def test_evaluateS1(self): # Create error measure error = pints.ProbabilityBasedError(self.problem) # Evaluate likelihood for test parameters test_parameters = [1, 2, 3] score, deriv = error.evaluateS1(test_parameters) # Check that error returns expected value self.assertEqual(score, error(test_parameters)) # Check dimension of partial derivatives self.assertEqual(deriv.shape, (3, )) # Check that partials are computed correctly self.assertEqual(deriv[0], -1) self.assertEqual(deriv[1], -2) self.assertEqual(deriv[2], -3)
def __init__(self, function, x0, sigma0=None, boundaries=None, method=None): # Convert x0 to vector # This converts e.g. (1, 7) shapes to (7, ), giving users a bit more # freedom with the exact shape passed in. For example, to allow the # output of LogPrior.sample(1) to be passed in. x0 = pints.vector(x0) # Check dimension of x0 against function if function.n_parameters() != len(x0): raise ValueError( 'Starting point must have same dimension as function to' ' optimise.') # Check if minimising or maximising self._minimising = not isinstance(function, pints.LogPDF) # Store function if self._minimising: self._function = function else: self._function = pints.ProbabilityBasedError(function) del (function) # Create optimiser if method is None: method = pints.CMAES elif not issubclass(method, pints.Optimiser): raise ValueError('Method must be subclass of pints.Optimiser.') self._optimiser = method(x0, sigma0, boundaries) # Logging self._log_to_screen = True self._log_filename = None self._log_csv = False self.set_log_interval() # Parallelisation self._parallel = False self._n_workers = 1 self.set_parallel() # # Stopping criteria # # Maximum iterations self._max_iterations = None self.set_max_iterations() # Maximum unchanged iterations self._max_unchanged_iterations = None self._min_significant_change = 1 self.set_max_unchanged_iterations() # Threshold value self._threshold = None # Post-run statistics self._evaluations = None self._iterations = None self._time = None
def __init__( self, function, x0, sigma0=None, boundaries=None, transformation=None, method=None): # Convert x0 to vector # This converts e.g. (1, 7) shapes to (7, ), giving users a bit more # freedom with the exact shape passed in. For example, to allow the # output of LogPrior.sample(1) to be passed in. x0 = pints.vector(x0) # Check dimension of x0 against function if function.n_parameters() != len(x0): raise ValueError( 'Starting point must have same dimension as function to' ' optimise.') # Check if minimising or maximising self._minimising = not isinstance(function, pints.LogPDF) # Apply a transformation (if given). From this point onward the # optimiser will see only the transformed search space and will know # nothing about the model parameter space. if transformation is not None: # Convert error measure or log pdf if self._minimising: function = transformation.convert_error_measure(function) else: function = transformation.convert_log_pdf(function) # Convert initial position x0 = transformation.to_search(x0) # Convert sigma0, if provided if sigma0 is not None: sigma0 = transformation.convert_standard_deviation(sigma0, x0) if boundaries: boundaries = transformation.convert_boundaries(boundaries) # Store transformation for later detransformation: if using a # transformation, any parameters logged to the filesystem or printed to # screen should be detransformed first! self._transformation = transformation # Store function if self._minimising: self._function = function else: self._function = pints.ProbabilityBasedError(function) del function # Create optimiser if method is None: method = pints.CMAES elif not issubclass(method, pints.Optimiser): raise ValueError('Method must be subclass of pints.Optimiser.') self._optimiser = method(x0, sigma0, boundaries) # Check if sensitivities are required self._needs_sensitivities = self._optimiser.needs_sensitivities() # Track optimiser's f_best or f_guessed self._use_f_guessed = None self.set_f_guessed_tracking() # Logging self._log_to_screen = True self._log_filename = None self._log_csv = False self.set_log_interval() # Parallelisation self._parallel = False self._n_workers = 1 self.set_parallel() # User callback self._callback = None # :meth:`run` can only be called once self._has_run = False # # Stopping criteria # # Maximum iterations self._max_iterations = None self.set_max_iterations() # Maximum unchanged iterations self._unchanged_max_iterations = None # n_iter w/o change until stop self._unchanged_threshold = 1 # smallest significant f change self.set_max_unchanged_iterations() # Maximum evaluations self._max_evaluations = None # Threshold value self._threshold = None # Post-run statistics self._evaluations = None self._iterations = None self._time = None
# Create a new log-likelihood function (adds an extra parameter!) log_likelihood = pints.GaussianLogLikelihood(problem) # Create a new prior large = 1e9 param_prior = pints.MultivariateGaussianLogPrior( mu_0, large * np.eye(len(mu_0))) noise_prior = pints.UniformLogPrior([lower_bounds[-1]], [upper_bounds[-1]]) log_prior = pints.ComposedLogPrior(param_prior, noise_prior) # Create a posterior log-likelihood (log(likelihood * prior)) log_posterior = pints.LogPosterior(log_likelihood, log_prior) log_posteriors.append(log_posterior) score = pints.ProbabilityBasedError(log_posterior) if synthetic: found_parameters = list(true_parameters) + [noise] else: found_parameters, found_value = pints.optimise(score, x0, sigma0, boundaries, method=pints.CMAES) sampler = pints.AdaptiveCovarianceMCMC(found_parameters) samplers.append(sampler) pickle.dump((samplers, log_posteriors), open(pickle_file, 'wb')) else: