Gaussian optimization Convergence Warning

[glitchyordis]

I got the following ConvergenceWarning while running BayesianOptimizer. Can you guide me on what values to choose and how to change them?

lib\site-packages\sklearn\gaussian_process\kernels.py:442: ConvergenceWarning:

The optimal value found for dimension 0 of parameter k2__noise_level is close to the specified lower bound 1e-05. Decreasing the bound and calling fit again may find a better value.

[SimonBlanke]

Hello @glitchyordis,

I am happy to help! Could you provide a small example, that I can run to reproduce this? The convergence-warning depends on the data that is provided to the gaussian-process. The data is the positions and scores collected during the optimization run. So the shape of the objective-function is a very important factor here.

[glitchyordis]

Hi @SimonBlanke ,

Attached is a reproducible code. In summary, the optimizer was executed on a Gaussian surface with added noise.

I've added a function to plot the surface if that helps.

import numpy as np
import numpy.typing as npt
import plotly.graph_objs as go

from scipy.interpolate import RegularGridInterpolator
from scipy.stats import multivariate_normal

from gradient_free_optimizers import BayesianOptimizer

if __name__ == "__main__":
    def get_raw_value(x: npt.NDArray|float, y: npt.NDArray|float, 
                      gaussians: dict, axis_key: str):
        # Ensure inputs are numpy arrays for consistent processing
        x = np.asarray(x)
        y = np.asarray(y)
        pos = np.dstack((x, y))
        
        value = np.zeros_like(x, dtype=float)
        # Sum the PDF values from each Gaussian component
        for g in gaussians[axis_key]:
            # g: scipy.stats._multivariate.multivariate_normal_frozen
            # g.pdf can handle arrays of shape (..., 2)
            value += g.pdf(pos)
        return value
    
    def plot_surface(x, y, z, title="Objective Function"):
        fig3d = go.Figure()
        fig3d.add_trace(go.Surface(
            # contours={
            #     "z": {"show": True,
            #             "start": 0.2,
            #             "end": 1.0,
            #             "size": 0.2,
            #             "usecolormap": False, 
            #             "color": "cyan",
            #             "width": 3,
            #         "project_z": True},},
            z=z,
            x=x,
            y=y,
            colorscale='cividis',
            colorbar=dict(title='Norm. Reward'),
            hovertemplate='x: %{x:.2f}<br>y: %{y:.2f}<br>Sum: %{z:.3f}<extra></extra>'
        ))

        fig3d.update_layout(
            title=title,
            scene=dict(
                    xaxis=dict(
                    title='x',
                    range=[x.min(), x.max()],  # Ensure x increases left to right
                ),
                yaxis=dict(
                    title='y',
                    range=[y.min(), y.max()],  # Ensure y increases bottom to top
                ),
                zaxis=dict(
                    title='Norm. Reward',
                ),
                aspectratio=dict(x=1, y=1, z=0.7)
            ),
            legend_title_text='Features',
            legend=dict(
                orientation="h",
                yanchor="top",
                y=-0.2,
                xanchor="left",
                x=0.1
            ),
            width=900,
            height=800
        )
        fig3d.show()
    
    search_space = {
        "hori": np.linspace(1.5, 4.5, 301),
        "vert": np.linspace(1.5, 4.5, 301)
    }
    peaks = {"hori_vert": [],}
    gaussians = {"hori_vert": [],}

    # gaussian peaks
    peak = {
        "mean": np.asarray([round(np.median(search_space["hori"]), 2), 
                            round(np.median(search_space["vert"]), 2)], dtype=np.float32),
        "covm": np.asarray([[0.1, 0], 
                            [0, 0.1]], dtype=np.float32)
    }
    peaks["hori_vert"].append(peak)
        
    for p in peaks["hori_vert"]:
        mean = p['mean']
        cov = p['covm']
        g = multivariate_normal(mean=mean, cov=cov, allow_singular=False)
        gaussians["hori_vert"].append(g)
    
    x, y = np.meshgrid(search_space["hori"],
                       search_space["vert"])
    value = get_raw_value(x, y, gaussians, "hori_vert",)
    noise = np.random.normal(loc=0, scale=0.05, 
                             size=value.shape)
    value = np.clip(value + noise, 0, np.inf)
    value /= np.max(value) # normalize to [0, 1]

    interpolator = RegularGridInterpolator((search_space["vert"],
                                            search_space["hori"],), value)
    
    plot_surface(x, y, value, title="Objective Function")
    
    def objective_function(para):
        hori, vert = round(para["hori"],2), round(para["vert"],2)
        return interpolator(np.array([vert, hori]).reshape(-1, 2))

    optimizer = BayesianOptimizer(search_space)
    optimizer.search(objective_function, n_iter=50,)

[SimonBlanke]

Thanks! I'll run the example when i get back from work. You could also take a look at the search data. If the warning occurs e.g. after the 20th iteration, you could look into the next iterations in the search data. Does the new search positions make sense? Does the optimizer still find good solutions?

[SimonBlanke]

I looked into the surface plot and the search-data. The bayesian optimization works just fine and does a great job finding the optimum (at n_iter ~15). This is very good if you consider, that the first 10 iterations are initializations.

Sklearn is known for its verbose warnings. That is why many silence them via this code:

def warn(*args, **kwargs):
    pass

import warnings
warnings.warn = warn

If you want further answers why the warning is necessary I would advice you to search in the sklearn project.

[glitchyordis]

I see. I'll take a look at the sklearn page to learn more about the optimizer. How do I change the k2__noise_level of this library's Bayesian Optimizer?