Title: LEARNING TO GUIDE RANDOM SEARCH

Abstract: We are interested in derivative-free optimization of high-dimensional functions. The sample complexity of existing methods is high and depends on problem dimensionality, unlike the dimensionality-independent rates of first-order methods. The recent success of deep learning suggests that many datasets lie on low-dimensional manifolds that can be represented by deep nonlinear models. We therefore consider derivative-free optimization of a high-dimensional function that lies on a latent low-dimensional manifold. We develop an online learning approach that learns this manifold while performing the optimization. In other words, we jointly learn the manifold and optimize the function. Our analysis suggests that the presented method significantly reduces sample complexity. We empirically evaluate the method on continuous optimization benchmarks and high-dimensional continuous control problems. Our method achieves significantly lower sample complexity than Augmented Random Search, Bayesian optimization, covariance matrix adaptation (CMA-ES), and other derivative-free optimization algorithms.

1. INTRODUCTION:

A typical approach to machine learning problems is to define an objective function and optimize it over a dataset. First-order optimization methods are widely used for this purpose since they can scale to high-dimensional problems and their convergence rates are independent of problem dimensionality in most cases. However, gradients are not available in many important settings such as control, black-box optimization, and interactive learning with humans in the loop. Derivativefree optimization (DFO) can be used to tackle such problems. The challenge is that the sample complexity of DFO scales poorly with the problem dimensionality. The design of DFO methods that solve high-dimensional problems with low sample complexity is a major open problem.

The success of deep learning methods suggests that high-dimensional data that arises in real-world settings can commonly be represented in low-dimensional spaces via learned nonlinear features. In other words, while the problems of interest are high-dimensional, the data typically lies on lowdimensional manifolds. If we could perform the optimization directly in the manifold instead of the full space, intuition suggests that we could reduce the sample complexity of DFO methods since their convergence rates are generally a function of the problem dimensionality (Nesterov & Spokoiny, 2017; Dvurechensky et al., 2018) . In this paper, we focus on high-dimensional data distributions that are drawn from low-dimensional manifolds. Since the manifold is typically not known prior to the optimization, we pose the following question. Can we develop an adaptive derivative-free optimization algorithm that learns the manifold in an online fashion while performing the optimization?

There exist DFO methods that aim to identify a low-dimensional search space (Maheswaranathan et al., 2019; Choromanski et al., 2019) . However, they are limited to linear subspaces. In contrast, we propose to use expressive nonlinear models (specifically, neural networks) to represent the manifold. Our approach not only increases expressivity but also enables utilization of domain knowledge concerning the geometry of the problem. For example, if the function of interest is known to be translation invariant, convolutional networks can be used to represent the underlying manifold structure. On the other hand, the high expressive power and flexibility brings challenges. Our approach requires solving for the parameters of the nonlinear manifold at each iteration of the optimization. To address this, we develop an efficient online method that learns the underlying manifold while the function is being optimized.

We specifically consider random search methods and extend them to the nonlinear manifold learning setting. Random search methods choose a set of random directions and perform perturbations to the current iterate in these directions. Differences of the function values computed at perturbed points are used to compute an estimator for the gradient of the function. We first extend this to random search over a known manifold and show that sampling directions in the tangent space of the manifold provides a similar estimate. We then propose an online learning method that estimates this manifold while jointly performing the optimization. We theoretically analyze sample complexity and show that our method reduces it. We conduct extensive experiments on continuous control problems, continuous optimization benchmarks, and gradient-free optimization of an airfoil. The results indicate that our method significantly outperforms state-of-the-art derivative-free optimization algorithms from multiple research communities.

2. PRELIMINARIES:

We are interested in high-dimensional stochastic optimization problems of the form

EQUATION

where x is the optimization variable and f : R d → R is the function of interest, which is defined as expectation over a noise variable ξ. We assume that the stochastic function is bounded (|F (x, ξ)| ≤ Ω), L-Lipschitz, and µ-smooth1 with respect to x for all ξ, and has uniformly bounded variance (E ξ [(F (x, ξ) -f (x))2 ] ≤ V F ). In DFO, we have no access to the gradients. Instead, we only have zeroth-order access by evaluating the function F (i.e. sampling F (x, ξ) for the input x).

We are specifically interested in random search methods in which an estimate of the gradient is computed using function evaluations at points randomly sampled around the current iterate. Before we formalize this, we introduce some definitions. Denote the d-dimensional unit sphere and unit ball by S d-1 and B d , respectively. We define a smoothed function following Flaxman et al. (2005) . For a function f : R d → R, its δ-smoothed version is f (x) = E v∼B d [f (x + δv)]. The main workhorse of random search is the following result by Flaxman et al. (2005) . Let s be a random vector sampled from the uniform distribution over S d-1 . Then f (x + δs)s is an unbiased estimate of the gradient of the smoothed function:

EQUATION

We use antithetic samples since this is known to decrease variance (Kroese et al., 2013) and define the final gradient estimator as y(x, s) = (F (x + δs, ξ) -F (x -δs, ξ)) s. Extending (2) to the antithetic case, E ξ,s∈S d-1 [y(x, s)] = 2δ d ∇ x f (x). A simple way to optimize the function of interest is to use the gradient estimate in stochastic gradient descent (SGD), as summarized in Algorithm 1. This method has been analyzed in various forms and its convergence is characterized well for nonconvex smooth functions. We restate the convergence rate and defer the constants and proof to Appendix A.2. Proposition 1 (Flaxman et al., 2005; Vemula et al., 2019) . Let f (x) be differentiable, L-Lipschitz, and µ-smooth. Consider running random search (Algorithm 1) for T steps. Let k = 1 for simplicity. Then

1 T T t=1 E ∇ x f (x t ) 2 2 ≤ O T -1 2 d + T -1 3 d 2 3

.

3. ONLINE LEARNING TO GUIDE RANDOM SEARCH:

Proposition 1 implies that the sample complexity of random search scales linearly with the dimensionality. This dependency is problematic when the function of interest is high-dimensional. We argue that in many practical problems, the function of interest lies on a low-dimensional nonlinear

Algorithm 1 Random Search 1: for t = 1 to T do 2:

g t , = GRADEST(x t , δ)

3:

x t+1 = x t -αg t 4: end for Algorithm 2 Manifold Random Search 1: for t = 1 to T do 2: g t , = MANIFOLDGRADEST(x t , J(x t ; θ ))

3::

x t+1 = x t -αg t 4: end for 1: procedure GRADEST(x, δ)

2::

Sample: s 1 , . . . , s k ∼ S d-1 3:

Query: y i = f (x + δs i ) -f (x -δs i ) 4: Estimator: g = d 2δ k i=1 y i s i 5: return g, {s i } i∈[k] 6: end procedure 1: procedure MANIFOLDGRADEST(x, θ,δ)

Normalize: J q = GramSchmidt(J) 3:

Sample: s 1 , . . . , s k ∼ S n-1

4::

Query:

y i = f (x + δJ q s i ) -f (x -δJ q s i ) 5: Estimator: g = n 2δ k i=1 y i J q s i 6: return g, {J q s i } i∈[k]

7: end procedure manifold. This structural assumption will allow us to significantly reduce the sample complexity of random search, without knowing the manifold a priori.

