RuntimeError: expected scalar type Double but found Float

[A-ep93]

I created the following code:
However, I get an error. I appreciate it if anyone can rune my code and let me know where is the problem. My function has two inputs and two outputs.

import os
import torch
import numpy as np



tkwargs = {
    "dtype": torch.double,
    "device": torch.device("cuda" if torch.cuda.is_available() else "cpu"),
}





def black_box_function2(input):
    result= []
    xl= input.cpu().detach().numpy()
    size=len(xl)
    for o in range(0,size):
        x=xl[o,0]
        y=xl[o,1]
        yout=x**2+y**2
        yout=float(yout)
        youtS=x**3+y**3
        youtS=float(youtS)
        out=([yout,youtS])
        result.append(out)
    return torch.tensor(result)

train_X = torch.rand(20, 2)
train_Y = black_box_function2(train_X)


TX= train_X.cpu().detach().numpy()
in1=torch.tensor(np.transpose([TX[:,0]]))
in2=torch.tensor(np.transpose([TX[:,1]]))

TY= train_Y.cpu().detach().numpy()
out1=torch.tensor(np.transpose([TY[:,0]]))
out2=torch.tensor(np.transpose([TY[:,1]]))

best_observed_value1=out1.max()
best_observed_value2=out2.max()
BestSoFar=[[best_observed_value1],[best_observed_value2]]



from botorch.models.gp_regression import SingleTaskGP
from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood
from botorch.models.transforms.outcome import Standardize
from botorch.models import ModelListGP
from gpytorch.mlls.sum_marginal_log_likelihood import SumMarginalLogLikelihood


models = [
        SingleTaskGP(
            train_X,
            train_Y[..., i : i + 1],
            outcome_transform=Standardize(m=1),
        )
        for i in range(train_Y.shape[-1])
    ]
        
model = ModelListGP(*models)
mll = SumMarginalLogLikelihood(model.likelihood, model)



from botorch import fit_gpytorch_model

fit_gpytorch_model(mll)



from botorch.acquisition.monte_carlo import qExpectedImprovement
from botorch.utils.sampling import sample_simplex
from botorch.acquisition.objective import GenericMCObjective
from botorch.utils.multi_objective.scalarization import get_chebyshev_scalarization
from botorch.sampling.samplers import SobolQMCNormalSampler

NUM_RESTARTS = 20 
MC_SAMPLES=128
RAW_SAMPLES = 1024 


qparego_sampler = SobolQMCNormalSampler(num_samples=MC_SAMPLES)
weights = torch.tensor([1,1], dtype=torch.float64)
objective = GenericMCObjective(get_chebyshev_scalarization(weights=weights, Y=train_Y))
acq_func = qExpectedImprovement(  # pyre-ignore: [28]
    model=model,
    objective=objective,
    best_f=objective(train_Y).max(),
    sampler=qparego_sampler,
)



from botorch.optim import optimize_acqf
bounds=torch.tensor([[1,0],[10,0.5]],dtype=torch.float64)


candidates, _ = optimize_acqf(
        acq_function=acq_func,
        bounds=bounds,
        q=1,
        num_restarts=NUM_RESTARTS,
        raw_samples=RAW_SAMPLES,  # used for intialization heuristic
        options={"batch_limit": 5, "maxiter": 200, "nonnegative": True},
        sequential=True,
    )

I get this error:
RuntimeError: expected scalar type Double but found Float

[wjmaddox]

This is because this line is causing your candidates to be generated in double rather than float precision:

bounds=torch.tensor([[1,0],[10,0.5]],dtype=torch.float64)
# change to 
bounds=torch.tensor([[1,0],[10,0.5]],dtype=torch.float)