Add TPE algorithm into Orion

docs/src/user/algorithms.rst

@@ -224,6 +224,7 @@ Configuration
           gamma: 0.25
           equal_weight: False
           prior_weight: 1.0
+          full_weight_num: 25
 
 
 ``seed``
@@ -250,6 +251,11 @@ True to set equal weights for observed points. Default is ``False``.
 
 The weight given to the prior point of the input space. Default is ``1.0``.
 
+``full_weight_num``
+
+The number of the most recent trials which get the full weight where the others will be
+applied with a linear ramp from 0 to 1.0. It will only take effect if ``equal_weight``
+is ``False``. Default is ``25``.
 
 
 Algorithm Plugins

src/orion/algo/tpe.py

@@ -52,8 +52,9 @@ def adaptive_parzen_estimator(mus, low, high,
     :param high: real value for upper bound of points.
     :param prior_weight: real value for the weight of the prior mean.
     :param equal_weight: bool value indicating if all points with equal weights.
-    :param flat_num: int value indicating the number of latest points with equal weights,
-                     it is only valid if `equal_weight` is False.
+    :param flat_num: int value indicating the number of the most recent trials which
+        get the full weight where the others will be applied with a linear ramp
+        from 0 to 1.0. It will only take effect if equal_weight is False.
     """
     def update_weights(total_num):
         """Generate weights for all components"""
@@ -153,20 +154,27 @@ class TPE(BaseAlgorithm):
     prior_weight: int
         The weight given to the prior point of the input space.
         Default: ``1.0``
+    full_weight_num: int
+        The number of the most recent trials which get the full weight where the others will be
+        applied with a linear ramp from 0 to 1.0. It will only take effect if equal_weight
+        is False.
 
     """
 
+    # pylint:disable=too-many-arguments
     def __init__(self, space, seed=None,
                  n_initial_points=20, n_ei_candidates=24,
-                 gamma=0.25, equal_weight=False, prior_weight=1.0):
+                 gamma=0.25, equal_weight=False,
+                 prior_weight=1.0, full_weight_num=25):
 
         super(TPE, self).__init__(space,
                                   seed=seed,
                                   n_initial_points=n_initial_points,
                                   n_ei_candidates=n_ei_candidates,
                                   gamma=gamma,
                                   equal_weight=equal_weight,
-                                  prior_weight=prior_weight)
+                                  prior_weight=prior_weight,
+                                  full_weight_num=full_weight_num)
 
         for dimension in self.space.values():
 
@@ -289,10 +297,10 @@ def _sample_real_point(self, dimension, below_points, above_points):
         low, high = dimension.interval()
         below_mus, below_sigmas, below_weights = \
             adaptive_parzen_estimator(below_points, low, high, self.prior_weight,
-                                      self.equal_weight, flat_num=25)
+                                      self.equal_weight, flat_num=self.full_weight_num)
         above_mus, above_sigmas, above_weights = \
             adaptive_parzen_estimator(above_points, low, high, self.prior_weight,
-                                      self.equal_weight, flat_num=25)
+                                      self.equal_weight, flat_num=self.full_weight_num)
 
         gmm_sampler_below = GMMSampler(self, below_mus, below_sigmas, low, high, below_weights)
         gmm_sampler_above = GMMSampler(self, above_mus, above_sigmas, low, high, above_weights)

tests/functional/algos/tpe.yaml

@@ -10,6 +10,7 @@ algorithms:
     gamma: 0.25
     equal_weight: False
     prior_weight: 1.0
+    full_weight_num: 25
 
 database:
   type: 'mongodb'

tests/unittests/algo/test_tpe.py

@@ -85,14 +85,21 @@ def test_adaptive_parzen_normal_estimator_weight():
     # prior weight
     mus, sigmas, weights = adaptive_parzen_estimator(obs_mus, low, high, prior_weight=0.5,
                                                      equal_weight=False, flat_num=25)
-    print(weights)
+
     prior_pos = numpy.searchsorted(mus, 2)
     assert numpy.all(weights[:30 - 25] == (numpy.linspace(1.0 / 30, 1.0, num=30 - 25) / 31))
     assert numpy.all(weights[33 - 25:prior_pos] == 1 / 31)
     assert weights[prior_pos] == 0.5 / 31
     assert numpy.all(weights[prior_pos + 1:] == 1 / 31)
     assert numpy.all(sigmas == 6 / 10)
 
+    # full weights number
+    mus, sigmas, weights = adaptive_parzen_estimator(obs_mus, low, high, prior_weight=1.0,
+                                                     equal_weight=False, flat_num=15)
+    assert numpy.all(weights[:30 - 15] == (numpy.linspace(1.0 / 30, 1.0, num=30 - 15) / 31))
+    assert numpy.all(weights[33 - 15:] == 1 / 31)
+    assert numpy.all(sigmas == 6 / 10)
+
 
 def test_adaptive_parzen_normal_estimator_sigma_clip():
     """Test that the magic clip of sigmas for parzen estimator"""