Assume that the function of interest is defined on an n-dimensional manifold (n d) and this manifold can be defined via a nonlinear parametric family (e.g. a neural network). Formally, we are interested in derivative-free optimization of functions with the following properties:

• Smoothness: F (•, ξ) : R d → R is µ-smooth and L-Lipschitz for all ξ. • Manifold: F (•, ξ) is defined on an n-dimensional manifold M for all ξ.

• Representability: The manifold M and the function of interest can be represented using parametrized function classes r(•; θ) and g(•; ψ). Formally, given ξ, there exist θ and ψ such that

F (x, ξ) = g(r(x; θ ); ψ ) ∀x ∈ R d .

We will first consider an idealized setting where the manifold is already known (i.e. we know θ ). Then we will extend the developed method to the practical setting where the manifold is not known in advance and must be estimated with no prior knowledge as the optimization progresses.

3.1. WARM-UP: RANDOM SEARCH OVER A KNOWN MANIFOLD:

If the manifold is known a priori, we can perform random search directly over the manifold instead of the full space. Consider the chain rule applied to g(r(x; θ); ψ) as ∇ x f (x) = J(x; θ )∇ r g(r; ψ), where J(x; θ ) = ∂r(x;θ ) /∂x and r = r(x, θ ). The gradient of the function of interest lies in the column space of the Jacobian of the parametric family. In light of this result, we can perform random search in the column space of the Jacobian, which has lower dimensionality than the full space.

For numerical stability, we will first orthonormalize the Jacobian using the Gram-Schmidt procedure, and perform the search in the column space of this orthonormal matrix since it spans the same space. We denote the orthonormalized version of J(x; θ ) by J q (x; θ ).

In order to perform random search, we sample an n-dimensional vector uniformly (s ∼ S n-1 ) and lift it to the input space via J q (x; θ )s. As a consequence of the manifold Stokes' theorem, using the lifted vector as a random direction gives an unbiased estimate of the gradient of the smoothed function as

EQUATION

where the smoothed function is defined as fθ (x) = E ṽ∼B n [f (x + δJ q (x; θ )ṽ)]. We show this result as Lemma 1 in Appendix A.1. We use the resulting gradient estimate in SGD. The following proposition summarizes the sample complexity of this method. The constants and the proof are given in Appendix A.2.

Proposition 2. Let f (x) be differentiable, L-Lipschitz, and µ-smooth. Consider running manifold random search (Algorithm 2) for T steps. Let k = 1 for simplicity. Then

1 T T t=1 E ∇ x f (x t ) 2 2 ≤ O T -1 2 n + T -1 3 n 2 3

.

3.2. JOINT OPTIMIZATION AND MANIFOLD LEARNING:

When n d, the reduction in the sample complexity of random search (summarized in Proposition 2) is significant. However, the setting of Algorithm 2 and Proposition 2 is impractical since the manifold is generally not known a priori. We thus propose to minimize the function and learn the manifold jointly. In other words, we start with an initial guess of the parameters and solve for them at each iteration using all function evaluations that have been performed so far.

Our major objective is to improve the sample efficiency of random search. Hence, minimizing the sample complexity with respect to manifold parameters is an intuitive way to approach the problem. We analyze the sample complexity of SGD using biased gradients in Appendix A.3.1 and show the following informal result. Consider running manifold random search with a sequence of manifold parameters θ 1 , ψ 1 , . . . , θ T , ψ T for T steps. Then the additional suboptimality caused by biased gradients, defined as SUBOPTIMALITY = 1

EQUATION

)

where SUBOPTIMALITY(θ , ψ ) is the suboptimality of the oracle case (Algorithm 2). Our aim is to minimize the additional suboptimality with respect to θ t and ψ t . However, we do not have access to ∇ x f (x) since we are in a derivative-free setting. Hence we cannot directly minimize (4).

At each iteration, we observe y(x t , s t ). Moreover, y(x t , s t ) = 2δs t ∇ x F (x t , ξ) + O(δ 2 ), due to the smoothness. Since we observe the projection of the gradient onto the chosen directions, we minimize the projection of (4) onto these directions. Formally, we define our one-step loss as

EQUATION

We use the Follow the Regularized Leader (FTRL) algorithm (Hazan, 2016; Shalev-Shwartz, 2012) to minimize the aforementioned loss function and learn the manifold parameters:

EQUATION

where the regularizer R(θ, ψ) = ∇ x g(r(x t ; θ t ); ψ t ) -∇ x g(r(x t ; θ); ψ) 2 is a temporal smoothness term that penalizes sudden changes in the gradient estimates.

Algorithm 3 summarizes our algorithm. We add exploration by sampling a mix of directions from the manifold and the full space. In each iteration, we sample directions and produce two gradient estimates g m , g e using the samples from the tangent space and the full space, respectively. We mix them to obtain the final estimate g = (1 -β)g m + βg e . We discuss the implementation details of the FTRL step in Section 4. In our theoretical analysis, we assume that (6) can be solved optimally.

Although this is a strong assumption, experimental results suggest that neural networks can easily fit any training data (Zhang et al., 2017) . Our experiments also support this observation.

Theorem 1 states our main result concerning the sample complexity of our method. As expected, the sample complexity includes both the input dimensionality d and the manifold dimensionality n.

On the other hand, the sample complexity only depends on n √ d rather than d. Thus our method significantly decreases sample complexity when n d. Theorem 1. Let f (x) be bounded, L-Lipschitz, and µ-smooth. Consider running learned manifold random search (Algorithm 3) for T steps. Let k e = 1 and k m = 1 for simplicity. Then

1 T T i=1 E ∇ x f (x t ) 2 2 ≤ O d 1 2 T -1 + (d 1 2 + n + nd 1 2 )T -1 2 + (n 2 3 + d 1 2 n 2 3 )T -1 3 .

Proof sketch. We provide a short proof sketch here and defer the detailed proof and constants to Appendix A.3. We start by analyzing SGD with bias. The additional suboptimality of using θ t , ψ t instead of θ , ψ can be bounded by (4).

The empirical loss we minimize is the projection of (4) onto randomly chosen directions. Next, we show that the expectation of the empirical loss is (4) when the directions are chosen uniformly at random from the unit sphere:

EQUATION

A crucial argument in our analysis is the concentration of the empirical loss around its expectation.

In order to study this concentration, we use Freedman's inequality (Freedman, 1975) , inspired by the analysis of generalization in online learning by Kakade & Tewari (2009) . Our analysis bounds the difference

E s t ∈S d-1 T t=1 L t - T t=1 L t , where L t = L(x t , s t , θ t , ψ t ).

Next, we use the FTL-BTL Lemma (Kalai & Vempala, 2005) to analyze the empirical loss T t=1 L t . We bound the empirical loss in terms of the distances between the iterates T t=1 x t+1 -x t 2 . Such a bound would not be useful in an adversarial setting since the adversary chooses x t , but we set appropriate step sizes, which yield sufficiently small steps and facilitate convergence.

Our analysis of learning requires the directions in (7) to be sampled from a unit sphere. On the other hand, our optimization method requires directions to be chosen from the tangent space of the manifold. We mix exploration (directions sampled from S d-1 ) and exploitation (directions sampled from the tangent space of the manifold) to address this mismatch. We show that mixing weight β = 1 /d yields both fast optimization and no-regret learning. Finally, we combine the analyses of empirical loss, concentration, and SGD to obtain the statement of the theorem.

