Spelling swapped to US, renamed some classes, removed long testing for travis compatibility

Author: Alan-Robertson

src/qinfer/hyper_heuristic_optimisers.py

@@ -38,9 +38,9 @@
 
 ## CLASSES ####################################################################
 
-class Optimiser(object):
+class Optimizer(object):
     '''
-        A generic optimiser class that is inherited by the other optimisation functions.
+        A generic optimizer class that is inherited by the other optimisation functions.
 
         :param np.ndarray param_names: The list of parameters that are being searched over.
         :param function fitness_function: The function that is being optimised over, defaults to perf test multiple
@@ -64,7 +64,7 @@ def __init__(
         self._funct_kwargs = funct_kwargs
 
         if fitness_function is None: # Default to calling perf test multiple
-            self._fitness_function = PerfTestMultipleAbstractor(
+            self._fitness_function = HeuristicPerformanceFitness(
                 self._param_names,
                 *self._funct_args,
                 **self._funct_kwargs
@@ -77,9 +77,9 @@ def fitness_function(self, params):
         return self._fitness_function(params)
 
     def parallel(self):
-        raise NotImplementedError("This optimiser does not have parallel support.")
+        raise NotImplementedError("This optimizer does not have parallel support.")
 
-class ParticleSwarmOptimiser(Optimiser):
+class ParticleSwarmOptimizer(Optimizer):
     '''
         A particle swarm optimisation based hyperheuristic
         :param integer n_pso_iterations:
@@ -200,7 +200,7 @@ def fitness_dt(self):
             ('fitness', np.float64)])
 
 
