Monte Carlo Tree Descent for Black-Box Optimization
Anonymous Author(s)
AffiliationAddress email
Abstract
The key to black-box optimization is the efficient search among regions withwidely-varying numerical properties to achieve low-regret descent and fast progresstoward the optimum.
Monte Carlo Tree Search (MCTS) methods have recently beenintroduced to improve Bayesian optimization (BO) by computing better partitioningof the search space and balancing exploration and exploitation.
Extending thispromising framework, we study how to integrate sample-based descent with BOfor faster optimization.
At the vertices of the search trees, we first introduce newdescent methods that incorporate stochastic and direct search.
We then design novelways of balancing progress and uncertainty, and propose new branch selection, treeexpansion, and backpropagation policies.
Overall, the proposed MCTS puts moreemphasis on sampling for faster descent, and uses localized Gaussian Processes asauxiliary metrics in both exploitation and exploration.
We show experimentallythat the proposed algorithms can outperform state-of-the-art methods on manychallenging benchmark problems.
Introduction
Black-box optimization (BBO) problems assume that the objective function is not known analyticallyand can be evaluated at arbitrary inputs, potentially with high evaluation cost and stochastic outcomes.
The generality of this formulation makes it applicable to a wide range of challenging problems inmachine learning Zoph & Le (2016); Bu¸soniu et al. (2013);
Kim et al.
and many scientificand engineering disciplines Vanderplaats (2002);
Yang et al.
; Kimura et al.
Theseproblems are naturally NP-hard: without analytic information of the objectives, we may need toexhaustively search through the combinatorially-large number of local regions to find high-qualitysolutions.
In practice, the focus of BBO algorithm design is on accelerating optimization progresswhile minimizing the number of function evaluations.
Existing work on BBO can be categorized into model-based and model-free approaches.
Mostmodel-based approaches, typically in the framework of BO Jones et al.
; Rasmussen (2003),involve learning a surrogate function from samples of the unknown function and optimizing thesurrogate rather than the original function.
In spite of this, the results of BO are sensitive tothe parameters of the surrogate model.
Normally, they are fixed at a particular value, but thisunderestimates uncertainty.
By contrast, one could compute the BO with astounding expense overentire distributions of hyperparameters.
In addition, the number of required samples increases inproportion to the size of the search space, so problems in high-dimensional spaces are less sampleefficient.
Model-free approaches include various search methods, such as simulated annealing,cross-entropy methods, search gradient, as well as traditional direct search methods such as NelderMead Henderson et al.
De Boer et al.
; Salomon (1998); Gao & Han (2012); Kolda et al.(2003).
The key to finding better samples in direct search algorithms is to create a good probabilitydistribution for the search space.
In both approaches, the lack of mechanisms of dealing with theinherent combinatorially-large number of local regions has been the bottleneck of scaling these approaches to high-dimensional problems with complex landscapes.
Recent advances in stochastictree search provides new opportunities for balancing local search and modeling with better globalexploitation/exploration trade-off.
In particular, MCTS has recently introduced in Munos (2011);
Kim et al.
; Wang et al.
(2020) for computing good partitioning of the search space.
We propose a new design of the MCTS framework with more emphasis on sample-driven descentmethods for local exploitation first, and then use BO methods at vertices of the search tree for localmodeling.
We change the role of BO from global modeling to local metrics for balancing exploitationand exploration.
We introduce new descent methods that incorporate ideas from stochastic anddirect search, and then design novel ways of balancing progress and uncertainty.
To integratethese approaches in the MCTS framework, we propose new branch selection, tree expansion, andbackpropagation policies.
We evaluate the proposed methods with experiments on nonlinear optimization benchmarks Lavezziet al.
(2022), MuJoCo locomotion tasks Todorov et al.
(2012), and neural architecture search benchmarks Dong & Yang (2020).
We compare with state-of-the-art methods such as TuRBO Erikssonet al.
and La-MCTS Wang et al.
as well other search methods such as CMA-ES Hansenet al.
and Nelder-Mead Gao & Han (2012).
We observe clear benefits in the proposed designsin achieving the most efficient and robust descent progress across all benchmark sets.
Related Work
Many attempts have been made on the black-box function optimization problem in continuous space.
Since 1960, direct search methods, a family of deterministic methods, have had a golden age intackling the derivative-free optimization problems Lewis et al.
In principle, they comparefunction values at candidate positions and adopt the best one iteratively.
A classic scheme of this typeis Nelder-Mead (NM) Gao & Han (2012).
This method creates a simplex in R N - the primary convexobject in n dimensional space with n + 1 vertices - and gauges the function on each vertex.
Withevery iteration of the algorithm, it mirrors the worst vertex over a hyperplane formed by the remainingn points, or shrinks the n worst vertices to the best one.
While the NM method performs well inpractice Rios & Sahinidis (2013), its ability to identify global or local optima is not guaranteed.
Forexample, in McKinnon (1998) the authors demonstrated it cannot reach the stationary point.
BO Jones et al.
Shahriari et al.
(2016) algorithms are the typical class by modeling with
Gaussian Process (GP) Rasmussen (2003) as a local surrogate.
GP uses a kernel function to evaluatethe correlation between samples, and yields the sample prediction of the objective function.
Such a
BO algorithm commonly builds an acquisition function and selects the sample with highest acquisitionfunction value Frazier (2018).
The most commonly used acquisition functions are Gaussian ProcessUpper Confidence Bound (GP-UCB), Expected Improvements (EI) and Most Probable Improvement(MPI) Srinivas et al.
Moreover, a multi-objective acquisition may also be implemented, asin the Cowen-Rivers et al.
(2020) who built one with evolutionary approach.
The problem with
BO approaches is that at every iteration, finding the global optimal of the acquisition function inhigh dimensional space is also challenging Oh et al.
There have been many attempts toovercome the difficulty of BO algorithm in high dimensional space Gardner et al.
(2017); Rollandet al.
(2018); Mutn`y & Krause (2019); Eriksson et al.
(2019), and TuRBO Eriksson et al.
(2019) is awidely accepted method.
To address large-scale, highly dimensional problems, TuRBO combines
Thompson sampling with Expected HyperVolume Improvement (EHVI) with a local probabilisticapproach.
As the trust region varies between iterations, TuRBO can improve the fitting of the localmodel and be able to allocate the sample of at the global extreme.
Another alternative is to optimize the black box function via sampling methods with domain partitions,such as Deterministic Optimistic Optimization (DOO) and Simultaneous Optimistic Optimization(SOO) in Munos (2011), and Hierarchical Optimistic Optimization (HOO) in Bubeck et al.
Specifically, DOO divides up the search domain into partitions, each of which is represented bya point within it, and analyses are made on these points.
Because DOO assumes a semi-metricinput and a Lipschitz constant for the objective function, it can calculate an upper bound at otherpoints within a partition cell via the distance between evaluated and unknown points.
SOO doesnot require a specific character in the objective function, and HOO is a stochastic counterpart of
DOO.
Nevertheless, these approaches are applicable only to low-dimensional problems because ofthe high cost involved in creating perfect partition cells at each dimension.
On the basis of these prior works, Voronoi Optimistic Optimization (VOO) Kim et al.
(2020) becomes more efficient inhigh-dimensional domains by including Voronoi partitioning in the tree search.
LA-MCTS Wanget al.
(2020) extends the work by learning a latent action within an existing partition.
Such latentactions define a boundary between the high and low-performing regions of a cell, thereby makingsampling preferential.
Preliminaries
Black-box optimization is a form of global optimization that makes the least requirement on theobjective function.
Without loss of generality, we assume that the objective f ( x ) takes values in abox domain Ω
= [ lb i , ub i ] d , i = 1 , ..., d , lb i and ub i are lower and upper bounds of the domain atdimension i .
We can evaluate f ( x ) for any x ∈ Ω , but do not have information about the analyticform of the function and can not directly evaluate its derivatives.
We use direct search sampling as part of the local descent optimization process.
Direct search, ingeneral, examines a set of points around the current point, seeking those with a function value lowerthan the current point.
We also incorporate Stochastic Three Points (STP) Bergou et al.
(2020) inorder to increase sample efficiency.
The STP algorithm effectively optimizes the objective functionof a point x by sampling two additional points either side of x and selecting the one with the lowestvalue.
Formally, descent approaches in direct search contains two steps in one iteration k : 1) sample{ x k,i } , i = 1 , ..., n with a probability distribution, and 2) select x k +1 =
argmin x ∈ D k f ( x ) . For STP,the sampling set at each iteration is simply D k = { x k , x k + s k · α k , x k − s k · α k } where s k is adirection and α k is its step size.
As long as the amplitude of α k is small enough, the relationshipbetween f ( x k + s k · α k ) , f ( x k ) and f ( x k − s k · α k ) is monotonically non-increasing or non-decreasingif the gradient of the continuous function f is not zero in the direction of s k .
With this method, it ispossible to optimize the objective function iteratively with only two evaluations per step.
BO uses Gaussian Process regression (GP) to construct a surrogate model of the objective function.
Using this model, we can now determine the predicted value and its uncertainty at a new point.
In this way, promising samples can be identified from a large number of new candidates based onacquisition functions, e.g., by maximizing the expected improvement over all new candidates.
Fora finite collection of points x 1 , ..., x k ∈ R d , GP constructs the mean vector µ 0 from the function fat each x i , and the covariance matrix Σ 0 from a kernel function at each pair of x i , x j .
The kernelreflects the correlation between the two points with the belief that two close points have similar valuesthan points that are far apart.
For any new point x , we can use Bayes’ rule to compute the conditionaldistribution of f ( x ) :
[Equation]
This model allows us to define various acquisition functions Rasmussen (2003).
Monte Carlo Tree Descent
4.1 Overview
We propose our partition-free algorithm for optimizing black-box functions by MCTS with localdescent in this section.
In a sample-based manner, our algorithm is like VOO and LaMCTS as faras constructing a Monte Carlo tree is concerned.
Despite this, our approach does not rely on anypartitioning concepts because of limitations in a high-dimensional space.
Instead, our samplingmethod combines learning a local surrogate model and optimizing with direct search.
In our approach,a node is commonly represented by samples and observed function values { ( x, f ( x ) } .
In eachiteration, a path is chosen from the root to the leaf.
During the selection of children for the branchnode on the path, we apply the Upper Confidence Bounds applied to Trees (UCT) for the nodes inthe child list of the branch node.
Aside from the UCTs from these existing children, we also appendan additional UCT value which indicates whether the tree is interested in exploring a new child atthis branch node.
As soon as this additional UCT is selected, a leaf node is created and added tothe current node’s child list, and this newly created leaf node is selected for optimization.
When anexisting leaf node is selected at the end of a path, a decision is also made concerning whether toexplore a new sibling or optimize in the chosen leaf.
The Alg. 1 is an overview of our approach.
Algorithm while within total budget do node ← Root explore branch ← False while node.children exist do uct i = − y ∗
i + C d · (cid:80) kj =1 ( dy i, − j ) + C p · (cid:112) log n node /n
i uct explore = − (cid:80) ( y ∗ i ) /N
children + C ′ p · √ log n node best uct ← max ( uct i , uct explore )
If best uct == uct explore : explore branch ← True ; break node ← child with best uct end while explore leaf ← False if node is leaf then
If − y ∗ + C ′′ d · (cid:80) kj =1 ( dy − j ) < C ′′ p · (cid:112) log n leaf : explore leaf ←
True end if if explore branch or explore leaf then x ← node.
X ; xnew ← node.
X + Distance · decay CurrNodeLevel
nodeNew (xnew) ; node.children.append(nodeNew)
If explore leaf: nodeInherit(node.
X) ; node.children.append(nodeInherit) node ← nodeNew end if while within Descent budget do
GP.train(node.samples) dx ← argmin(GP(sampling))
* GP.correlation lengh * step size node.
X ← argmin(f(node.
X), f(node.
X
+ dx), f(node.
X - dx)) end while while within BO budget do node.
X ← TuRBO(node.
X) end while end while
4.2 Node Optimization
Local Descent We examined several direct search algorithms, including NM Gao & Han (2012)and STP Bergou et al.
(2020), and selected STP with careful redesign.
A general principle suggeststhat s k will be selected at random from a uniform sphere in the absence of prior knowledge about theobjective function.
In our approach, however, we use the surrogate GPR model to assist in identifyingthe point with the highest expected improvement.
By utilizing STP, we evaluate not only the pointwith the greatest expected improvement, but also the point that is positioned in the opposite direction,which will lead to an increased likelihood of finding a better solution.
The step size α k was, bysuggestion from Bergou et al.
(2020), inversely proportional to the square root of iteration steps.
Inour case, we set it to be proportional to the square root of the product of node visits and its level.
Inaddition, the step size is also rescaled according to the correlation length in the surrogate GP model- a similar approach to when TuRBO defines the length of each dimension for a trust region.
Thedescent optimizer, if it succeeds at finding a better solution, will continue to evaluate new points inthe same direction until failure; if the step is not successful at the beginning of the step on the twopoints in opposite directions, the step size is halved.
Each node is trained with a local GPR model as a surrogate to approximate the objective function.
We use the vanilla GP with RBF kernel in our implementation.
In the case when the local descentoptimizer selects candidates for evaluation, the surrogate may provide answers to the expectedfunction value.
It also serves to suggest the correlation length for rescaling the step size at descent.
Local Bayesian Optimization We modify TuRBO-1 Eriksson et al.
(2019) for local BO.
The
TuRBO-1 model creates a hyper-rectangle Trust Region (TR) with volume L N centered at the bestsample found so far.
Afterwards, it samples new candidates within the TR and queries the objectivefunction for ground truth data.
The length of L i will either increase after successive "successes" or decrease after consecutive "failures".
We changes TuRBO-1 in three ways to fit it into our algorithm:1) TuRBO-1 begins with collected samples of the node.
Consequently, TuRBO-1 is compelled tooptimize from the vicinity of the collected sample.
The trust region length has been preserved onthe same node, so the local BO can continue from the previous epoch.
We do not perform restartsfor TuRBO-1 in order to avoid TuRBO-1 restarting from random samples.
4.3 Tree Expansion
In the event that exploration is decided on a node, a new child node will be created.
The newchild node is randomly created on a point that is distant from the best point of the selected node.
Minimum and maximum distances are set to 10% and 50% of the domain’s dimensional length, byan exponential decay on node level.
After the new child node is created, it will be selected as thenode for optimization at the current step.
In the scene the selected node to explore is a leaf node L , a new child node M is created in the sameway as above, making L a branch node.
At this time, a new node L’ , starting from the current bestpoint at L , is also created as the second child of node L .
The new node L’ inherits a batch of samplesthat are near its starting point, as well as the latest improvement history on L .
The reduced number ofsamples forces the inheriting node L’ to focus on optimizing in the neighborhood of the starting point,while the newly created node M is optimizing in a distant region.
By adopting this approach, the treegrows at node L while maintaining the potential to optimize around the best point found on L by theinherit node L’ .
4.4 Path selection
In order to balance exploration and exploitation, our algorithm uses UCT to determine the pathbetween the root and a node.
We modified the UCT formula for fitting our MCDescent algorithm:
[Equation]
Here, C p is a hyper-parameter for the extent of exploration, n parent is the number of visits to theparent node, y ∗ is the best value found at this node, and dy − k is the most recent k ’s improvement atthis node: dy i =
y ∗ i − 1 −
y
i if y i < y ∗ i − 1 , else 0 . 0 .
As an example, if the best found value at a nodeimproves over eight calls to the objective function, there will be eight improvements in total, andthe last k improvements will be taken into account at computing UCT.
At a parent node, it picks thenodes that has the highest UCT score.
When C d = 0 and C p = 0 , our approach degenerates into agreedy policy that only optimizes around the current best value.
When a branch node is selected, it examines the UCT of all its child nodes as well as an additional
UCT value that has the following setting: y ∗ ′ =
(cid:80) ( y ∗ i ) /N , C ′ d = 0 , and C ′ p ̸
= C p , where N is thenumber of children at the current node.
This additional UCT value represents if the branch decides toexplore in a new child domain, because the existing children are not performing well enough.
Whenthis branch exploration UCT is the highest among all other child nodes, the search for the path isterminated, and the branch node is selected to create a child node.
If no exploration is need on everybranch node along the path, we apply the following criteria after selecting a leaf nodein order todetermine whether it is worth exploring or exploiting:
[Equation]
In the event that the inequality holds, it is decided to optimize the selected leaf node.
Otherwise, twonew nodes are created as children of this leaf node, as discussed above.
Experiments
Our first benchmark set includes synthetic functions from standard nonlinear optimization benchmarks Lavezzi et al.
These functions all contain numerous local minima,valleys, and ridges.
We scale the [Figure]
The MuJoCo locomotion environments Todorov et al.
(2012) are among the most popular benchmarksfor search and optimization.
In our experiments, we choose Hopper, Walker, and HalfCheetah fortests.
Hopper has 3 dimensions in action space a and 11 in observation s .
We choose a linear policya =
Ws in which W is the weighting matrix to search for maximizing the reward, therefore, thesearch space for Hopper is in the dimension of 3 · 11 = 33 .
Similarly, we set linear policies in both
Walker-102d and HalfCheetah-102d.
In addition to the above linear policy, we double the weightingmatrix space dimension in Walker from 102 to 204, such that a = W 1 s + W 2 s where W 1 and W 2are matrix both in dimension 102.
In this case the Walker becomes an optimization problem in 204d.
Note since our approach does only consider deterministic result, we set the noise scale to zero in all
MuJoCo environment to avoid the randomness in rewards.
The third test set is from NAS-Bench-201 .
The use of deep learning models is becoming popularin many fields, however the implementation of efficient neural networks requires lots of time andefforts.
Therefore, Neural Architecture Search (NAS) problems have a practical significance.
Wechoose the CIFAR-10 and CIFAR-100 datasets from NAS-Bench-201 Dong & Yang (2020) for ourbenchmark.
Each network in the datasets consists of three stacks of searching cells, and each cell hassix positions where one can select one type of layer from five different types: (1) zeroize, (2) skipconnection, (3) 1-by-1 convolution, (4) 3-by-3 convolution, and (5) 3-by-3 average pooling layer.
Overall, there are 5 6 = 15625 different types of architectures, and each architecture is trained andevaluated on both CIFAR-10 and CIFAR-100.
The accuracy of training and evaluation is recorded.
Inorder to benchmark on these datasets, we create following functions in real domain: we replace eachof the five types of layers with an integer, and use the evaluation accuracy as the function value atcorresponding point for the performance of a particular type of architecture in the set.
When the input is a real number, it is rounded up to the nearest integer and the function value at that point is returned.
As an example, we set the input domain to { [0 . 5 , 5 . 5] 6 } , and f ([1 . 1] 6 ) =
f
([1] 6 ) , where each 1 − 5corresponds to one type of the layers.
It should be noted that in this method different inputs may referto the same network architecture; therefore, the number of unique architectures examined is less thanthe number of functions called.
Baselines We evaluated our MCTS-Descent by comparing it to baselines from various algorithmcategories.
From among the BO algorithms, we selected TuRBO Eriksson et al.
which isalso part of our own algorithm
La-MCTS Wang et al.
(2020) in MCTS class is selected as a majorcomparator, since this algorithm also constructs the tree in a similar manner.
Moreover, CMA-ES
Hansen et al.
from the Evolutionary Algorithm category, Nelder-Mead Gao & Han (2012)from Direct Search algorithms, as well as the Random Search algorithm are selected for comparisonas baselines.
Evaluation Metrics For each benchmark set, we run each baseline and our algorithm using up tofive different random seeds.
We assume that there is a limit on the number of calls to the objectivefunction, which we set to 3,000.
In our study, we evaluate the best found value until every step, andcompute the mean and standard deviation for all runs.
In this manner, we can compare the best foundvalue at the end of the run as well as the speed at which each algorithm can reach its goal.
It ispossible that some algorithms will find the optimal value before 3000 calls, which will lead to anearly stop in such a case.
Experiment Setup
The function fmin 2 from CMA-ES package is applied for CMA optimizationwith its default parameters.
We implement our own version of Nelder-Mead algorithm, and set itsexpansion coefficient, contraction outside of simplex, contraction inside the simplex, and shrinkcoefficient as 2 . 0 , 0 . 5 , 0 .
5 and 0 . 5 , respectively.
TuRBO is initialized with 20 random samples chosenby Latin Hypercube sampling, and its Automatic Relevance Determination (ARD) is set to True .
LaMCTS uses different exploration setting for different test functions, so as our MC-Descent algorithm,and we put them in supplementary material.
Our approach allows us to adjust not only the coefficientsfor the UCT and tree expansion, but also the allocation of resources between local descent and local
BO.
We set up running our approach on Google Colab with Tesla-V100 graphic card.
Overall Performance Fig.
1 shows the comparison between our model and baselines on differentdatasets.
It is seen that MCDescent can substantially improve the speed of finding better resultsfor Ackley-50d, Ackley-100d, Hopper-66d, CIFAR-10 and CIFAR-100.
Particularly for Ackleyand CIFAR-10/CIFAR-100, MCDescent comes very close to the optimal solution in a fast manner,which is crucial for NAS search.
In the remaining test cases, we find that the approach is capableof achieving similar or even better mean scores earlier than TuRBO and LaMCTS.
It may, however,display significant variability due to the challenging complexity of the landscape for the descentapproach.
As seen in the late stage of optimization on Walker-102d and Walker-204d, the rewardcurves exhibit large variation between the runs of MCDescent.
Consequently, the performanceof MCDescent may be limited in some high dimensional spaces that are inhospitable to descentapproaches.
Overall, these results show clear benefits of the designs in the proposed methods inachieving faster descent progress and more optimal final results.
Ablation Study: Tree expansion It is important to justify the expansion of the tree.
Fig.
2illustrates the nodes from which the query is made for the objective function.
In Fig. 2(a), the rootnode is optimized for the first 200 queries; however, no significant improvement is evident for thenext 300 queries.
At this point, the tree decides to expand, so it creates a new child node, child-1 , andstarts optimizing from this child.
Nonetheless, the optimization is also stuck after 200 more queries.
Therefore, our tree abandons to optimize in child-1 , and adds a new child node named child-2 .
Onchild-2 , the optimization procedure is significant, and a new best value is found.
The tree in Fig.2(b) attempts to optimize in the child-1 and its new exploration child child-1-child , however, theimprovements on these nodes are insignificant.
Consequently, the tree decides to optimize from theroot inherit node.
In light of the newly gathered samples upon exploring child-1 and child-1-child ,optimization is able to proceed at the root inherit node.
They demonstrate that the tuned tree model iscapable of optimizing by selecting a correct node.
[Figure] [Figure] [Figure] Ablation Study: Descent optimizer and Bayesian optimizer We examine the performance ofour approach when the computational budget is divided between a local descent model and a local
Bayesian optimizer TuRBO.
Fig. 3(a) illustrates the optimization history of Ackley-100d whenbudget ratios are 1:2, 5: and 1:10.
It is demonstrated that the model with a high budget in local descent suffers from a low optimization rate, and the model with a high budget in local Bayesianoptimizer may have difficulty escaping from the local optimal point.
Having a balanced budgetbetween local descent and BO speeds up the optimization process and overcomes the limits of the
BO method at the local optimal.
To investigate further how the local descent can enhance BO, weexamine the function value of Michalewicz-100d at queries from both models in Fig. 3(b).
From thefigure we seen the local Bayesian optimizer has significantly better epoch improvement than localdescent at an early stage of optimization, but when it reaches the local optimum, the optimizationimprovement provided by the local Bayesian optimizer becomes insignificant, while local descentcan contribute steadily towards a superior solution.
The two models can be combined to achievebetter results than when they are used separately.
Ablation Study: Optimization route Fig.
4 illustrates how MCDescent, TuRBO, and LaMCTSoptimize Ackley-2d and Michalewicz-2d in the first 30 samples after initialization.
In both plots, LaMCTS explores a wide range of input domains, making it less likely to find a solution by asmall number of calls.
TuRBO locates efficiently the area where the optimal point is located in thebeginning, however, its subsequent samples are diverse and fail to identify the global optimal solution.
MCDescent, on the other hand, samples much closer to the global optimal point and thus finds thesolution more rapidly.
Conclusion
In this paper, we present a sample-efficient approach to the optimization of deterministic black-boxfunctions.
Our proposed algorithm comprises descent methods as well as BO, and is not based onthe input domain partition.
The performance of our approach is evaluated against baselines from
BO Eriksson et al.
, partition-based MCTS Wang et al.
(2020), Evolutionary Algorithms
Hansen et al.
and Direct Search Gao & Han (2012).
The benchmark is applied by usingsynthetic functions, MuJoCo locomotion tasks, and NAS-201 datasets.
The result shows MCDescent,our approach, is comparable to baselines in terms of the best found values within fewer evaluationfunction calls, but provides the solution faster.
Specifically, we examine how the descent modelassists BO in increasing optimization speed as well as how the tree structure balances explorationand exploitation of a search domain.
Checklist
The checklist follows the references.
Please read the checklist guidelines carefully for information onhow to answer these questions.
For each question, change the default [TODO] to [Yes] [No] or[N/A] .
You are strongly encouraged to include a justification to your answer , either by referencingthe appropriate section of your paper or providing a brief inline description.
For example:
• Did you include the license to the code and datasets?
[Yes] See Section ?? .
• Did you include the license to the code and datasets?
[No] The code and the data areproprietary.
• Did you include the license to the code and datasets?
[N/A]
Please do not modify the questions and only use the provided macros for your answers.
Note that the
Checklist section does not count towards the page limit.
In your paper, please delete this instructionsblock and only keep the Checklist section heading above along with the questions/answers below.
For all authors...
(a) Do the main claims made in the abstract and introduction accurately reflect the paper’scontributions and scope?
[Yes](b) Did you describe the limitations of your work?
[Yes] See section Overall performance(c)
Did you discuss any potential negative societal impacts of your work?
[N/A](d)
Have you read the ethics review guidelines and ensured that your paper conforms tothem?
[Yes]2.
If you are including theoretical results...
(a) Did you state the full set of assumptions of all theoretical results?
[N/A](b)
Did you include complete proofs of all theoretical results?
[N/A]3.
If you ran experiments...
(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
[Yes](b) Did you specify all the training details (e g., data splits, hyperparameters, how theywere chosen)?
[Yes] See section 5.4(c)
Did you report error bars (e
g., with respect to the random seed after running experiments multiple times)?
[Yes] All results in section 5.5 and 5.6 include uncertaintyrange(d)
Did you include the total amount of compute and the type of resources used (e
g., typeof GPUs, internal cluster, or cloud provider)?
[Yes]
In section {+5.
+}
If you are using existing assets (e
g., code, data, models) or curating/releasing new assets...
a) If your work uses existing assets, did you cite the creators?
[Yes]
) Did you mention the license of the assets?
[Yes]
(c) Did you include any new assets either in the supplemental material or as a URL?
[No]
(d) Did you discuss whether and how consent was obtained from people whose data you’re
using/curating?
[N/A]
(e) Did you discuss whether the data you are using/curating contains personally identifiable
information or offensive content?
[Yes]
If you used crowdsourcing or conducted research with human subjects...
Did you include the full text of instructions given to participants and screenshots, if
applicable?
[N/A]
you describe any potential participant risks, with links to Institutional Review
Board approvals, if applicable
[N A]
Did you include the estimated hourly wage paid to participants and the total amount
spent on participant compensation
[N A]