4. IMPLEMENTATION DETAILS AND LIMITATIONS:

We summarize important details here and elaborate further in Appendix B. A full implementation is available at https://github.com/intel-isl/LMRS. Parametric family. We use multilayer perceptrons with ReLU nonlinearities to define g and r. We initialize our models with standard normal distributions. Our method thus starts with random search at initialization and transitions to manifold random search as the learning progresses.

Solving FTRL. Results on training deep networks suggest that local SGD-based methods perform well. We thus use SGD with momentum as a solver for FTRL in (6). We do not solve each learning problem from scratch but initialize with the previous solution. Since this process may be vulnerable to local optima, we fully solve (6) from scratch for every 100 th iteration of the method.

Computational complexity. Our method increases the amount of computation since we need to learn a model while performing the optimization. However, in DFO, the major computational bottleneck is typically the function evaluation. When efficiently implemented on a GPU, the time spent on learning the manifold is negligible in comparison to function evaluations.

Parallelization. Random search is highly parallelizable since directions can be processed independently.

Communication costs include i) sending the current iterate to workers, ii) sending directions to each corresponding worker, and iii) workers sending the function values back. When the directions are chosen independently, they can be indicated to each worker via a single integer by first creating a shared noise table in preprocessing.

For a d-dimensional problem with k random directions, these costs are d, k, and k, respectively. The total communication cost is therefore d + 2k.

In our method, each worker also needs a copy of the Jacobian, resulting in a communication cost of d + 2k + kd. Hence our method increases communication cost from d + 2k to d + 2k + kd.

Algorithm 3 Learned Manifold Random Search (LMRS) 1: for t = 1 to T do 2:

g t e , S t e = GRADEST(x t , δ)

3:

g t m , S t m = MANIFOLDGRADEST(x t , J(x t ; θ t ))

4: 

g t = βke ke+km g t e + (1-β)km ke+km g t m 5: x t+1 = x t -αg t 6: θ t+1 , ψ t+1 = arg min θ,ψ t i=1 L(x i , S i e,

5. EXPERIMENTS:

We empirically evaluate the presented method (referred to as Learned Manifold Random Search (LMRS)) on the following sets of problems. i) We use the MuJoCo simulator (Todorov et al., 2012) to evaluate our method on high-dimensional control problems. ii) We use 46 single-objective unconstrained functions from the Pagmo suite of continuous optimization benchmarks (Biscani et al., 2019) . iii) We use the XFoil simulator (Drela, 1989) to benchmark gradient-free optimization of an airfoil.

We consider the following baselines. i) Augmented Random Search (ARS): Random search with all the augmentations from Mania et al. (2018) . ii) Guided ES (Maheswaranathan et al., 2019) : A method to guide random search by adapting the covariance matrix. iii) CMA-ES (Hansen, 2016) : Adaptive derivative-free optimization based on evolutionary search. iv) REMBO (Wang et al., 2016) : A Bayesian optimization method which uses random embeddings in order to scale to high-dimensional problems. Although CMA-ES and REMBO are not based on random search, we include them for the sake of completeness. Additional implementation details are provided in Appendix B.

5.1. LEARNING CONTINUOUS CONTROL:

Following the setup of Mania et al. (2018) , we use random search to learn control of highly articulated systems. The MuJoCo locomotion suite (Todorov et al., 2012) includes six problems of varying difficulty. We evaluate our method and the baselines on all of them. We use linear policies and include all the tricks (whitening the observation space and scaling the step size using the variance of the rewards) from Mania et al. (2018) . We report average reward over five random experiments versus the number of episodes (i.e. number of function evaluations) in Figure 1 . We also report the average number of episodes required to reach the prescribed reward threshold at which the task is considered 'solved' in Table 1 . We include proximal policy optimization (PPO) (Schulman et al., 2017; Hill et al., 2018) for reference. Note that our results are slightly different from the numbers reported by Mania et al. (2018) as we use 5 random seeds instead of 3.

The results suggest that our method improves upon ARS in all environments. Our method also outperforms all other baselines. The improvement is particularly significant for high-dimensional problems such as Humanoid. Our method is at least twice as efficient as ARS in all environments except Swimmer, which is the only low-dimensional problem in the suite. Interestingly, Guided-ES fails to solve the Humanoid task, which we think is due to biased gradient estimation. Furthermore, CMA-ES performs similarly to ARS. These results suggest that a challenging task like Humanoid is out of reach for heuristics like local adaptation of the covariance matrix due to high stochasticity and nonconvexity. We list the number of cores used for each experiment.

REMBO only solves the Swimmer task and fails to solve others. We believe this is due to the fact that these continuous control problems have no global structure and are highly nonsmooth. The number of possible sets of contacts with the environment is combinatorial in the number of joints, and each contact configuration yields a distinct reward surface. This contradicts the global structure assumption in Bayesian optimization.

Wall-clock time analysis. Our method performs additional computation as we learn the underlying manifold. In order to quantify the effect of the additional computation, we perform wall-clock time analysis and plot average reward vs wall-clock time in Figure 2 . Our method outperforms all baselines with similar margins to Figure 1 . The trends and shapes of the curves in Figures 1 and 2 are similar. This is not surprising since computation requirements of all the optimizers are rather negligible when compared with the simulation time of MuJoCo.

The only major differences we notice are on the Hopper task. Here the margin between our method and the baselines narrows and the relative ordering of Guided-ES and ARS changes. This is due to the fact that simulation stops when the agent falls. In other words, the simulation time depends on the current solution. Methods that query the simulator for these unstable solutions lose less wall-clock time.

Quantifying manifold learning performance. In order to evaluate the learning performance, we project the gradient of the function to the tangent space of the learned manifold and plot the norm of the residual. Since we do not have access to the gradients, we estimate them at 30 time instants, evenly distributed through the learning process. We perform accurate gradient estimation using a very large number of directions (2000) . We compute the norm of the residual of the projection as

1 T T t=1 ∇ x f (x t ) -P Jq(x t ,θ t ) (∇ x f (x t )) 2

, where P A (•) is projection onto the column space of A. The results are visualized in Figure 3 . Our method successfully and quickly learns the manifold in all cases. We denote the number of successful trials as (success/trial) and average over successful trials only.

If the number of successful trials is not noted, the method solved the task for all random seeds. 

Hopper-v1:

Figure 3 : Manifold learning accuracy. We plot

1 T T t=1 ∇ x f (x t ) -P Jq(x t ,θ t ) (∇ x f (x t )) 2 .

In order to estimate the gradient, we use GRADEST with a high number of directions.

Ablation studies. Our method uses three major ideas. i) We learn a manifold that the function lies on. ii) We learn this manifold in an online fashion. iii) We perform random search on the learned manifold. To study the impact of each of these ideas, we perform the following experiments. i) No learning. We randomly initialize the manifold r(•; θ) by sampling the entries of θ from the standard normal distribution. Then we perform random search on this random manifold. ii) No online learning. We collect an offline training dataset by sampling x i values uniformly at random from a range that includes the optimal solutions. We evaluate function values at sampled points and learn the manifold. We perform random search on this manifold without updating the manifold model. iii) No search. We use the gradients of the estimated function (∇ x g(r(x; θ t )ψ t )) as surrogate gradients and minimize the function of interest using first-order methods.

