def test_q_multi_fidelity_max_value_entropy(self):
for dtype in (torch.float, torch.double):
torch.manual_seed(7)
mm = MESMockModel()
train_inputs = torch.rand(10, 2, device=self.device, dtype=dtype)
mm.train_inputs = (train_inputs, )
candidate_set = torch.rand(10, 2, device=self.device, dtype=dtype)
qMF_MVE = qMultiFidelityMaxValueEntropy(
model=mm, candidate_set=candidate_set, num_mv_samples=10)
# test initialization
self.assertEqual(qMF_MVE.num_fantasies, 16)
self.assertEqual(qMF_MVE.num_mv_samples, 10)
self.assertIsInstance(qMF_MVE.sampler, SobolQMCNormalSampler)
self.assertIsInstance(qMF_MVE.cost_sampler, SobolQMCNormalSampler)
self.assertEqual(qMF_MVE.sampler.sample_shape, torch.Size([128]))
self.assertIsInstance(qMF_MVE.fantasies_sampler,
SobolQMCNormalSampler)
self.assertEqual(qMF_MVE.fantasies_sampler.sample_shape,
torch.Size([16]))
self.assertIsInstance(qMF_MVE.expand, Callable)
self.assertIsInstance(qMF_MVE.project, Callable)
self.assertIsNone(qMF_MVE.X_pending)
self.assertEqual(qMF_MVE.posterior_max_values.shape,
torch.Size([10, 1]))
self.assertIsInstance(qMF_MVE.cost_aware_utility,
InverseCostWeightedUtility)
# test evaluation
X = torch.rand(1, 2, device=self.device, dtype=dtype)
self.assertEqual(qMF_MVE(X).shape, torch.Size([1]))
def _instantiate_MES(
model: Model,
candidate_set: Tensor,
num_fantasies: int = 16,
num_mv_samples: int = 10,
num_y_samples: int = 128,
use_gumbel: bool = True,
X_pending: Optional[Tensor] = None,
maximize: bool = True,
num_trace_observations: int = 0,
target_fidelities: Optional[Dict[int, float]] = None,
fidelity_weights: Optional[Dict[int, float]] = None,
cost_intercept: float = 1.0,
) -> qMaxValueEntropy:
if target_fidelities:
if fidelity_weights is None:
fidelity_weights = {f: 1.0 for f in target_fidelities}
if not set(target_fidelities) == set(fidelity_weights):
raise RuntimeError(
"Must provide the same indices for target_fidelities "
f"({set(target_fidelities)}) and fidelity_weights "
f" ({set(fidelity_weights)})."
)
cost_model = AffineFidelityCostModel(
fidelity_weights=fidelity_weights, fixed_cost=cost_intercept
)
cost_aware_utility = InverseCostWeightedUtility(cost_model=cost_model)
def project(X: Tensor) -> Tensor:
return project_to_target_fidelity(X=X, target_fidelities=target_fidelities)
def expand(X: Tensor) -> Tensor:
return expand_trace_observations(
X=X,
fidelity_dims=sorted(target_fidelities), # pyre-ignore: [6]
num_trace_obs=num_trace_observations,
)
return qMultiFidelityMaxValueEntropy(
model=model,
candidate_set=candidate_set,
num_fantasies=num_fantasies,
num_mv_samples=num_mv_samples,
num_y_samples=num_y_samples,
X_pending=X_pending,
maximize=maximize,
cost_aware_utility=cost_aware_utility,
project=project,
expand=expand,
)
return qMaxValueEntropy(
model=model,
candidate_set=candidate_set,
num_fantasies=num_fantasies,
num_mv_samples=num_mv_samples,
num_y_samples=num_y_samples,
X_pending=X_pending,
maximize=maximize,
)