-class ParticleSwarmSimpleAnnealingOptimiser(ParticleSwarmOptimiser):
+class ParticleSwarmSimpleAnnealingOptimizer(ParticleSwarmOptimizer):
 
     def __call__(self,
         n_pso_iterations=50,
@@ -293,7 +293,7 @@ def update_pso_params(self, temperature, omega_v, phi_p, phi_g):
         return omega_v, phi_p, phi_g
 
 
-class ParticleSwarmTemperingOptimiser(ParticleSwarmOptimiser):
+class ParticleSwarmTemperingOptimizer(ParticleSwarmOptimizer):
     '''
         A particle swarm optimisation based hyperheuristic
         :param integer n_pso_iterations:
@@ -444,7 +444,7 @@ def distribute_particles(self, n_pso_particles, n_temper_categories):
 
         return temper_map
 
-class PerfTestMultipleAbstractor(object):
+class HeuristicPerformanceFitness(object):
     def __init__(self, 
                  param_names,
                  evaluation_function = None, 

src/qinfer/tests/test_optimiser.py

@@ -44,17 +44,17 @@ class TestPSO(DerandomizedTestCase):
 
 	def test_pso_quad(self):
 		f_quad = lambda x: numpy.sum(10 * (x-0.5)**2)
-		hh_opt = ParticleSwarmOptimiser(['x','y','z','a'], fitness_function = f_quad)
+		hh_opt = ParticleSwarmOptimizer(['x','y','z','a'], fitness_function = f_quad)
 		hh_opt()
 
 	def test_pso_sin_sq(self):
 		f_sin_sq = lambda x: numpy.sum(np.sin(x - 0.2)**2)
-		hh_opt = ParticleSwarmOptimiser(['x','y','z','a'], fitness_function = f_sin_sq)
+		hh_opt = ParticleSwarmOptimizer(['x','y','z','a'], fitness_function = f_sin_sq)
 		hh_opt()
 
 	def test_pso_rosenbrock(self):
 		f_rosenbrock = lambda x: numpy.sum([((x[i+1]  - x[i]**2)**2 + (1 - x[i])**2)/len(x) for i in range(len(x)-1)])
-		hh_opt = ParticleSwarmOptimiser(['x','y','z','a'], fitness_function = f_rosenbrock)
+		hh_opt = ParticleSwarmOptimizer(['x','y','z','a'], fitness_function = f_rosenbrock)
 		hh_opt()
 
 
@@ -84,7 +84,7 @@ def test_pso_perf_test_multiple_short(self):
 		#Fitness function to evaluate the performance of the experiment
 		EXPERIMENT_FITNESS = lambda performance: performance['loss'][:,-1].mean(axis=0)
 
-		hh_opt = ParticleSwarmOptimiser(params,
+		hh_opt = ParticleSwarmOptimizer(params,
 		                                n_trials = n_trials,
 		                                n_particles = n_particles,
 		                                prior = prior,
@@ -95,58 +95,21 @@ def test_pso_perf_test_multiple_short(self):
 		hh_opt(n_pso_iterations=5,
 		        n_pso_particles=6)
 
-
-	def test_pso_perf_test_multiple_long(self):
-		# Define our experiment
-		n_trials = 20 # Times we repeat the set of experiments
-		n_exp = 150 # Number of experiments in the set
-		n_particles = 4000 # Number of points we track during the experiment
-
-		# Model for the experiment
-		model = rb.RandomizedBenchmarkingModel()
-
-		#Ordering of RB is 'p', 'A', 'B'
-		# A + B < 1, 0 < p < 1
-		#Prior distribution of the experiment
-		prior = dist.PostselectedDistribution(
-		    dist.MultivariateNormalDistribution(mean=[0.5,0.1,0.25], cov=np.diag([0.1, 0.1, 0.1])),
-		    model
-		)
-
-		#Heuristic used in the experiment
-		heuristic_class = qi.expdesign.ExpSparseHeuristic
-
-		#Heuristic Parameters
-		params = ['base', 'scale']
-
-		#Fitness function to evaluate the performance of the experiment
-		EXPERIMENT_FITNESS = lambda performance: performance['loss'][:,-1].mean(axis=0)
-
-		hh_opt = ParticleSwarmOptimiser(params,
-		                                n_trials = n_trials,
-		                                n_particles = n_particles,
-		                                prior = prior,
-		                                model = model,
-		                                n_exp = n_exp,
-		                                heuristic_class = heuristic_class
-		                               )
-		hh_opt()
-
 def TestPSSAO(DerandomizedTestCase):
 
 	def test_pssao_quad(self):
 		f_quad = lambda x: numpy.sum(10 * (x-0.5)**2)
-		hh_opt = ParticleSwarmSimpleAnnealingOptimiser(['x','y','z','a'], fitness_function = f_quad)
+		hh_opt = ParticleSwarmSimpleAnnealingOptimizer(['x','y','z','a'], fitness_function = f_quad)
 		hh_opt()
 
 	def test_pssao_sin_sq(self):
 		f_sin_sq = lambda x: numpy.sum(np.sin(x - 0.2)**2)
-		hh_opt = ParticleSwarmSimpleAnnealingOptimiser(['x','y','z','a'], fitness_function = f_sin_sq)
+		hh_opt = ParticleSwarmSimpleAnnealingOptimizer(['x','y','z','a'], fitness_function = f_sin_sq)
 		hh_opt()
 
 	def test_pssao_rosenbrock(self):
 		f_rosenbrock = lambda x: numpy.sum([((x[i+1]  - x[i]**2)**2 + (1 - x[i])**2)/len(x) for i in range(len(x)-1)])
-		hh_opt = ParticleSwarmSimpleAnnealingOptimiser(['x','y','z','a'], fitness_function = f_rosenbrock)
+		hh_opt = ParticleSwarmSimpleAnnealingOptimizer(['x','y','z','a'], fitness_function = f_rosenbrock)
 		hh_opt()
 
 
@@ -176,7 +139,7 @@ def test_pssao_perf_test_multiple_short(self):
 		#Fitness function to evaluate the performance of the experiment
 		EXPERIMENT_FITNESS = lambda performance: performance['loss'][:,-1].mean(axis=0)
 
-		hh_opt = ParticleSwarmSimpleAnnealingOptimiser(params,
+		hh_opt = ParticleSwarmSimpleAnnealingOptimizer(params,
 		                                n_trials = n_trials,
 		                                n_particles = n_particles,
 		                                prior = prior,
@@ -192,17 +155,17 @@ def TestPSTO(DerandomizedTestCase):
 
 	def test_psto_quad(self):
 		f_quad = lambda x: numpy.sum(10 * (x-0.5)**2)
-		hh_opt = ParticleSwarmTemperingOptimiser(['x','y','z','a'], fitness_function = f_quad)
+		hh_opt = ParticleSwarmTemperingOptimizer(['x','y','z','a'], fitness_function = f_quad)
 		hh_opt()
 
 	def test_psto_sin_sq(self):
 		f_sin_sq = lambda x: numpy.sum(np.sin(x - 0.2)**2)
-		hh_opt = ParticleSwarmTemperingOptimiser(['x','y','z','a'], fitness_function = f_sin_sq)
+		hh_opt = ParticleSwarmTemperingOptimizer(['x','y','z','a'], fitness_function = f_sin_sq)
 		hh_opt()
 
 	def test_psto_rosenbrock(self):
 		f_rosenbrock = lambda x: numpy.sum([((x[i+1]  - x[i]**2)**2 + (1 - x[i])**2)/len(x) for i in range(len(x)-1)])
-		hh_opt = ParticleSwarmTemperingOptimiser(['x','y','z','a'], fitness_function = f_rosenbrock)
+		hh_opt = ParticleSwarmTemperingOptimizer(['x','y','z','a'], fitness_function = f_rosenbrock)
 		hh_opt()
 
 
@@ -232,7 +195,7 @@ def test_psto_perf_test_multiple_short(self):
 		#Fitness function to evaluate the performance of the experiment
 		EXPERIMENT_FITNESS = lambda performance: performance['loss'][:,-1].mean(axis=0)
 
-		hh_opt = ParticleSwarmTemperingOptimiser(params,
+		hh_opt = ParticleSwarmTemperingOptimizer(params,
 		                                n_trials = n_trials,
 		                                n_particles = n_particles,
 		                                prior = prior,