We list the results in Table 1 . We do not include the no-search baseline since it fails to solve any of the tasks. Failure of the no-search baseline suggests that the estimated functions are powerful enough to guide the search, but not accurate enough for optimization. The no-learning baseline outperforms ARS on the simplest problem (Swimmer), but either fails completely or increases sample complexity on other problems, suggesting that random features are not effective, especially on high-dimensional problems. Although the offline learning baseline solves more tasks than the no-learning one, it has worse sample complexity since initial offline sampling is expensive. This study indicates that all three of the ideas that underpin our method are important.

5.2. CONTINUOUS OPTIMIZATION BENCHMARKS:

We use continuous optimization problems from the Pagmo problem suite (Biscani et al., 2019) . This benchmark includes minimization of 46 functions such as Rastrigin, Rosenbrock, Schwefel, etc. (See Appendix B for the complete list.) We use ten random starting points and report the average number of function evaluations required to reach a stationary point. Figure 4 reports the results as performance profiles (Dolan & Moré, 2002) . Performance profiles represent how frequently a method is within distance τ of optimality. Specifically, if we denote the number of function evaluations that method m requires to solve problem p by T m (p) and the number of function evaluations used by the best method by T (p) = min m T m (p), the performance profile is the fraction of problems for which method m is within distance τ of the best: is the number of problems.

1 /Np p 1[T m (p) -T (p) ≤ τ ],

As can be seen in Figure 4 , our method outperforms all baselines. The success of our method is not surprising since the functions are typically defined as nonconvex functions of some statistics, inducing manifold structure by construction. REMBO (Bayesian optimization) is close to our method and outperforms the other baselines. We believe this is due to the global geometric structure of the considered functions. Both CMA-ES and Guided-ES outperform ARS.

5.3. OPTIMIZATION OF AN AIRFOIL:

We apply our method to gradient-free optimization of a 2D airfoil. We use a computational fluid dynamics (CFD) simulator, XFoil (Drela, 1989) . (Drela, 1989) , which can simulate an airfoil using its contour plot. We parametrize the airfoils using smooth polynomials of up to 36 degrees. We model the upper and lower parts of the airfoil with different polynomials. The dimensionality of the problem is thus 72. XFoil can simulate various viscosity properties, speeds, and angles of attack. The details are discussed in Appendix B. We plot the resulting airfoil after 1500 simulator calls in Table 2 . We also report the lift and drag of the resulting shape. The objective we optimize is LIFT -DRAG. Table 2 suggests that all methods find airfoils that can fly (LIFT > DRAG). Our method yields the highest LIFT -DRAG. Bayesian optimization outperforms the other baselines.

5.4. EFFECT OF MANIFOLD AND PROBLEM DIMENSIONALITY:

In this section, we perform a controlled experiment to understand the effect of problem dimensionality (d) and manifold dimensionality (n). We generate a collection of synthetic optimization problems. All synthesized functions follow the manifold hypothesis: f (x) = g(r(x, θ )), where r(x, θ ) is a multilayer perceptron with the architecture Linear(d, 2n) → ReLU → Linear(2n, n) and g(•) is a randomly sampled convex quadratic function. In order to sample a convex quadratic function, we sample the parameters of the quadratic function from a Gaussian distribution and project the result to the space of convex quadratic functions.

We choose d ∈ {100, 1000} and plot the objective value with respect to the number of function evaluations for various manifold dimensionalities n in Figure 5 . The results suggest that for a given ambient dimensionality d, the lower the dimensionality of the data manifold n, the more sampleefficient our method. In concordance with our theoretical analysis, the improvement is very significant when n d, as can be seen in the cases n = 5, d = 1000 and n = 2, d = 100.

Interestingly, our method is effective even when the manifold assumption is violated (n = d). We hypothesize that this is due to anisotropy in the geometry of the problem. Although all directions are important when n = d, some will result in faster search since the function changes more along them. It appears that our method can identify these direction and thus accelerate the search. Derivative-free optimization. We summarize the work on DFO that is relevant to our paper. For a complete review, readers are referred to Custódio et al. (2017) and Conn et al. (2009) . We are specifically interested in random search methods, which have been developed as early as Matyas (1965) and Rechenberg (1973) . Convergence properties of these methods have recently been analyzed by Agarwal et al. (2010) , Bach & Perchet (2016) , Nesterov & Spokoiny (2017) , and Dvurechensky et al. (2018) . A lower bound on the sample complexity for the convex case has been given by Duchi et al. (2015) and Jamieson et al. (2012) . Bandit convex optimization is also highly relevant and we utilize the work of Flaxman et al. (2005) Adaptive random search. There are various methods in the literature that adapt the search space by using anisotropic covariance as in the case of CMA-ES (Hansen et al., 2003; Hansen, 2016) , guided evolutionary search (Maheswaranathan et al., 2019) , and active subspace methods (Choromanski et al., 2019) . There are also methods that enforce structure such as orthogonality in the search directions (Choromanski et al., 2018) . Other methods use information geometry tools as in Wierstra et al. (2014) and Glasmachers et al. (2010) . Lehman et al. (2018) use gradient magnitudes to guide neuro-evolutionary search. Staines & Barber (2012) use a variational lower bound to guide the search. In contrast to these methods, we explicitly posit nonlinear manifold structure and directly learn this latent manifold via online learning. Our method is the only one that can learn an arbitrary nonlinear search space given a parametric class that characterizes its geometry.

Adaptive Bayesian optimization. Bayesian optimization (BO) is another approach to zeroth-order optimization with desirable theoretical properties (Srinivas et al., 2010) . Although we are only interested in methods based on random search, some of the ideas we use have been utilized in BO. Calandra et al. (2016) used the manifold assumption for Gaussian processes. In contrast to our method, they use autoencoders for learning the manifold and assume initial availability of offline data. Similarly, Djolonga et al. (2013) consider the case where the function of interest lies on some linear manifold and collect offline data to identify this manifold. In contrast, we only use online information and our models are nonlinear. Wang et al. (2016) and Kirschner et al. (2019) propose using random low-dimensional features instead of adaptation. Rolland et al. (2018) design adaptive BO methods for additive models. Major distinctions between our work and the adaptive BO literature include our use of nonlinear manifolds, no reliance on offline data collection, and formulation of the problem as online learning.

7. CONCLUSION:

We presented Learned Manifold Random Search (LMRS): a derivative-free optimization algorithm.

Our algorithm learns the underlying geometric structure of the problem online while performing the optimization. Our experiments suggest that LMRS is effective on a wide range of problems and significantly outperforms prior derivative-free optimization algorithms from multiple research communities.

A PROOFS A.1 GRADIENT ESTIMATOR:

In this section, we show that when random directions are sampled in the column space of the orthonormal matrix U, perturbations give biased gradient estimates of the manifold smoothed function. Moreover, when U = U , resulting gradients are unbiased. We formalize this with the following lemma.

Lemma 1. Let U be an orthonormal basis for the tangent space of the n-dimensional manifold M at point x ∈ M, U be another orthonormal matrix, and f be a function defined on this manifold. Fix δ > 0. Then

