def run_predict(data, final_model, settings, save_folds=False, dknn_only=False):
"""
Runs benchmark based on final_model without training everything again.
It also computes the Knn distance and puts it in the results pickle.
In fine, this should be integrated inside modnet benchmark.
:param data:
:param final_model:
:param settings:
:return:
"""
task = settings["task"]
# rebuild the EnsembleMODNetModels from the final model
n_best_archs = 5 # change this (from 1 to 5 max) to adapt number of inner best archs chosen
bootstrap_size = 5
outer_fold_size = bootstrap_size * 5 * 5
inner_fold_size = bootstrap_size * 5
models = []
multi_target = bool(len(data.df_targets.columns) - 1)
for i in range(5): # outer fold
modnet_models = []
for j in range(5): # inner fold
modnet_models+=(
final_model.model[(i * outer_fold_size) + (j * inner_fold_size):
(i * outer_fold_size) + (j * inner_fold_size) + (n_best_archs * bootstrap_size)])
model = EnsembleMODNetModel(modnet_models=modnet_models)
models.append(model)
if dknn_only:
with open(f"results/{task}_results.pkl", "rb") as f:
results = pickle.load(f)
results["dknns"] = []
else:
results = defaultdict(list)
for ind, (train, test) in enumerate(matbench_kfold_splits(data, classification=settings.get("classification", False))):
train_data, test_data = data.split((train, test))
path = "folds/train_moddata_f{}".format(ind + 1)
train_data = MODData.load(path)
assert len(set(train_data.df_targets.index).intersection(set(test_data.df_targets.index))) == 0
model = models[ind]
# compute dkNN
# TODO: test this quickly before submitting
max_feat_model = np.argmax([m.n_feat for m in model.model])
n_feat = model.model[max_feat_model].n_feat
feature_names = model.model[max_feat_model].optimal_descriptors
dknn = get_dknn(train_data, test_data, feature_names)
results["dknns"].append(dknn)
if dknn_only:
continue
predict_kwargs = {}
if settings.get("classification"):
predict_kwargs["return_prob"] = True
if model.can_return_uncertainty:
predict_kwargs["return_unc"] = True
pred_results = model.predict(test_data, **predict_kwargs)
if isinstance(pred_results, tuple):
predictions, stds = pred_results
else:
predictions = pred_results
stds = None
targets = test_data.df_targets
if settings.get("classification"):
from sklearn.metrics import roc_auc_score
from sklearn.preprocessing import OneHotEncoder
y_true = OneHotEncoder().fit_transform(targets.values).toarray()
score = roc_auc_score(y_true, predictions.values)
pred_bool = model.predict(test_data, return_prob=False)
print(f"ROC-AUC: {score}")
errors = targets - pred_bool
elif multi_target:
errors = targets - predictions
score = np.mean(np.abs(errors.values), axis=0)
else:
errors = targets - predictions
score = np.mean(np.abs(errors.values))
if save_folds:
opt_feat = train_data.optimal_features[:n_feat]
df_train = train_data.df_featurized
df_train = df_train[opt_feat]
df_train.to_csv("folds/train_f{}.csv".format(ind + 1))
df_test = test_data.df_featurized
df_test = df_test[opt_feat]
errors.columns = [x + "_error" for x in errors.columns]
df_test = df_test.join(errors)
df_test.to_csv("folds/test_f{}.csv".format(ind + 1))
results["predictions"].append(predictions)
if stds is not None:
results["stds"].append(stds)
results["targets"].append(targets)
results["errors"].append(errors)
results["scores"].append(score)
results['model'].append(model)
return results
def fit_preset(
self,
data: MODData,
presets: List[Dict[str, Any]] = None,
val_fraction: float = 0.15,
verbose: int = 0,
classification: bool = False,
refit: bool = True,
fast: bool = False,
nested: int = 5,
callbacks: List[Any] = None,
n_jobs=None,
) -> Tuple[List[List[Any]], np.ndarray, Optional[List[float]],
List[List[float]], Dict[str, Any], ]:
"""Chooses an optimal hyper-parametered MODNet model from different presets.
This function implements the "inner loop" of a cross-validation workflow. By
modifying the `nested` argument, it can be run in full nested mode (i.e.
train n_fold * n_preset models) or just with a simple random hold-out set.
The data is first fitted on several well working MODNet presets
with a validation set (10% of the furnished data by default).
Sets the `self.model` attribute to the model with the lowest mean validation loss across
all folds.
Args:
data: MODData object contain training and validation samples.
presets: A list of dictionaries containing custom presets.
verbose: The verbosity level to pass to tf.keras
val_fraction: The fraction of the data to use for validation.
classification: Whether or not we are performing classification.
refit: Whether or not to refit the final model for each fold with
the best-performing settings.
fast: Used for debugging. If `True`, only fit the first 2 presets and
reduce the number of epochs.
nested: integer specifying whether or not to perform a full nested CV. If 0,
a simple validation split is performed based on val_fraction argument.
If an integer, use this number of inner CV folds, ignoring the `val_fraction` argument.
Note: If set to 1, the value will be overwritten to a default of 5 folds.
n_jobs: number of jobs for multiprocessing
Returns:
- A list of length num_outer_folds containing lists of MODNet models of length num_inner_folds.
- A list of validation losses achieved by the best model for each fold during validation (excluding refit).
- The learning curve of the final (refitted) model (or `None` if `refit` is `False`)
- A nested list of learning curves for each trained model of lengths (num_outer_folds, num_inner folds).
- The settings of the best-performing preset.
"""
from modnet.matbench.benchmark import matbench_kfold_splits
if callbacks is None:
es = tf.keras.callbacks.EarlyStopping(
monitor="loss",
min_delta=0.001,
patience=100,
verbose=verbose,
mode="auto",
baseline=None,
restore_best_weights=False,
)
callbacks = [es]
if presets is None:
from modnet.model_presets import gen_presets
presets = gen_presets(
len(data.optimal_features),
len(data.df_targets),
classification=classification,
)
if fast and len(presets) >= 2:
presets = presets[:2]
for k, _ in enumerate(presets):
presets[k]["epochs"] = 100
num_nested_folds = 5
if nested:
num_nested_folds = nested
if num_nested_folds <= 1:
num_nested_folds = 5
# create tasks
splits = matbench_kfold_splits(data,
n_splits=num_nested_folds,
classification=classification)
if not nested:
splits = [
train_test_split(range(len(data.df_featurized)),
test_size=val_fraction)
]
n_splits = 1
else:
n_splits = num_nested_folds
train_val_datas = []
for train, val in splits:
train_val_datas.append(data.split((train, val)))
tasks = []
for i, params in enumerate(presets):
n_feat = min(len(data.get_optimal_descriptors()), params["n_feat"])
for ind in range(n_splits):
val_params = {}
train_data, val_data = train_val_datas[ind]
val_params["val_data"] = val_data
tasks += [{
"train_data": train_data,
"targets": self.targets,
"weights": self.weights,
"num_classes": self.num_classes,
"n_feat": n_feat,
"num_neurons": params["num_neurons"],
"lr": params["lr"],
"batch_size": params["batch_size"],
"epochs": params["epochs"],
"loss": params["loss"],
"act": params["act"],
"out_act": self.out_act,
"callbacks": callbacks,
"preset_id": i,
"fold_id": ind,
"verbose": verbose,
**val_params,
}]
val_losses = 1e20 * np.ones((len(presets), n_splits))
learning_curves = [[None for _ in range(n_splits)]
for _ in range(len(presets))]
models = [[None for _ in range(n_splits)] for _ in range(len(presets))]
ctx = multiprocessing.get_context("spawn")
pool = ctx.Pool(processes=n_jobs)
LOG.info(
f"Multiprocessing on {n_jobs} cores. Total of {multiprocessing.cpu_count()} cores available."
)
for res in tqdm.tqdm(
pool.imap_unordered(map_validate_model, tasks, chunksize=1),
total=len(tasks),
):
val_loss, learning_curve, model, preset_id, fold_id = res
LOG.info(f"Preset #{preset_id} fitting finished, loss: {val_loss}")
# reload the model object after serialization
model._restore_model()
val_losses[preset_id, fold_id] = val_loss
learning_curves[preset_id][fold_id] = learning_curve
models[preset_id][fold_id] = model
pool.close()
pool.join()
val_loss_per_preset = np.mean(val_losses, axis=1)
best_preset_idx = int(np.argmin(val_loss_per_preset))
best_model_idx = int(np.argmin(val_losses[best_preset_idx, :]))
best_preset = presets[best_preset_idx]
best_learning_curve = learning_curves[best_preset_idx][best_model_idx]
best_model = models[best_preset_idx][best_model_idx]
LOG.info(
"Preset #{} resulted in lowest validation loss with params {}".
format(best_preset_idx + 1,
tasks[n_splits * best_preset_idx + best_model_idx]))
if refit:
LOG.info("Refitting with all data and parameters: {}".format(
best_preset))
# Building final model
n_feat = min(len(data.get_optimal_descriptors()),
best_preset["n_feat"])
self.model = MODNetModel(
self.targets,
self.weights,
num_neurons=best_preset["num_neurons"],
n_feat=n_feat,
act=best_preset["act"],
out_act=self.out_act,
num_classes=self.num_classes,
).model
self.n_feat = n_feat
self.fit(
data,
val_fraction=0,
lr=best_preset["lr"],
epochs=best_preset["epochs"],
batch_size=best_preset["batch_size"],
loss=best_preset["loss"],
callbacks=callbacks,
verbose=verbose,
)
else:
self.n_feat = best_model.n_feat
self.model = best_model.model
self._scaler = best_model._scaler
return models, val_losses, best_learning_curve, learning_curves, best_preset