def test_choice_function_fixed(trivial_choice_problem, name):
tf.set_random_seed(0)
os.environ["KERAS_BACKEND"] = "tensorflow"
np.random.seed(123)
x, y = trivial_choice_problem
choice_function = choice_functions[name][0]
params, accuracies = choice_functions[name][1], choice_functions[name][2]
params["n_objects"], params["n_object_features"] = tuple(x.shape[1:])
learner = choice_function(**params)
if name == GLM_CHOICE:
learner.fit(
x,
y,
vi_params={
"n": 100,
"method": "advi",
"callbacks": [CheckParametersConvergence()],
},
)
elif "linear" in name:
learner.fit(x, y, epochs=10, validation_split=0, verbose=False)
else:
learner.fit(x, y, epochs=100, validation_split=0, verbose=False)
s_pred = learner.predict_scores(x)
y_pred = learner.predict_for_scores(s_pred)
y_pred_2 = learner.predict(x)
rtol = 1e-2
atol = 5e-2
assert np.isclose(
0.0, subset_01_loss(y_pred, y_pred_2), rtol=rtol, atol=atol, equal_nan=False
)
for key, value in accuracies.items():
metric = choice_metrics[key]
if metric in metrics_on_predictions:
pred_loss = metric(y, y_pred)
else:
pred_loss = metric(y, s_pred)
assert np.isclose(value, pred_loss, rtol=rtol, atol=atol, equal_nan=False)
params = {
"n_hidden": 20,
"n_units": 20,
"n_hidden_set_units": 2,
"n_hidden_set_layers": 10,
"n_hidden_joint_units": 2,
"n_hidden_joint_layers": 10,
"reg_strength": 1e-3,
"learning_rate": 1e-1,
"batch_size": 32,
"alpha": 0.5,
"l1_ratio": 0.7,
"tol": 1e-2,
"C": 10,
"n_mixtures": 10,
"n_nests": 5,
"regularization": "l2",
}
learner.set_tunable_parameters(**params)
check_params_tunable(learner, params, rtol, atol)
def test_choice_function_fixed(trivial_choice_problem, name):
np.random.seed(123)
# Pytorch does not guarantee full reproducibility in different settings
# [1]. This may become a problem in the test suite, in which case we should
# increase the tolerance. These are only "sanity checks" on small data sets
# anyway and the exact values do not mean much here.
# [1] https://pytorch.org/docs/stable/notes/randomness.html
torch.manual_seed(123)
# Trade off performance for better reproducibility.
torch.use_deterministic_algorithms(True)
x, y = trivial_choice_problem
choice_function = choice_functions[name][0]
params, accuracies = choice_functions[name][1], choice_functions[name][2]
learner = choice_function(**params)
if name == GLM_CHOICE:
learner.fit(
x,
y,
vi_params={
"n": 100,
"method": "advi",
"callbacks": [CheckParametersConvergence()],
},
)
else:
learner.fit(x, y)
s_pred = learner.predict_scores(x)
y_pred = learner.predict_for_scores(s_pred)
y_pred_2 = learner.predict(x)
rtol = 1e-2
atol = 5e-2
assert np.isclose(0.0,
subset_01_loss(y_pred, y_pred_2),
rtol=rtol,
atol=atol,
equal_nan=False)
for key, value in accuracies.items():
metric = choice_metrics[key]
if metric in metrics_on_predictions:
pred_loss = metric(y, y_pred)
else:
pred_loss = metric(y, s_pred)
assert np.isclose(value,
pred_loss,
rtol=rtol,
atol=atol,
equal_nan=False)
def test_discrete_choice_function_fixed(trivial_discrete_choice_problem, name):
np.random.seed(123)
# There are some caveats with pytorch reproducibility. See the comment on
# the corresponding line of `test_choice_functions.py` for details.
torch.manual_seed(123)
torch.use_deterministic_algorithms(True)
x, y = trivial_discrete_choice_problem
choice_function = discrete_choice_functions[name][0]
params, accuracies = (
discrete_choice_functions[name][1],
discrete_choice_functions[name][2],
)
learner = choice_function(**params)
if name in [MNL, NLM, GEV, PCL, MLM]:
learner.fit(
x,
y,
vi_params={
"n": 100,
"method": "advi",
"callbacks": [CheckParametersConvergence()],
},
)
else:
learner.fit(x, y)
s_pred = learner.predict_scores(x)
y_pred = learner.predict_for_scores(s_pred)
y_pred_2 = learner.predict(x)
rtol = 1e-2
atol = 5e-2
assert np.isclose(0.0,
subset_01_loss(y_pred, y_pred_2),
rtol=rtol,
atol=atol,
equal_nan=False)
for key, value in accuracies.items():
metric = metrics[key]
if metric in metrics_on_predictions:
pred_loss = metric(y, y_pred)
else:
pred_loss = metric(y, s_pred)
assert np.isclose(value,
pred_loss,
rtol=rtol,
atol=atol,
equal_nan=False)
def test_choice_function_fixed(trivial_choice_problem, name):
tf.set_random_seed(0)
os.environ["KERAS_BACKEND"] = "tensorflow"
np.random.seed(123)
x, y = trivial_choice_problem
choice_function = choice_functions[name][0]
params, accuracies = choice_functions[name][1], choice_functions[name][2]
learner = choice_function(**params)
if name == GLM_CHOICE:
learner.fit(
x,
y,
vi_params={
"n": 100,
"method": "advi",
"callbacks": [CheckParametersConvergence()],
},
)
elif "linear" in name:
learner.fit(x, y, epochs=10, validation_split=0, verbose=False)
else:
learner.fit(x, y, epochs=100, validation_split=0, verbose=False)
s_pred = learner.predict_scores(x)
y_pred = learner.predict_for_scores(s_pred)
y_pred_2 = learner.predict(x)
rtol = 1e-2
atol = 5e-2
assert np.isclose(0.0,
subset_01_loss(y_pred, y_pred_2),
rtol=rtol,
atol=atol,
equal_nan=False)
for key, value in accuracies.items():
metric = choice_metrics[key]
if metric in metrics_on_predictions:
pred_loss = metric(y, y_pred)
else:
pred_loss = metric(y, s_pred)
assert np.isclose(value,
pred_loss,
rtol=rtol,
atol=atol,
equal_nan=False)