E s∼S n-1 [f (x + δUs)Us] = δ n ∇ x fU (x) + BIAS(U)

where

BIAS(U) = E s∈S n-1 [f (x + δUs)[U -U ]s].

Moreover, bias is 0 and the resulting estimator is unbiased when U = U .

Proof. Without loss of generality, we can assume det U = 1 and det U = 1. Using this remark, we can state the proof of the lemma as the straightforward application of the manifold Stoke's theorem

EQUATION

)

where vol denotes volume, and we use the definition of the expectation in (a, e), orthonormality of U in (b,d), manifold Stoke's theorem in (c) and the fact that the ratio of volume to the surface area of a n-dimensional ball of radius δ is δ n in (e). Moreover, bias vanishes when U = U .

A.2 SAMPLE COMPLEXITY FOR RANDOM SEARCH AND MANIFOLD RANDOM SEARCH:

In this section, we bound the sample complexity of the random search (Algorithm 1) and the manifold random search (Algorithm 2). Our analysis starts with studying the relationship between the function (f ) and its smoothed ( f ) as well as manifold smoothed ( fU ) versions in section A.2.2. We show that L-Lipschitzness and µ-smoothness of the function extend to the smoothed functions. Moreover, we also bound the difference between the gradients of the original function and the gradients of the smoothed versions. Next, we study the second moment of the gradient estimator in section A.2.3. Finally, we state the sample complexity of SGD on non-convex functions in section A.2.1. Combining these results, we state the final sample complexity of random search and manifold random search in section A.2.4&A.2.5.

A.2.1 CONVERGENCE OF SGD FOR NON-CONVEX FUCTIONS:

The convergence of the SGD has been widely studied and here we state its convergence result for non-convex functions from Ghadimi & Lan (2013) as a Lemma and give its proof for the sake of completeness.

Lemma 2 (Convergence of SGD (Ghadimi & Lan, 2013; Vemula et al., 2019) ). Consider running SGD on f (x) that is µ-smooth and L-Lipschitz for T steps starting with initial solution x 0 . Denote Ω 0 = f (x 0 ) -f (x ) where x is the globally optimal point and assume that the unbiased gradient estimate has second moment bounded with V . Then,

1 T T t=1 E ∇ x f (x t ) 2 2 ≤ 8Ω 0 µV T (9)

Proof. We denote the step size as α and the unbiased gradient estimate as g t . We analyze the step at t as;

EQUATION

)

where we used the µ-smoothness of the function. Taking expectation of the inequality,

EQUATION

)

Using the bounded second moment of the gradient, and summing from step 1 to T ,

T t=1 E g t [f (x t+1 )] ≤ T t=1 f (x t ) -α T t=1 ∇ x f (x t ) 2 2 + µα 2 T V 2 (12)

Re-arranging the terms, we obtain,

T t=1 ∇ x f (x t ) 2 2 ≤ 1 α E g 0 ,...,g t [f (x 0 ) -f (x t+1 )] + µαT V 2 ≤ ∆ 0 α + µT αV (13) Set α = 2∆ 0

µT V , and divide the inequality to T in order to obtain the required inequality as

EQUATION

A.2.2 PRELIMINARY RESULTS ON SMOOTHED FUNCTIONS First, we will show that the µ-smoothness and L-Lipschitness properties of f applies to f and f .

| fU (x 1 ) -fU (x 2 )| = |E v∈B n [f (x 1 + δUv)] -E v∈B n [f (x 2 + δUv)]| = |E v∈B n [f (x 1 + δUv) -f (x 2 + δUv)]| ≤ |E v∈Bn [L x 1 -x 2 2 ]| (a) = L x 1 -x 2 2 (15)

where we use L-Lipschitz continuity of f in (a), and,

∇ fU (x 1 ) -∇ fU (x 2 ) 2 = ∇E v∈B n [f (x 1 + δUv)] -∇E v∈B n [f (x 2 + δUv)] 2 = E v∈B n [∇f (x 1 + δUv)] -E v∈B n [∇f (x 2 + δUv)] 2 = E v∈B n [∇f (x 1 + δUv) -∇f (x 2 + δUv)] 2 (b) ≤ E v∈B n [ ∇f (x 1 + δUv) -∇f (x 2 + δUv) 2 ] (c) ≤ µ x 1 -x 2 2 (16)

where we use Jensen's inequality and convexity of the norm in (b) and µ-smoothness of f in (c). Hence, µ-smoothness and L-Lipschitness applies to fU for any U. Take n = d and U = I, then the µ-smoothness and L-Lipschitness applies to f .

Next, we will study the impact of using the gradients of the smoothed function instead of the original function.

EQUATION

)

where we use a + b 2 2 ≤ 2 a 2 2 + 2 b 2 2 . We further bound the left term as

EQUATION

using dominated convergence theorem in (a), the µ-smoothness of f in (b) and orthonormality of U and the fact that norm of any point in a unit ball is bounded by 1. By taking n = d and U = I, this result also implies the same for f . Hence,

EQUATION

A.2.3 SECOND MOMENT OF THE GRADIENT ESTIMATOR:

We will start with studying the second moment of our gradient estimate for the manifold case. We bound the expected square norm of the gradient estimate as

EQUATION

where we use orthonormality of U and unit norm property of s in (a), add and substract f (x + δUs) -f (x -δUs) and use (a + b) 2 ≤ 2a 2 + 2b 2 in (b), use the bounded variance of F and the Lipschitz smoothness of f in (c).

Second moment of the random search estimator can also computed similarly. And, the resulting bound would be

EQUATION

A.2.4 PROOF OF PROPOSITION 1

Proof. Analysis of SGD from Lemma 2 shows that

EQUATION

Using the bound on the second moment of the estimator we derive in ( 21),

EQUATION

Using the relationship between f and f we derive in ( 19),

EQUATION

)

We use the property √ a + b ≤ √ a + √ b, and solve for α. After we substituted the resulting δ,

EQUATION

where

EQUATION

A.2.5 PROOF OF PROPOSITION 2:

Proof. Sample complexity of the manifold random search follows closely the proof of Proposition 1.

We summarize here for the sake of completeness. Using the analysis of SGD from Lemma 2,

EQUATION

Using the bound on the second moment of the estimator we derive in (21), and the relationship between f and fU we derive in ( 19),

EQUATION

)

We first use the property √ a + b ≤ √ a + √ b, then solve for α and δ. Finally, we substitute resulting δ to get the final result as;

EQUATION

where

c 0 = 4L 2Ω 0 µ, c 1 = √ 2c 0 , and c 2 = (4V F Ω 0 ) 1 3 (2µ + 4µ 5 6 ).

A.3 PROOF OF THE THEOREM 1:

Proof. We will prove our main theorem using a three major arguments. First, we analyze the SGD of a non-convex function with biased gradients in section A.3.1. Second, we show that the expected value of our loss function is equal to the bias term in section A.3.2. In order to bound the difference between the empirical loss function we minimize and its expectation, we use the Freedman's inequality Freedman (1975) . Third, we bound the empirical loss in section A.3.3 in terms of the distance travelled by the iterates of the optimization x t+1 -x t 2 . Finally, we optimize the resulting bound in terms of the finite difference step (δ t ), SGD step size (α t ), and mixing coefficients (β) to obtain the final statement of the theorem in section A.3.4.

