FedericaBrando
commented
8 months ago Extract of a conversation that can be relevant to keep it in here for posterity.
I need to set up the space with n-dimension as the number of methods (example 8 ) and then sample as many time as I want (ex. 10000). Then apply the constraints to verify if the vector fulfills them. The bottleneck is indeed the number of sampling, because I will be iterating through that, but the w.c.s is O(samples) which is definitely lower than 21^methods
I was thinking, since the constraint are the following:
"""
These are the constraints that must be in place:
constraint 1: sum w_i = 1
constraint 2: w_i >= 0.05 for all w_i may not apply if some w_i is discarded
constraint 3: w_i <= 0.3 for all w_i
"""Maybe we can set the space to be (0, 0.3) given the third constraint, what is the point on looking for a weight higher than 0.3 if we are going to discard it anyway.
In this way we don't need to do any "normalization" of the vector and rely on the result from the sampling, since the chance of hitting a vector that fulfill the first if condition (if sum(w) <= 1 - LOWER_BOUND | where LOWER_BOUND is 0.05) is higher.
here is the code:
dim = len(METHODS) - len(low_quality_index)
space = Space([(0.0, 0.3)]*dim)
lhs = Lhs(lhs_type='classic', criterion='maximin', iterations=1000)
for w in lhs.generate(dimensions=space.dimensions, n_samples=1000):
if sum(w) <= 1 - LOWER_BOUND: # inside the simplex
w_dim = list(np.append(w, [1 - sum(w)])) # consequently len(w_dim) == dim
if all_constraints(w_dim):
w_all = fill_with_zeros(w_dim, low_quality_index)
f = func(w_all)
if optimum['Objective_Function'] > f: # remember we are running a minimization
optimum['Objective_Function'] = f
for i, v in enumerate(METHODS):
optimum[v] = w_all[i]
Could it make sense?
koszulordie
migrau
The current approach to scan the grid of possible weight vectors to find an optimal method combination is inefficient and expected to blow up as we add new methods to the combination pool. Instead of using an exhaustive grid search with a predefined grid step, we can use a filling-space random grid search strategy. This is a technique to randomly sample vectors from the grid in such a way that the subsequent samples avoid the areas of the previously sampled ones.
One common approach to do this is based on latin hypercubes. The approach has been already implemented in the Python package "scikit-optimize". Specifically, we can make use of the skopt.sampler.Lhs class: https://scikit-optimize.github.io/stable/modules/generated/skopt.sampler.Lhs.html