A.3.1 ANALYSIS OF SGD WITH BIAS:

In order to analyze the SGD with bias, we will denote the gradient at the iteration t, as g t . Moreover, we will assume that its bias is b t as E[g t ] = b t + ∇ x F (x, ξ). Using the µ-smoothness of the function F , we can state that

EQUATION

Let's assume the effect of the bias is bounded as

EQUATION

Taking the expectation with respect to s and ξ, we get

EQUATION

where

V g = E[ g t 2 2

]. Summing up from t = 1 to T and dividing by α, we obtain

EQUATION

We now compute the bound on the bias term (B t ) using Lemma 1 and

EQUATION

where we used the fact that function is bounded as F (x, ξ) ≤ Ω. Since ∇ x F (x, ξ) lies in the column space of U , for some p,

p U [U -U ] = p [U U -I] = p [U U -U U] = [∇ x F (x, ξ) -p U ]U (34)

Choice of bases (U ) is not unique in Lemma 1. It can be any orthonormal basis spanning the tangent space of the manifold. In order to minimize

E s∈S n-1 |∇ x F (x t , ξ) [U -U ]s| , choose

the basis which will set Up to the projection of ∇ x F (x t , ξ) into the column space of U. Then,

∇ x F (x t , ξ) [U -U ] 2 ≤ min q∈R n ∇ x F (x t , ξ) -Uq 2 ≤ ∇ x F (x t , ξ) -∇ x g(r(x t ; θ t ); ψ t ) 2 (35)

where last inequality is due to ∇ x g(r(x t ; θ t ); ψ t ) being in the column space of U. Combining with (32), ( 19), and

EQUATION

)

We proceed to bound T t=1 ∇ x F (x t , ξ) -∇ x g(r(x t ; θ t ); ψ t ) 2 in the next section.

A.3.2 ROLE OF THE BANDIT FEEDBACK:

The true loss we are interested in is the effect of bias on the SGD. The bias is the sum of the differences between the gradients of the true function ( F (x, ξ)) and the estimated one (g(r(x; θ); ψ)) as derived in (36). On the other hand, the empirical information we have is the projection of this loss to a random direction (s) with an additional noise term. In this section, we will analyze the difference between the bias and the empirical loss without the noise. We will include the discussion on the noise in section A.3.3.

First, we will show that expectation of the empirical loss over a direction uniformly chosen from a unit sphere is the bias term. In order to show this, we need an elementary result which is

E s∈S d-1 [(s t v) 2 ] = v 2 d .

We show this result in Section A.4.1. Using this result,

E s∈S d-1 s ∇ x F (x, ξ) -∇ x g((r(x; θ); ψ) 2 = 1 d ∇ x F (x, ξ) -∇ x g((r(x; θ); ψ) 2 2 (37)

We introduce the notation ∆(s, x, ξ, θ, ψ) = s ∇ x F (x, ξ)-∇ x g((r(x; θ); ψ) 2 for clarity and, proceed to bound the difference ∆(s, x, ξ, θ, ψ) -E s [∆(s, x, ξ, θ, ψ) ] . Consider the sequence of differences as,

EQUATION

it is clear that E[Z t ] = 0 for all t. Moreover, the differences are bounded due to the Lipschitz continuity. Hence, Z t is a martingale difference sequence. We use the Freedman's inequality (Freedman, 1975) in order to bound Z t , similar to the seminal work studying the generalization of online learning by Kakade & Tewari (2009 ). Freedman's inequality (Freedman, 1975) states that if Z t is a martingale difference sequence,

EQUATION

)

where b is the bound on Z t as |Z t | ≤ b for all t. Before we substitute the Z t in the Freedman's inequality, we need to compute the variance of the Z t . We bound the variance using the definition of the variance as 

E s∈S d-1 s t ∇x F (x t , ξ t ) -∇xg((r(x t ; θ t ); ψ t ) 2 - 1 d ∇x F (x t , ξ t ) -∇xg((r(x t ; θ t ); ψ t ) 2 2 ≤ E s∈S d-1 1 d ∇x F (x t ,

≤ 1 d 2 ∇x F (x t , ξ t ) -∇xg((r(x t ; θ t ); ψ t ) 2 2 d 2 E s∈S d-1 [(ν s t ) 2 ] + 2L 2 ) = 2L 2 + d d 2 ∇x F (x t , ξ t ) -∇xg((r(x t ; θ t ); ψ t ) 2 2 (40)

where we denote the unit vector in the direction of ∇ x F (x t , ξ t ) -∇ x g((r(x t ; θ t ); ψ t ) as ν in (a) and use the Lipschitz property as well as ( 63) in (b). Finally we substitute this result in Freedman's inequality and use the expectation ∆(s t , x t , ξ t , θ t , ψ t ) from (37). We also introduce the shorthand notation ∆ t = ∆(s t , x t , ξ t , θ t , ψ ) . With probability at least 1 -4γ ln(T ),

EQUATION

We can further bound T t=1 E[∆ t ] by using the fact that ( 41) is in the form of s 2 ≤ r + max{2as, 6bc}c which can be solved for s using quadratic formula. We solve this quadratic in Section A.4.2, and show that it implies s ≤ r + 2ac √ r + max{4a 2 , 6b}c 2 . Using the solution of the quadratic formula, we get the following final result describing the effect of bandit feedback. With probability 1 -4γ ln(T ),

EQUATION

Published as a conference paper at ICLR 2020

In summary, we bound the difference between the effect of the bias T t=1 E[∆ t ] and the empirical loss we minimize T t=1 ∆ t without the noise term. In the next section, we procede to bound the empirical loss T t=1 L t and the effect of the noise term T t=1 |∆ t -L t |.

A.3.3 ANALYSIS OF THE EMPIRICAL LOSS:

In this section, we will analyze the empirical loss. Our analysis is similar to the regret analysis of Follow the Regularized Leader (FTRL). However, we do not get an adverserial bound. Our resulting bound is the function of distances of iterates denoted as x tx t-1 2 . Such a bound would not be useful in adverserial setting since adversary chooses the iterates. However, we also design the optimization method. Hence, we bound x tx t-1 2 by setting step sizes accordingly. We start our analysis with bounding the total empirical loss in terms of the length of the trajectory the learner takes. As a consequence of the FTL-BTL Lemma (Kalai & Vempala, 2005) ,

T t=1 L(s t , x t , ξ t , θ t , ψ t ) ≤ T t=1 L(s t , x t , ξ t , θ t , ψ t ) -L(s t , x t , ξ t , θ t+1 , ψ t+1 ) + R(θ T , ψ T ).

(43) We use the Lipschitz smoothness property to convert this into distance travelled by the learner as

EQUATION

)

With properly chosen λ, our regularizer enforces the smallest possible update, in terms of learner path length, which is consistent with the current sampled directions. This is due to the representability assumption which guarantees that manifold can be fit perfectly using the parametric family. Hence, there is a solution with L = 0. Considering the regularizer is the learner path length, with proper choice of λ, the FTRL will choose the shortest learner path length.

Among all choices of s t , s t = ∇xF (x t ,ξ t ) / ∇xF (x t ,ξ t ) would result in the longest distance. Hence, we can bound the learner path distance of our empirical problem with the distances of this oracle problem. We denote the θ and ψ found by this oracle problem as θ, ψ. 

EQUATION

as the consequence of the fact that oracle problem solves all gradients perfectly (i.e. ∇ x F (x t , ξ t ) = ∇ x g(r(x; θ i ); ψ i ) for all i > t) in (a), and the functions are µ-smooth in (b).

Using the fact that gradient norms are bounded,

EQUATION

In order to extend this result to the ∆ t , we use the smoothness of the function as

EQUATION

By combining ( 47) and ( 46), we state

EQUATION

A.3.4 PROOF OF THE THEOREM We combine the aforementioned three arguments to state the final sample complexity of our method. Our analysis of SGD with bias from (36) combined with the definition of the ∆ t gives the following bound on the sample complexity.

EQUATION

)

Using the concavity of the square root function with Jensen's inequality, we can convert this bound to

EQUATION

Next, we will bound

1 T T t=1 E[∆ t ] using (42).

For simplicity, we will analyze two cases

( T t=1 ∆ t ≤ 1) and ( T t=1 ∆ t > 1) seperately. Case 1, T t=1 ∆ t ≤ 1: We substitute this bound directly in (42). With probability 1 -4γ ln(T ), 1 T T t=1 E[∆ t ] ≤ 1 T + 2 T 2L 2 + d d ln( 1 /γ) + max 8L 2 + 4d dT , 6L 2 1 + d dT ln( 1 /γ) (51)

Relaxing the upper bound with the fact that dimension is greater than 1,

EQUATION

where

c 1 = 1 + (8L 2 + 4) ln( 1 /γ) + max{8L 2 + 4, 12L 2 } ln( 1 /γ).

Case 2, 1 T T t=1 ∆ t > 1: Using the fact that √ x < x for x > 1 and √ x + y ≤ √ x + √ y as well as d ≥ 1, we can state that with probability 1 -4γ ln(T ),

EQUATION

where c 2 = max{8L 2 + 4, 12L 2 } ln( 1 /γ) and c 3 = 1 + 2 (2L 2 + 1) ln( 1 /γ). Combining this with the bound (48) and

EQUATION

We combine two cases and substitute it in (50). The final sample complexity is,

1 T T t=1 ∇ x f (x t ) 2 ≤ Ω αT + µαV g 1 2 + 8c 3 Ω √ d + µ 2 δ 2 1 + Ωc 3 √ d + 2c 3 ΩL √ d T + c 1,2 d T .

(55) where c 1,2 = √ Ω max{c 1 , c 2 }. We minimize with respect to α t and substitute it.

EQUATION

Before we solve for δ, we bound V g by choosing β = 1 /d as,

EQUATION

)

Next, we solve δ to obtain the statement of the theorem. With probability 1 -4γ ln(T ),

EQUATION

where 

Hence, combining all, 

EQUATION

B ADDITIONAL IMPLEMENTATION DETAILS

In this section, we provide additional details for the implementation. Our experimental setup is also available open-source along with a full implementation of our method at https:// github.com/intel-isl/LMRS. One key element of our method is the parametric family we use to learn the manifold. We consider a multi-layered perceptron with one to three hidden layers as Linear(d, 2n) → ReLU → Linear(2n, n) → ReLU → Linear(n, n) for d < 1000 and Linear(d, 1 /2d) → ReLU → Linear( 1 /2d, 2n) → ReLU → Linear(2n, n) → ReLU → Linear(n, n) for d > 1000. We set the dimensionality of the manifold as the number of directions k which is a hyper parameter. We use grid search over δ and n = k values and choose the best performing one in all experiments. Moreover, we also reinitialize the manifold parameters whenever the estimated gradient's magnitude is less than 1e-6. We perform online gradient descent to learn the model parameters using SGD with momentum as 0.9. We also perform grid search for learning rate over {1e-4, 1e-3, 1e-2}. We set λ = 10 3 for all experiments.

We further discuss experiment-specific details below.

MuJoCo experiments. We use linear policies and initialize them as zeros, which corresponds to no action. We use v2-t algorithm from Mania et al. (2018) , which includes whitening of the observation space and using top-k directions instead of all. We use grid search over the parameter space described by Mania et al. (2018) for n = k, α and δ.

Low-dimensional unconstrained optimization suite. We use the following functions: sphere, noisysphere, cigar, tablet, cigtab, cigtab2, elli, rosen, rosen chained, diffpow, rosenelli, ridge, ridgecircle, happycat, branin, goldsteinprice, rastrigin, schaffer, schwefel2 22, lincon, rosen nesterov, styblinski tang, bukin with dimensions d = 10 and d = 100 resulting in total 46 problems. We initialize all solutions with zero mean unit variance normal variables and use grid search over δ ∈ {1e-4, 1e-3, 1e-2, 1e-1}, k ∈ {2, 5, 10, 50}, and α ∈ {1e-4, 1e-3, 1e-2, 1e-1}.

Airfoil optimization. We initialize the parameters of the manifold with zero-mean unit-variance normal variables. We use grid search over δ ∈ {1e-4, 1e-3, 1e-2, 1e-1}, k ∈ {2, 5, 10, 50}, and α ∈ {1e-4, 1e-3, 1e-2, 1e-1}. For choosing hyper-parameters, we simulate all models with Reynolds number 12e6, speed 0.4 mach, and angle of attack 5 degrees. After the hyper-parameters are set, we used Reynolds number 14e6, speed 0.6 mach and angle of attack 2 degrees for evaluation.

Implementation details for the baselines. For ARS, we use grid search over the parameters recommended by Mania et al. (2018) . For CMA-ES, we use pycma (Hansen et al., 2019) with recommended hyperparameters. For Bayesian optimization, we use the REMBO optimizer (Wang et al., 2016) with the following details. For continuous control problems, we use Structured Kernel Interpolation (SKI) (Wilson & Nickisch, 2015) and perform grid search over hyperparameters using the ranges recommended by GPyTorch (Gardner et al., 2018) . For other problems, we use full GP inference since the number of samples is rather low and perform grid search over kernel parameters following GPyTorch (Gardner et al., 2018) . As an acquisition function, we perform grid search over Optimistic Expected Improvement (Rontsis et al., 2017) , Multi-point Expected Improvement (Marmin et al., 2015) , and the approach of Ginsbourger et al. (2010) .

:

L-Lipschitz and µ-smooth: |f (x)-f (y)| ≤ L x-y

and ∇xf (x)-∇xf (y) 2 ≤ µ x-y 2 ∀x,y

Figures and Tables:

m , θ, ψ) + λR(θ, ψ) 7: end for See Algorithms 1 & 2 for definitions of GRADEST and MANIFOLDGRADEST.

Figure 1: Average reward vs. number of episodes for MuJoCo locomotion tasks. In each condition, we perform 5 runs with different random seeds. Shaded areas represent 1 standard deviation. The grey horizontal line indicates the prescribed threshold at which the task is considered 'solved'.

Figure2: Average reward vs. wall-clock time for MuJoCo locomotion tasks. In each condition, we perform 5 runs with different random seeds. Shaded areas represent 1 standard deviation. The grey horizontal line indicates the prescribed threshold at which the task is considered 'solved'. Measurements are performed on Intel Xeon E7-8890 v3 processors and Nvidia GeForce RTX 2080 Ti GPUs. We list the number of cores used for each experiment.

Figure 4: Performance profiles of our method and baselines on an optimization benchmark.

Figure 5: Effect of problem dimensionality and manifold dimensionality. Average objective value over 10 random seeds vs. number of function evaluations. Shaded areas represent 1 standard deviation.

k 1 = 2c 3 ΩL, k 2 = √ c 1,2 , k 3 = 2L √ 2µΩ, k 4 = 4LΩ √ µc 3 , k 5 = 3(2ΩV F ) 1 /3, andk 6 = k 5 (3Ωc 3 ). A.4 USEFUL ELEMENTARY RESULTS A.4.1 EXPECTATION OF (s v) 2 WHEN s IS CHOSEN UNIFORMLY FROM S d-1 Consider F (Oe)µ(O) where [•]µ(O)is an integral over orthogonal matrices with Haar measure. If e is a unit vector, we can show thatE s∈S d-1 [F (s)] = F (Oe)µ(O).(59)Before we use this result, we define v 2 as an integral over orthogonal matrices O. Using orthogonality and cyclic property of the trace,v v = Tr(vv ) = Tr(vv )µ(O) = Tr (OO vv ) µ(O) = Tr (O vv O) µ(O). (60) Since the indentity matrix is sum of outer products of one hot vectors e i as I = i e i e i , Tr (O vv O) µ(O) = Tr i e i e i O vv O µ(O) = i Tr (e i O vv Oe i ) µ(O).

, we can further showi Tr (e i O vv Oe i ) µ(O) = i E s∈S d-1 [Tr(s vv s)] = dE s∈S d-1 [(s v)]



Table content: <table/>

Generated airfoils with their lift and drag values after 1500 calls to XFoil

Table content: <table><tr><td/><td/><td/><td colspan="2">Airfoil after 1500 Simulations</td><td/><td/></tr><tr><td/><td>Init</td><td>LMRS</td><td>ARS</td><td>Guided ES</td><td>CMA-ES</td><td>REMBO</td></tr><tr><td>LIFT</td><td>-0.229</td><td>2.0126</td><td>0.567</td><td>1.231</td><td>1.418</td><td>1.8645</td></tr><tr><td>DRAG</td><td>0.040</td><td>0.0389</td><td>0.007</td><td>0.0598</td><td>0.0249</td><td>0.02123</td></tr><tr><td>LIFT -DRAG</td><td>-0.269</td><td>1.9737</td><td>0.560</td><td>1.1712</td><td>1.3931</td><td>1.8432</td></tr><tr><td>Foil</td><td/><td/><td/><td/><td/><td/></tr></table>

and Shamir (2013).Random search for learning continuous control. Learning continuous control is an active research topic that has received significant interest in the reinforcement learning community. Recently, Salimans et al. (2017) andMania et al. (2018) have shown that random search methods are competitive with state-of-the-art policy gradient algorithms in this setting.Vemula et al. (2019) analyzed this phenomenon theoretically and characterized the sample complexity of random search and policy gradient methods for continuous control.

Table content: <table/>

ξ t ) -∇xg((r(x t ; θ t ); ψ t ) ds t -∇x F (x t , ξ t ) + ∇xg((r(x t ; θ t ); ψ t )

Table content: <table><tr><td/><td/><td/><td/><td>2</td></tr><tr><td>(a) ≤</td><td>∇x F (x t , ξ t ) -∇xg((r(x t ; θ t ); ψ t ) d 2</td><td>2 2</td><td>E s∈S d-1 ν ds t -∇x F (x t , ξ t ) + ∇xg((r(x t ; θ t ); ψ t )</td><td>2</td></tr><tr><td>(b)</td><td/><td/><td/><td/></tr></table>

A.4.2 BOUNDING THE QUADRATIC FORMWe need to bound s when the following quadratic inequality is correct;≤ (ac + a 2 c 2 + r) 2 = a 2 c 2 + a 2 c 2 + r + 2ac a 2 c 2 + r ≤ 4a 2 c 2 + 2ac √ r + r (66)Combining the resulting bound with the other option gives the final bound as, s ≤ r + 2ac √ r + max{4a 2 , 6b}c 2

Table content: <table><tr><td/><td colspan="3">s ≤ r + max{2a</td><td>√</td><td>s, 6bc}c.</td><td>(64)</td></tr><tr><td colspan="7">We first consider the max as two separate options. Given the original inequality, one of the following</td></tr><tr><td>is correct;</td><td>s ≤ r + 2ac √</td><td>s,</td><td>or</td><td/><td>s ≤ r + 6bc 2 .</td><td>(65)</td></tr><tr><td colspan="6">For the first case, ( largest root as √ s ≤ ac + √ s) 2 -2ac √ √ a 2 c 2 + r. Hence, s -r ≤ 0. Using the quadratic formula, s = ( √ s) 2</td><td>√</td><td>s is smaller than the</td></tr></table>

Peer review (iclr2020):
The computation times for random search methods depend largely on the total dimension of the problem. The larger the problem, the longer it takes to perform a single iteration. I believe the main reason why many people use deep reinforcement learning to solve their problems is due to its dimension-independence. I am not aware of a paper that tries to minimize the sample complexity. Thus, I think the idea in this paper is novel and may have influence on the literature (maybe an encouragement for a shift from deep reinforcement learning to derivative-free optimization methods). In terms of presented results I think that there is not much that they could do wrong. They show in Figure 1 that the reward they achieved with their method is only outperformed by Augmented Random Search (ARS) on the Ant task. On all other tasks, their method at least performs on par with ARS which is a good result. In Table 1 they show the number of episodes that are needed to achieve the reward threshold. Their method required less episodes than all other methods, but I think this is not the only criteria they should have looked at. So, it might be the case that their iterations take longer to compute than the iterations of the ARS and thereby making it slower. The authors have showed that their method has a lower sample complexity, which is their goal of the research (“Our major objective is to improve the sample efficiency of random search.”). However, I am not sure whether this means that it also has a lower computational complexity. They address this issue briefly by stating that “Our method increases the amount of computation since we need to learn a model while performing the optimization. However, in DFO, the major computational bottleneck is typically the function evaluation. When efficiently implemented on a GPU, total time spent on learning the manifold is negligible in comparison to function evaluations.” This would mean that their iterations are performed in less computation time than the ARS, but I would have personally liked to see a number attached to this. If we thus assume that this is the case, then their results are sound. However, I do not see this reduced complexity reflected in the results. If I look at the ratios between the number of episodes it takes to solve the tasks, they seem to be similar to the ones from the ARS. The number of episodes reduces by roughly 50% for all tasks but this keeps the ratio between the different tasks identical. I would have assumed that the ratios would increase in the favor of the larger problems like the Humanoid task. In other words, I still see the influence of the larger dimension in the results. Maybe I am too critical, but to me if they would have just found a faster method without the reduced sample complexity, they would have achieved similar results. Of course, this problem would not be present if the computation time increases with the number of iterations. In that case, the computation time would not reduce by a “fixed” ratio and would therefore decrease relatively much on the tasks with a higher dimension. But that would require an exact comparison between the computation times for all tasks for both their method and the ARS which I do not see in their results. If all these things are common knowledge, then their results are sound and they have found a large improvement to the already well performing ARS.