diff --git a/Barite_50_Data.h5 b/Barite_50_Data.h5 deleted file mode 100644 index 91ec8d7..0000000 --- a/Barite_50_Data.h5 +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:925b9e7a484e38bb0ba3ffb9f487854e471b476379f3d1c1adc08112f49f3eeb -size 13021031 diff --git a/Barite_50_Data_inference.h5 b/Barite_50_Data_inference.h5 deleted file mode 100644 index 4a8c6ee..0000000 --- a/Barite_50_Data_inference.h5 +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:03523c238f6afe6585a7c93110fee1f3b1f52da6a262d62fe0184646b5a48798 -size 168757224 diff --git a/Barite_50_Data_training.h5 b/Barite_50_Data_training.h5 deleted file mode 100644 index 182d286..0000000 --- a/Barite_50_Data_training.h5 +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:3c35aae40ae8bbe153a59cdaa5ac687769f1c00e7482b4925602179093a9767f -size 329314569 diff --git a/__pycache__/preprocessing.cpython-311.pyc b/__pycache__/preprocessing.cpython-311.pyc index ebe217b..41b0d6a 100644 Binary files a/__pycache__/preprocessing.cpython-311.pyc and b/__pycache__/preprocessing.cpython-311.pyc differ diff --git a/barite_50_4_corner.h5 b/barite_50_4_corner.h5 deleted file mode 100644 index f55a844..0000000 --- a/barite_50_4_corner.h5 +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:d135c6696d4a0068b442f8e58c77842dcc8c229b79fe9ae0af030cfc3e813bf7 -size 62127814 diff --git a/doc/measurement_plan.md b/doc/measurement_plan.md new file mode 100644 index 0000000..7faf52b --- /dev/null +++ b/doc/measurement_plan.md @@ -0,0 +1,24 @@ +# Measurement overview for model optimization + +### Parameters to optimize + + + + + + + +### Saved models + +`./results/model_large_standardization.keras`: Trained on `barite_50_4_corner.h5` dataset with extended Loss function (Huber loss with mass balance) and **standardized data** + + + + + +### Experiments + +| **Experiment** | **Dataset** | **Model** | **Lossfunction** | **Activation** | **Preprocessing** | +|----------------|-----------------------|-----------|------------------|----------------|-------------------|-------------------| +| 1 | barite_50_4_corner.h5 | large | Huber+dBa+dSa | LeakuRelu | Standardization | +| 2 | barite_50_4_corner.h5 | diff --git a/loss_1_to_end.png b/loss_1_to_end.png deleted file mode 100644 index fe5b726..0000000 Binary files a/loss_1_to_end.png and /dev/null differ diff --git a/loss_all.png b/loss_all.png deleted file mode 100644 index 9b45cb2..0000000 Binary files a/loss_all.png and /dev/null differ diff --git a/optuna_runs.py b/optuna_runs.py deleted file mode 100644 index 0df7b3f..0000000 --- a/optuna_runs.py +++ /dev/null @@ -1,225 +0,0 @@ -import keras -from keras.layers import Dense, Dropout, Input,BatchNormalization -import tensorflow as tf -import h5py -import numpy as np -import pandas as pd -import time -import sklearn.model_selection as sk -import matplotlib.pyplot as plt -from sklearn.cluster import KMeans -from sklearn.pipeline import Pipeline, make_pipeline -from sklearn.preprocessing import StandardScaler, MinMaxScaler -from imblearn.over_sampling import SMOTE -from imblearn.under_sampling import RandomUnderSampler -from imblearn.over_sampling import RandomOverSampler -from collections import Counter -import os -from preprocessing import * -from sklearn import set_config -from importlib import reload -set_config(transform_output = "pandas") - -dtype = "float32" -activation = "relu" - -lr = 0.001 -batch_size = 512 -epochs = 50 # default 400 epochs - -lr_schedule = keras.optimizers.schedules.ExponentialDecay( - initial_learning_rate=lr, - decay_steps=2000, - decay_rate=0.9, - staircase=True -) - -optimizer_simple = keras.optimizers.Adam(learning_rate=lr_schedule) -optimizer_large = keras.optimizers.Adam(learning_rate=lr_schedule) -optimizer_paper = keras.optimizers.Adam(learning_rate=lr_schedule) - -sample_fraction = 0.8 - -# small model -model_simple = keras.Sequential( - [ - keras.Input(shape = (9,), dtype = "float32"), - keras.layers.Dense(units = 128, activation = "linear", dtype = "float32"), - # Dropout(0.2), - keras.layers.Dense(units = 128, activation = "elu", dtype = "float32"), - keras.layers.Dense(units = 9, dtype = "float32") - ] -) - -def Safelog(val): - # get range of vector - if val > 0: - return np.log10(val) - elif val < 0: - return -np.log10(-val) - else: - return 0 - -def Safeexp(val): - if val > 0: - return -10 ** -val - elif val < 0: - return 10 ** val - else: - return 0 - -# ? Why does the charge is using another logarithm than the other species - -func_dict_in = { - "H" : np.log1p, - "O" : np.log1p, - "Charge" : Safelog, - "H_0_" : np.log1p, - "O_0_" : np.log1p, - "Ba" : np.log1p, - "Cl" : np.log1p, - "S_2_" : np.log1p, - "S_6_" : np.log1p, - "Sr" : np.log1p, - "Barite" : np.log1p, - "Celestite" : np.log1p, -} - -func_dict_out = { - "H" : np.expm1, - "O" : np.expm1, - "Charge" : Safeexp, - "H_0_" : np.expm1, - "O_0_" : np.expm1, - "Ba" : np.expm1, - "Cl" : np.expm1, - "S_2_" : np.expm1, - "S_6_" : np.expm1, - "Sr" : np.expm1, - "Barite" : np.expm1, - "Celestite" : np.expm1, -} - -# os.chdir('/mnt/beegfs/home/signer/projects/model-training') -data_file = h5py.File("barite_50_4_corner.h5") - -design = data_file["design"] -results = data_file["result"] - -df_design = pd.DataFrame(np.array(design["data"]).transpose(), columns = np.array(design["names"].asstr())) -df_results = pd.DataFrame(np.array(results["data"]).transpose(), columns = np.array(results["names"].asstr())) - -data_file.close() - -species_columns = ['H', 'O', 'Charge', 'Ba', 'Cl', 'S', 'Sr', 'Barite', 'Celestite'] - -preprocess = preprocessing(func_dict_in=func_dict_in, func_dict_out=func_dict_out) -X, y = preprocess.cluster(df_design[species_columns], df_results[species_columns]) -# X, y = preprocess.funcTranform(X, y) - -X_train, X_test, y_train, y_test = preprocess.split(X, y, ratio = 0.2) -X_train, y_train = preprocess.balancer(X_train, y_train, strategy = "over") -preprocess.scale_fit(X_train, y_train, scaling = "individual") -X_train, X_test, y_train, y_test = preprocess.scale_transform(X_train, X_test, y_train, y_test) -X_train, X_val, y_train, y_val = preprocess.split(X_train, y_train, ratio = 0.1) - -column_dict = {"Ba": X.columns.get_loc("Ba"), "Barite":X.columns.get_loc("Barite"), "Sr":X.columns.get_loc("Sr"), "Celestite":X.columns.get_loc("Celestite"), "H":X.columns.get_loc("H"), "H":X.columns.get_loc("H"), "O":X.columns.get_loc("O")} - -def custom_loss(preprocess, column_dict, h1, h2, h3, h4): - # extract the scaling parameters - scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32) - min_X = tf.convert_to_tensor(preprocess.scaler_X.min_, dtype=tf.float32) - scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32) - min_y = tf.convert_to_tensor(preprocess.scaler_y.min_, dtype=tf.float32) - - def loss(results, predicted): - # inverse min/max scaling - predicted_inverse = predicted * scale_X + min_X - results_inverse = results * scale_y + min_y - - # mass balance - dBa = tf.keras.backend.abs( - (predicted_inverse[:, column_dict["Ba"]] + predicted_inverse[:, column_dict["Barite"]]) - - (results_inverse[:, column_dict["Ba"]] + results_inverse[:, column_dict["Barite"]]) - ) - dSr = tf.keras.backend.abs( - (predicted_inverse[:, column_dict["Sr"]] + predicted_inverse[:, column_dict["Celestite"]]) - - (results_inverse[:, column_dict["Sr"]] + results_inverse[:, column_dict["Celestite"]]) - ) - - # H/O ratio has to be 2 - h2o_ratio = tf.keras.backend.abs( - (predicted_inverse[:, column_dict["H"]] / predicted_inverse[:, column_dict["O"]]) - 2 - ) - - # huber loss - huber_loss = tf.keras.losses.Huber()(results, predicted) - - # total loss - total_loss = h1 * huber_loss + h2 * dBa**2 + h3 * dSr**2 #+ h4 * h2o_ratio**2 - - return total_loss - - return loss - -def mass_balance(model, X, preprocess): - - # predict the chemistry - columns = X.iloc[:, X.columns != "Class"].columns - prediction = pd.DataFrame(model.predict(X[columns]), columns=columns) - - # backtransform min/max - X = pd.DataFrame(preprocess.scaler_X.inverse_transform(X.iloc[:, X.columns != "Class"]), columns=columns) - prediction = pd.DataFrame(preprocess.scaler_y.inverse_transform(prediction), columns=columns) - - # calculate mass balance dBa = np.abs((prediction["Ba"] + prediction["Barite"]) - (X["Ba"] + X["Barite"])) - dSr = np.abs((prediction["Sr"] + prediction["Celestite"]) - (X["Sr"] + X["Celestite"])) - - return dBa + dSr - -import optuna - -def create_model(model, preprocess, h1, h2, h3, h4): - - model.compile(optimizer=optimizer_simple, loss=custom_loss(preprocess, column_dict, h1, h2, h3, h4)) - - return model - - -def objective(trial, preprocess, X_train, y_train, X_val, y_val, X_test, y_test): - h1 = trial.suggest_float("h1", 0.1, 10) - h2 = trial.suggest_float("h2", 0.1, 10) - h3 = trial.suggest_float("h3", 0.1, 10) - h4 = trial.suggest_float("h4", 0.1, 10) - - model = create_model(model_simple, preprocess, h1, h2, h3, h4) - - callback = keras.callbacks.EarlyStopping(monitor='loss', patience=3) - history = model.fit(X_train.loc[:, X_train.columns != "Class"], - y_train.loc[:, y_train.columns != "Class"], - batch_size=batch_size, - epochs=50, - validation_data=(X_val.loc[:, X_val.columns != "Class"], y_val.loc[:, y_val.columns != "Class"]), - callbacks=[callback]) - - prediction_loss = model.evaluate(X_test.loc[:, X_test.columns != "Class"], y_test.loc[:, y_test.columns != "Class"]) - mass_balance_results = mass_balance(model, X_test, preprocess) - - mass_balance_ratio = len(mass_balance_results[mass_balance_results < 1e-5]) / len(mass_balance_results) - - return prediction_loss, mass_balance_ratio - -if __name__ == "__main__": - study = optuna.create_study(storage="sqlite:///model_optimization.db", study_name="model_optimization", directions=["minimize", "maximize"]) - study.optimize(lambda trial: objective(trial, preprocess, X_train, y_train, X_val, y_val, X_test, y_test), n_trials=1000) - - print("Number of finished trials: ", len(study.trials)) - - print("Best trial:") - trial = study.best_trial - - print(" Value: ", trial.value) - - print(" Params: ") - for key, value in trial.params.items(): - print(" {}: {}".format(key, value)) \ No newline at end of file diff --git a/preprocessing.py b/preprocessing.py deleted file mode 100644 index 4597334..0000000 --- a/preprocessing.py +++ /dev/null @@ -1,332 +0,0 @@ -import keras -print("Running Keras in version {}".format(keras.__version__)) - -import h5py -import numpy as np -import pandas as pd -import time -import sklearn.model_selection as sk -import matplotlib.pyplot as plt -from sklearn.cluster import KMeans -from imblearn.over_sampling import SMOTE -from imblearn.under_sampling import RandomUnderSampler -from imblearn.over_sampling import RandomOverSampler -from collections import Counter -import os -from sklearn.preprocessing import StandardScaler, MinMaxScaler -from sklearn.base import clone - -# preprocessing pipeline -# - -def Safelog(val): - # get range of vector - if val > 0: - return np.log10(val) - elif val < 0: - return -np.log10(-val) - else: - return 0 - -def Safeexp(val): - if val > 0: - return -10 ** -val - elif val < 0: - return 10 ** val - else: - return 0 - - -class FuncTransform(): - ''' - Class to transform and inverse transform data with given functions. - Transform and inverse transform functions have to be given as dictionaries in the following format: - {'key1': function1, 'key2': function2, ...} - ''' - - def __init__(self, func_transform, func_inverse): - self.func_transform = func_transform - self.func_inverse = func_inverse - - def fit(self, X, y=None): - return self - - def transform(self, X, y=None): - X = X.copy() - for key in X.keys(): - if "Class" not in key: - X[key] = X[key].apply(self.func_transform[key]) - return X - - def fit_transform(self, X, y=None): - self.fit(X) - return self.transform(X, y) - - def inverse_transform(self, X_log): - X_log = X_log.copy() - for key in X_log.keys(): - if "Class" not in key: - X_log[key] = X_log[key].apply(self.func_inverse[key]) - return X_log - - -def clustering(X, n_clusters=2, random_state=42, x_length=50, y_length=50, species='Barite'): - ''' - Function to cluster data with KMeans. - ''' - - class_labels = np.array([]) - grid_length = x_length * y_length - iterations = int(len(X) / grid_length) - - for i in range(0, iterations): - field = np.array(X[species][(i*grid_length):(i*grid_length+grid_length)] - ).reshape(x_length, y_length) - kmeans = KMeans(n_clusters=n_clusters, random_state=random_state).fit( - field.reshape(-1, 1)) - - class_labels = np.append(class_labels.astype(int), kmeans.labels_) - - if("Class" in X.columns): - print("Class column already exists") - else: - class_labels_df = pd.DataFrame(class_labels, columns=['Class']) - X_clustered = pd.concat([X, class_labels_df], axis=1) - - return X_clustered - - -def balancer(design, target, strategy, sample_fraction=0.5): - - number_features = (design.columns != "Class").sum() - if("Class" not in design.columns): - if("Class" in target.columns): - classes = target['Class'] - else: - raise Exception("No class column found") - else: - classes = design['Class'] - counter = classes.value_counts() - print("Amount class 0 before:", counter[0] / (counter[0] + counter[1]) ) - print("Amount class 1 before:", counter[1] / (counter[0] + counter[1]) ) - df = pd.concat([design.loc[:,design.columns != "Class"], target.loc[:, target.columns != "Class"], classes], axis=1) - - if strategy == 'smote': - print("Using SMOTE strategy") - smote = SMOTE(sampling_strategy=sample_fraction) - df_resampled, classes_resampled = smote.fit_resample(df.loc[:, df.columns != "Class"], df.loc[:, df.columns == "Class"]) - - elif strategy == 'over': - print("Using Oversampling") - over = RandomOverSampler() - df_resampled, classes_resampled = over.fit_resample(df.loc[:, df.columns != "Class"], df.loc[:, df.columns == "Class"]) - - elif strategy == 'under': - print("Using Undersampling") - under = RandomUnderSampler() - df_resampled, classes_resampled = under.fit_resample(df.loc[:, df.columns != "Class"], df.loc[:, df.columns == "Class"]) - - else: - return design, target - - counter = classes_resampled["Class"].value_counts() - print("Amount class 0 after:", counter[0] / (counter[0] + counter[1]) ) - print("Amount class 1 after:", counter[1] / (counter[0] + counter[1]) ) - - design_resampled = pd.concat([df_resampled.iloc[:,0:number_features], classes_resampled], axis=1) - target_resampled = pd.concat([df_resampled.iloc[:,number_features:], classes_resampled], axis=1) - - return design_resampled, target_resampled - - -def plot_simulation(X, timestep, component='Barite', x_length=50, y_length=50): - grid_length = x_length * y_length - max_iter = int(len(X) / grid_length) - if(timestep >= max_iter): - raise Exception("timestep is not in the simulation range") - - plt.imshow(np.array(X[component][(timestep*grid_length):(timestep*grid_length+grid_length)]).reshape(x_length,y_length), interpolation='bicubic', origin='lower') - - if("Class" in X.columns): - plt.contour(np.array(X['Class'][(timestep*grid_length):(timestep*grid_length+grid_length)]).reshape(x_length,y_length), levels=[0.1], colors='red', origin='lower') - - plt.show() - - -def preprocessing_training(df_design, df_targets, func_dict_in, func_dict_out, sampling, scaling, test_size): - - df_design = clustering(df_design) - df_targets = pd.concat([df_targets, df_design['Class']], axis=1) - - df_design_log = FuncTransform(func_dict_in, func_dict_out).fit_transform(df_design) - df_results_log = FuncTransform(func_dict_in, func_dict_out).fit_transform(df_targets) - - X_train, X_test, y_train, y_test = sk.train_test_split(df_design_log, df_results_log, test_size = test_size, random_state=42) - - X_train, y_train = balancer(X_train, y_train, sampling) - - scaler_X = MinMaxScaler() - scaler_y = MinMaxScaler() - - if scaling == 'individual': - scaler_X.fit(X_train.iloc[:, X_train.columns != "Class"]) - scaler_y.fit(y_train.iloc[:, y_train.columns != "Class"]) - - elif scaling == 'global': - scaler_X.fit(pd.concat([X_train.iloc[:, X_train.columns != "Class"], y_train.iloc[:, y_train.columns != "Class"]], axis=0)) - scaler_y = scaler_X - - X_train = pd.concat([scaler_X.transform(X_train.loc[:, X_train.columns != "Class"]), X_train.loc[:, "Class"]], axis=1) - X_test = pd.concat([scaler_X.transform(X_test.loc[:, X_test.columns != "Class"]), X_test.loc[:, "Class"]], axis=1) - - y_train = pd.concat([scaler_y.transform(y_train.loc[:, y_train.columns != "Class"]), y_train.loc[:, "Class"]], axis=1) - y_test = pd.concat([scaler_y.transform(y_test.loc[:, y_test.columns != "Class"]), y_test.loc[:, "Class"]], axis=1) - - X_train, X_val, y_train, y_val = sk.train_test_split(X_train, y_train, test_size = 0.1) - - return X_train, X_val, X_test, y_train, y_val, y_test, scaler_X, scaler_y - - - -class preprocessing: - - def __init__(self, func_dict_in, func_dict_out, random_state=42): - self.random_state = random_state - self.scaler_X = None - self.scaler_y = None - self.func_dict_in = func_dict_in - self.func_dict_out = func_dict_out - self.state = {"cluster": False, "log": False, "balance": False, "scale": False} - - def funcTranform(self, X, y): - for key in X.keys(): - if "Class" not in key: - X[key] = X[key].apply(self.func_dict_in[key]) - y[key] = y[key].apply(self.func_dict_in[key]) - self.state["log"] = True - - return X, y - - def funcInverse(self, X, y): - - for key in X.keys(): - if "Class" not in key: - X[key] = X[key].apply(self.func_dict_out[key]) - y[key] = y[key].apply(self.func_dict_out[key]) - self.state["log"] = False - return X, y - - def cluster(self, X, y, species='Barite', n_clusters=2, x_length=50, y_length=50): - - class_labels = np.array([]) - grid_length = x_length * y_length - iterations = int(len(X) / grid_length) - - for i in range(0, iterations): - field = np.array(X[species][(i*grid_length):(i*grid_length+grid_length)] - ).reshape(x_length, y_length) - kmeans = KMeans(n_clusters=n_clusters, random_state=self.random_state).fit(field.reshape(-1, 1)) - class_labels = np.append(class_labels.astype(int), kmeans.labels_) - - if ("Class" in X.columns and "Class" in y.columns): - print("Class column already exists") - else: - class_labels_df = pd.DataFrame(class_labels, columns=['Class']) - X = pd.concat([X, class_labels_df], axis=1) - y = pd.concat([y, class_labels_df], axis=1) - self.state["cluster"] = True - - return X, y - - - def balancer(self, X, y, strategy, sample_fraction=0.5): - - number_features = (X.columns != "Class").sum() - if("Class" not in X.columns): - if("Class" in y.columns): - classes = y['Class'] - else: - raise Exception("No class column found") - else: - classes = X['Class'] - counter = classes.value_counts() - print("Amount class 0 before:", counter[0] / (counter[0] + counter[1]) ) - print("Amount class 1 before:", counter[1] / (counter[0] + counter[1]) ) - df = pd.concat([X.loc[:,X.columns != "Class"], y.loc[:, y.columns != "Class"], classes], axis=1) - - if strategy == 'smote': - print("Using SMOTE strategy") - smote = SMOTE(sampling_strategy=sample_fraction) - df_resampled, classes_resampled = smote.fit_resample(df.loc[:, df.columns != "Class"], df.loc[:, df. columns == "Class"]) - - elif strategy == 'over': - print("Using Oversampling") - over = RandomOverSampler() - df_resampled, classes_resampled = over.fit_resample(df.loc[:, df.columns != "Class"], df.loc[:, df. columns == "Class"]) - - elif strategy == 'under': - print("Using Undersampling") - under = RandomUnderSampler() - df_resampled, classes_resampled = under.fit_resample(df.loc[:, df.columns != "Class"], df.loc[:, df. columns == "Class"]) - - else: - return X, y - - counter = classes_resampled["Class"].value_counts() - print("Amount class 0 after:", counter[0] / (counter[0] + counter[1]) ) - print("Amount class 1 after:", counter[1] / (counter[0] + counter[1]) ) - - design_resampled = pd.concat([df_resampled.iloc[:,0:number_features], classes_resampled], axis=1) - target_resampled = pd.concat([df_resampled.iloc[:,number_features:], classes_resampled], axis=1) - - self.state['balance'] = True - return design_resampled, target_resampled - - - def scale_fit(self, X, y, scaling): - - if scaling == 'individual': - self.scaler_X = MinMaxScaler() - self.scaler_y = MinMaxScaler() - self.scaler_X.fit(X.iloc[:, X.columns != "Class"]) - self.scaler_y.fit(y.iloc[:, y.columns != "Class"]) - - elif scaling == 'global': - self.scaler_X = MinMaxScaler() - self.scaler_X.fit(pd.concat([X.iloc[:, X.columns != "Class"], y.iloc[:, y.columns != "Class"]], axis=0)) - self.scaler_y = self.scaler_X - - self.state['scale'] = True - - def scale_transform(self, X_train, X_test, y_train, y_test): - X_train = pd.concat([self.scaler_X.transform(X_train.loc[:, X_train.columns != "Class"]), X_train.loc[:, "Class"]], axis=1) - - X_test = pd.concat([self.scaler_X.transform(X_test.loc[:, X_test.columns != "Class"]), X_test.loc[:, "Class"]], axis=1) - - y_train = pd.concat([self.scaler_y.transform(y_train.loc[:, y_train.columns != "Class"]), y_train.loc[:, "Class"]], axis=1) - - y_test = pd.concat([self.scaler_y.transform(y_test.loc[:, y_test.columns != "Class"]), y_test.loc[:, "Class"]], axis=1) - - return X_train, X_test, y_train, y_test - - def scale_inverse(self, X): - - if("Class" in X.columns): - X = pd.concat([self.scaler_X.inverse_transform(X.loc[:, X.columns != "Class"]), X.loc[:, "Class"]], axis=1) - else: - X = self.scaler_X.inverse_transform(X) - - return X - - def split(self, X, y, ratio=0.8): - X_train, y_train, X_test, y_test = sk.train_test_split(X, y, test_size = ratio, random_state=self.random_state) - - return X_train, y_train, X_test, y_test - - - - - - - - \ No newline at end of file diff --git a/POET_Training.ipynb b/src/POET_Training.ipynb similarity index 52% rename from POET_Training.ipynb rename to src/POET_Training.ipynb index 56fe545..d1e696a 100644 --- a/POET_Training.ipynb +++ b/src/POET_Training.ipynb @@ -30,17 +30,26 @@ "execution_count": 1, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-02-18 13:55:19.773381: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-02-18 13:55:19.792623: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "Running Keras in version 3.8.0\n" + "Running Keras in version 3.6.0\n" ] } ], "source": [ "import keras\n", - "from keras.layers import Dense, Dropout, Input,BatchNormalization\n", + "from keras.layers import Dense, Dropout, Input,BatchNormalization, LeakyReLU\n", "import tensorflow as tf\n", "import h5py\n", "import numpy as np\n", @@ -121,6 +130,14 @@ "execution_count": 4, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/signer/bin/miniconda3/envs/training/lib/python3.11/site-packages/keras/src/layers/activations/leaky_relu.py:41: UserWarning: Argument `alpha` is deprecated. Use `negative_slope` instead.\n", + " warnings.warn(\n" + ] + }, { "data": { "text/html": [ @@ -142,8 +159,12 @@ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", "│ dense (Dense) │ (None, 128) │ 1,152 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu (LeakyReLU) │ (None, 128) │ 0 │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_1 (Dense) │ (None, 128) │ 16,512 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu_1 (LeakyReLU) │ (None, 128) │ 0 │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_2 (Dense) │ (None, 8) │ 1,032 │\n", "└─────────────────────────────────┴────────────────────────┴───────────────┘\n", "\n" @@ -154,8 +175,12 @@ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m1,152\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu (\u001b[38;5;33mLeakyReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m16,512\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu_1 (\u001b[38;5;33mLeakyReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_2 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m) │ \u001b[38;5;34m1,032\u001b[0m │\n", "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" ] @@ -207,11 +232,13 @@ "# small model\n", "model_simple = keras.Sequential(\n", " [\n", - " keras.Input(shape = (8,), dtype = \"float32\"),\n", - " keras.layers.Dense(units = 128, activation = \"linear\", dtype = \"float32\"),\n", + " keras.Input(shape=(8,), dtype=\"float32\"),\n", + " keras.layers.Dense(units=128, dtype=\"float32\"),\n", + " LeakyReLU(alpha=0.01),\n", " # Dropout(0.2),\n", - " keras.layers.Dense(units = 128, activation = \"elu\", dtype = \"float32\"),\n", - " keras.layers.Dense(units = 8, dtype = \"float32\")\n", + " keras.layers.Dense(units=128, dtype=\"float32\"),\n", + " LeakyReLU(alpha=0.01),\n", + " keras.layers.Dense(units=8, dtype=\"float32\")\n", " ]\n", ")\n", "\n", @@ -245,10 +272,16 @@ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", "│ dense_3 (Dense) │ (None, 512) │ 4,608 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu_2 (LeakyReLU) │ (None, 512) │ 0 │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_4 (Dense) │ (None, 1024) │ 525,312 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu_3 (LeakyReLU) │ (None, 1024) │ 0 │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_5 (Dense) │ (None, 512) │ 524,800 │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu_4 (LeakyReLU) │ (None, 512) │ 0 │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_6 (Dense) │ (None, 8) │ 4,104 │\n", "└─────────────────────────────────┴────────────────────────┴───────────────┘\n", "\n" @@ -259,10 +292,16 @@ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", "│ dense_3 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m4,608\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu_2 (\u001b[38;5;33mLeakyReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_4 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1024\u001b[0m) │ \u001b[38;5;34m525,312\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu_3 (\u001b[38;5;33mLeakyReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1024\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_5 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m524,800\u001b[0m │\n", "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ leaky_re_lu_4 (\u001b[38;5;33mLeakyReLU\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", "│ dense_6 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m) │ \u001b[38;5;34m4,104\u001b[0m │\n", "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" ] @@ -312,13 +351,18 @@ ], "source": [ "# large model\n", - "model_large = keras.Sequential(\n", - " [keras.layers.Input(shape=(8,), dtype=dtype),\n", - " keras.layers.Dense(512, activation='relu', dtype=dtype),\n", - " keras.layers.Dense(1024, activation='relu', dtype=dtype),\n", - " keras.layers.Dense(512, activation='relu', dtype=dtype),\n", - " keras.layers.Dense(8, dtype=dtype)\n", - " ])\n", + "model_large = keras.Sequential(\n", + " [\n", + " keras.layers.Input(shape=(8,), dtype=dtype),\n", + " keras.layers.Dense(512, dtype=dtype),\n", + " LeakyReLU(alpha=0.01),\n", + " keras.layers.Dense(1024, dtype=dtype),\n", + " LeakyReLU(alpha=0.01),\n", + " keras.layers.Dense(512, dtype=dtype),\n", + " LeakyReLU(alpha=0.01),\n", + " keras.layers.Dense(8, dtype=dtype)\n", + " ]\n", + ")\n", "\n", "model_large.compile(optimizer=optimizer_large, loss = loss)\n", "model_large.summary()\n" @@ -326,7 +370,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -424,10 +468,14 @@ "# (see https://doi.org/10.1007/s11242-022-01779-3 model for the complex chemistry)\n", "model_paper = keras.Sequential(\n", " [keras.layers.Input(shape=(8,), dtype=dtype),\n", - " keras.layers.Dense(128, activation='relu', dtype=dtype),\n", - " keras.layers.Dense(256, activation='relu', dtype=dtype),\n", - " keras.layers.Dense(512, activation='relu', dtype=dtype),\n", - " keras.layers.Dense(256, activation='relu', dtype=dtype),\n", + " keras.layers.Dense(128, dtype=dtype),\n", + " LeakyReLU(alpha=0.01),\n", + " keras.layers.Dense(256, dtype=dtype),\n", + " LeakyReLU(alpha=0.01),\n", + " keras.layers.Dense(512, dtype=dtype),\n", + " LeakyReLU(alpha=0.01),\n", + " keras.layers.Dense(256, dtype=dtype),\n", + " LeakyReLU(alpha=0.01),\n", " keras.layers.Dense(8, dtype=dtype)\n", " ])\n", "\n", @@ -520,7 +568,7 @@ "source": [ "# os.chdir('/mnt/beegfs/home/signer/projects/model-training')\n", "# data_file = h5py.File(\"barite_50_ai_20k.h5\")\n", - "data_file = h5py.File(\"barite_50_4_corner.h5\")\n", + "data_file = h5py.File(\"../datasets/barite_50_4_corner.h5\")\n", "\n", "design = data_file[\"design\"]\n", "results = data_file[\"result\"]\n", @@ -558,14 +606,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/hannessigner/miniconda3/envs/ai/lib/python3.11/site-packages/sklearn/base.py:1473: ConvergenceWarning: Number of distinct clusters (1) found smaller than n_clusters (2). Possibly due to duplicate points in X.\n", + "/home/signer/bin/miniconda3/envs/training/lib/python3.11/site-packages/sklearn/base.py:1473: ConvergenceWarning: Number of distinct clusters (1) found smaller than n_clusters (2). Possibly due to duplicate points in X.\n", " return fit_method(estimator, *args, **kwargs)\n" ] }, @@ -588,29 +636,29 @@ "\n", "X_train, X_test, y_train, y_test = preprocess.split(X, y, ratio = 0.2)\n", "X_train, y_train = preprocess.balancer(X_train, y_train, strategy = \"over\")\n", - "preprocess.scale_fit(X_train, y_train, scaling = \"global\")\n", + "preprocess.scale_fit(X_train, y_train, scaling = \"global\", type=\"MinMax\")\n", "X_train, X_test, y_train, y_test = preprocess.scale_transform(X_train, X_test, y_train, y_test)\n", "X_train, X_val, y_train, y_val = preprocess.split(X_train, y_train, ratio = 0.1)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 26, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -634,7 +682,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -643,22 +691,35 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "def custom_loss(preprocess, column_dict, h1, h2, h3, h4):\n", + "def custom_loss(preprocess, column_dict, h1, h2, h3, h4, scaler_type=\"minmax\"):\n", " # extract the scaling parameters\n", - " scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32)\n", - " min_X = tf.convert_to_tensor(preprocess.scaler_X.min_, dtype=tf.float32)\n", - " scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32)\n", - " min_y = tf.convert_to_tensor(preprocess.scaler_y.min_, dtype=tf.float32)\n", + " \n", + " if scaler_type == \"minmax\":\n", + " scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32)\n", + " min_X = tf.convert_to_tensor(preprocess.scaler_X.min_, dtype=tf.float32)\n", + " scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32)\n", + " min_y = tf.convert_to_tensor(preprocess.scaler_y.min_, dtype=tf.float32)\n", + " \n", + " elif scaler_type == \"standard\":\n", + " scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32)\n", + " mean_X = tf.convert_to_tensor(preprocess.scaler_X.mean_, dtype=tf.float32)\n", + " scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32)\n", + " mean_y = tf.convert_to_tensor(preprocess.scaler_y.mean_, dtype=tf.float32)\n", "\n", " def loss(results, predicted):\n", " \n", " # inverse min/max scaling\n", - " predicted_inverse = predicted #* scale_y + min_y\n", - " results_inverse = results #* scale_X + min_X\n", + " if scaler_type == \"minmax\":\n", + " predicted_inverse = predicted * scale_y + min_y\n", + " results_inverse = results * scale_X + min_X\n", + " \n", + " elif scaler_type == \"standard\":\n", + " predicted_inverse = predicted * scale_y + mean_y\n", + " results_inverse = results * scale_X + mean_X\n", "\n", " # mass balance\n", " dBa = tf.keras.backend.abs(\n", @@ -679,21 +740,69 @@ " huber_loss = tf.keras.losses.Huber()(results, predicted)\n", " \n", " # total loss\n", - " total_loss = h1 * huber_loss + h2 * dBa + h3 * dSr #+ h4 * h2o_ratio**2\n", + " total_loss = h1 * huber_loss + h2 * dBa + h3 * dSr #+ h4 * h2o_ratio\n", " # total_loss = huber_loss\n", " return total_loss\n", "\n", - " return loss" + " return loss\n", + "\n", + "\n", + "def custom_metric(preprocess, column_dict, scaler_type=\"minmax\"):\n", + " \n", + " if scaler_type == \"minmax\":\n", + " scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32)\n", + " min_X = tf.convert_to_tensor(preprocess.scaler_X.min_, dtype=tf.float32)\n", + " scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32)\n", + " min_y = tf.convert_to_tensor(preprocess.scaler_y.min_, dtype=tf.float32)\n", + "\n", + " elif scaler_type == \"standard\":\n", + " scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32)\n", + " mean_X = tf.convert_to_tensor(preprocess.scaler_X.mean_, dtype=tf.float32)\n", + " scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32)\n", + " mean_y = tf.convert_to_tensor(preprocess.scaler_y.mean_, dtype=tf.float32)\n", + " \n", + " \n", + " def mass_balance(results, predicted):\n", + " # inverse min/max scaling\n", + " if scaler_type == \"minmax\":\n", + " predicted_inverse = predicted * scale_y + min_y\n", + " results_inverse = results * scale_X + min_X\n", + " \n", + " elif scaler_type == \"standard\":\n", + " predicted_inverse = predicted * scale_y + mean_y\n", + " results_inverse = results * scale_X + mean_X\n", + "\n", + " # mass balance\n", + " dBa = tf.keras.backend.abs(\n", + " (predicted_inverse[:, column_dict[\"Ba\"]] + predicted_inverse[:, column_dict[\"Barite\"]]) -\n", + " (results_inverse[:, column_dict[\"Ba\"]] + results_inverse[:, column_dict[\"Barite\"]])\n", + " )\n", + " dSr = tf.keras.backend.abs(\n", + " (predicted_inverse[:, column_dict[\"Sr\"]] + predicted_inverse[:, column_dict[\"Celestite\"]]) -\n", + " (results_inverse[:, column_dict[\"Sr\"]] + results_inverse[:, column_dict[\"Celestite\"]])\n", + " )\n", + " \n", + " return tf.reduce_mean(dBa + dSr)\n", + " \n", + " return mass_balance\n", + "\n", + "\n", + "def huber_metric(delta=1.0):\n", + " def huber(results, predicted):\n", + " return tf.keras.losses.huber(results, predicted, delta=delta)\n", + " \n", + " return huber" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "model_simple.compile(optimizer=optimizer_simple, loss=custom_loss(preprocess, column_dict, 1, 1, 1, 1))#custom_loss(preprocess, column_dict))\n", - "model_large.compile(optimizer=optimizer_large, loss=custom_loss(preprocess, column_dict, 1, 1, 1, 1))#custom_loss(preprocess, column_dict))" + "model_simple.compile(optimizer=optimizer_simple, loss=custom_loss(preprocess, column_dict, 1, 1, 1, 1, \"minmax\"))\n", + "\n", + "model_large.compile(optimizer=optimizer_large, loss=custom_loss(preprocess, column_dict, 1, 1, 1, 1, \"minmax\"), metrics=[huber_metric(1.0), custom_metric(preprocess, column_dict, scaler_type=\"minmax\")])" ] }, { @@ -705,7 +814,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -723,12 +832,14 @@ "\n", " end = time.time()\n", "\n", - " print(\"Training took {} seconds\".format(end - start))" + " print(\"Training took {} seconds\".format(end - start))\n", + " \n", + " return history" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -736,211 +847,207 @@ "output_type": "stream", "text": [ "Epoch 1/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 0.0073 - val_loss: 0.0025\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 13ms/step - huber: 0.0280 - loss: 0.5766 - mass_balance: 0.5486 - val_huber: 0.0052 - val_loss: 0.3554 - val_mass_balance: 0.3502\n", "Epoch 2/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 11ms/step - loss: 0.0043 - val_loss: 0.0035\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 14ms/step - huber: 0.0038 - loss: 0.1885 - mass_balance: 0.1847 - val_huber: 0.0013 - val_loss: 0.1407 - val_mass_balance: 0.1394\n", "Epoch 3/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 0.0035 - val_loss: 0.0029\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m28s\u001b[0m 17ms/step - huber: 9.8317e-04 - loss: 0.1252 - mass_balance: 0.1242 - val_huber: 6.6276e-04 - val_loss: 0.1825 - val_mass_balance: 0.1818\n", "Epoch 4/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 0.0031 - val_loss: 0.0030\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m47s\u001b[0m 28ms/step - huber: 5.5962e-04 - loss: 0.1058 - mass_balance: 0.1052 - val_huber: 4.2667e-04 - val_loss: 0.1063 - val_mass_balance: 0.1058\n", "Epoch 5/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 0.0031 - val_loss: 0.0017\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 20ms/step - huber: 4.1409e-04 - loss: 0.0987 - mass_balance: 0.0983 - val_huber: 2.7614e-04 - val_loss: 0.0551 - val_mass_balance: 0.0548\n", "Epoch 6/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 0.0025 - val_loss: 0.0019\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 13ms/step - huber: 2.9547e-04 - loss: 0.0840 - mass_balance: 0.0837 - val_huber: 2.2160e-04 - val_loss: 0.0798 - val_mass_balance: 0.0796\n", "Epoch 7/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 0.0024 - val_loss: 0.0018\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 13ms/step - huber: 2.2008e-04 - loss: 0.0703 - mass_balance: 0.0701 - val_huber: 1.5488e-04 - val_loss: 0.0621 - val_mass_balance: 0.0620\n", "Epoch 8/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 0.0021 - val_loss: 0.0013\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m26s\u001b[0m 15ms/step - huber: 1.5455e-04 - loss: 0.0563 - mass_balance: 0.0562 - val_huber: 1.4596e-04 - val_loss: 0.0520 - val_mass_balance: 0.0519\n", "Epoch 9/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 10ms/step - loss: 0.0020 - val_loss: 0.0023\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 20ms/step - huber: 1.3447e-04 - loss: 0.0548 - mass_balance: 0.0547 - val_huber: 9.0868e-05 - val_loss: 0.0258 - val_mass_balance: 0.0257\n", "Epoch 10/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 10ms/step - loss: 0.0019 - val_loss: 0.0012\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 17ms/step - huber: 1.0780e-04 - loss: 0.0512 - mass_balance: 0.0511 - val_huber: 1.0800e-04 - val_loss: 0.0882 - val_mass_balance: 0.0880\n", "Epoch 11/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 0.0017 - val_loss: 0.0010\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 13ms/step - huber: 9.2014e-05 - loss: 0.0469 - mass_balance: 0.0468 - val_huber: 6.0724e-05 - val_loss: 0.0343 - val_mass_balance: 0.0343\n", "Epoch 12/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 10ms/step - loss: 0.0016 - val_loss: 0.0011\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 14ms/step - huber: 7.2128e-05 - loss: 0.0386 - mass_balance: 0.0386 - val_huber: 5.6025e-05 - val_loss: 0.0444 - val_mass_balance: 0.0444\n", "Epoch 13/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 0.0014 - val_loss: 0.0024\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 21ms/step - huber: 6.2327e-05 - loss: 0.0383 - mass_balance: 0.0382 - val_huber: 4.8252e-05 - val_loss: 0.0264 - val_mass_balance: 0.0263\n", "Epoch 14/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 10ms/step - loss: 0.0013 - val_loss: 0.0010\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 19ms/step - huber: 5.0254e-05 - loss: 0.0289 - mass_balance: 0.0289 - val_huber: 4.7942e-05 - val_loss: 0.0367 - val_mass_balance: 0.0366\n", "Epoch 15/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 0.0013 - val_loss: 0.0013\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 14ms/step - huber: 4.9434e-05 - loss: 0.0317 - mass_balance: 0.0316 - val_huber: 3.9466e-05 - val_loss: 0.0483 - val_mass_balance: 0.0483\n", "Epoch 16/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 0.0011 - val_loss: 7.8773e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 22ms/step - huber: 4.1831e-05 - loss: 0.0292 - mass_balance: 0.0292 - val_huber: 3.3752e-05 - val_loss: 0.0254 - val_mass_balance: 0.0254\n", "Epoch 17/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 9.8307e-04 - val_loss: 9.4317e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 22ms/step - huber: 3.5998e-05 - loss: 0.0254 - mass_balance: 0.0254 - val_huber: 3.6478e-05 - val_loss: 0.0198 - val_mass_balance: 0.0197\n", "Epoch 18/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 0.0011 - val_loss: 7.2556e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 15ms/step - huber: 3.1113e-05 - loss: 0.0216 - mass_balance: 0.0216 - val_huber: 2.5108e-05 - val_loss: 0.0183 - val_mass_balance: 0.0183\n", "Epoch 19/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 8.6145e-04 - val_loss: 0.0012\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 18ms/step - huber: 2.6720e-05 - loss: 0.0199 - mass_balance: 0.0198 - val_huber: 2.1269e-05 - val_loss: 0.0195 - val_mass_balance: 0.0195\n", "Epoch 20/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 8.7931e-04 - val_loss: 7.9255e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 24ms/step - huber: 2.2666e-05 - loss: 0.0166 - mass_balance: 0.0166 - val_huber: 2.1749e-05 - val_loss: 0.0166 - val_mass_balance: 0.0166\n", "Epoch 21/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 8.1421e-04 - val_loss: 8.6545e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 21ms/step - huber: 1.9886e-05 - loss: 0.0147 - mass_balance: 0.0147 - val_huber: 2.0177e-05 - val_loss: 0.0258 - val_mass_balance: 0.0258\n", "Epoch 22/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 11ms/step - loss: 8.0980e-04 - val_loss: 8.0041e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 14ms/step - huber: 1.7967e-05 - loss: 0.0145 - mass_balance: 0.0145 - val_huber: 1.5768e-05 - val_loss: 0.0225 - val_mass_balance: 0.0225\n", "Epoch 23/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 7.0201e-04 - val_loss: 7.4177e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 18ms/step - huber: 1.6283e-05 - loss: 0.0129 - mass_balance: 0.0129 - val_huber: 1.3621e-05 - val_loss: 0.0099 - val_mass_balance: 0.0099\n", "Epoch 24/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 11ms/step - loss: 7.1057e-04 - val_loss: 8.0948e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 25ms/step - huber: 1.4158e-05 - loss: 0.0120 - mass_balance: 0.0120 - val_huber: 1.2725e-05 - val_loss: 0.0219 - val_mass_balance: 0.0219\n", "Epoch 25/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 6.5622e-04 - val_loss: 7.4124e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 23ms/step - huber: 1.3349e-05 - loss: 0.0122 - mass_balance: 0.0122 - val_huber: 1.1089e-05 - val_loss: 0.0058 - val_mass_balance: 0.0058\n", "Epoch 26/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 6.3500e-04 - val_loss: 5.9376e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 14ms/step - huber: 1.1305e-05 - loss: 0.0094 - mass_balance: 0.0094 - val_huber: 1.0137e-05 - val_loss: 0.0094 - val_mass_balance: 0.0094\n", "Epoch 27/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 5.9934e-04 - val_loss: 6.4478e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 18ms/step - huber: 1.0401e-05 - loss: 0.0087 - mass_balance: 0.0087 - val_huber: 8.7671e-06 - val_loss: 0.0097 - val_mass_balance: 0.0097\n", "Epoch 28/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 5.8949e-04 - val_loss: 7.3300e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 25ms/step - huber: 9.2662e-06 - loss: 0.0084 - mass_balance: 0.0084 - val_huber: 7.9543e-06 - val_loss: 0.0042 - val_mass_balance: 0.0042\n", "Epoch 29/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 5.7806e-04 - val_loss: 6.7011e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 20ms/step - huber: 8.7411e-06 - loss: 0.0083 - mass_balance: 0.0083 - val_huber: 7.5361e-06 - val_loss: 0.0047 - val_mass_balance: 0.0047\n", "Epoch 30/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 5.6589e-04 - val_loss: 5.5847e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 13ms/step - huber: 8.3025e-06 - loss: 0.0069 - mass_balance: 0.0069 - val_huber: 7.4451e-06 - val_loss: 0.0094 - val_mass_balance: 0.0094\n", "Epoch 31/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 5.3306e-04 - val_loss: 5.4670e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m28s\u001b[0m 17ms/step - huber: 7.6382e-06 - loss: 0.0057 - mass_balance: 0.0057 - val_huber: 6.9163e-06 - val_loss: 0.0050 - val_mass_balance: 0.0050\n", "Epoch 32/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 5.2881e-04 - val_loss: 6.1837e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 23ms/step - huber: 7.3375e-06 - loss: 0.0056 - mass_balance: 0.0056 - val_huber: 6.7540e-06 - val_loss: 0.0046 - val_mass_balance: 0.0046\n", "Epoch 33/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 5.1513e-04 - val_loss: 4.9995e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 20ms/step - huber: 7.0753e-06 - loss: 0.0051 - mass_balance: 0.0051 - val_huber: 6.2671e-06 - val_loss: 0.0072 - val_mass_balance: 0.0072\n", "Epoch 34/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 5.0624e-04 - val_loss: 5.4048e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 14ms/step - huber: 6.7945e-06 - loss: 0.0048 - mass_balance: 0.0048 - val_huber: 6.2241e-06 - val_loss: 0.0072 - val_mass_balance: 0.0072\n", "Epoch 35/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 5.0185e-04 - val_loss: 5.5650e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 19ms/step - huber: 6.5585e-06 - loss: 0.0045 - mass_balance: 0.0045 - val_huber: 6.1400e-06 - val_loss: 0.0036 - val_mass_balance: 0.0036\n", "Epoch 36/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 4.9359e-04 - val_loss: 4.8311e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 22ms/step - huber: 6.4420e-06 - loss: 0.0038 - mass_balance: 0.0038 - val_huber: 5.8129e-06 - val_loss: 0.0028 - val_mass_balance: 0.0027\n", "Epoch 37/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 4.7914e-04 - val_loss: 4.7833e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 18ms/step - huber: 6.0778e-06 - loss: 0.0034 - mass_balance: 0.0034 - val_huber: 5.7370e-06 - val_loss: 0.0020 - val_mass_balance: 0.0020\n", "Epoch 38/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 4.7096e-04 - val_loss: 4.5319e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 13ms/step - huber: 6.0100e-06 - loss: 0.0030 - mass_balance: 0.0030 - val_huber: 5.4983e-06 - val_loss: 0.0026 - val_mass_balance: 0.0026\n", "Epoch 39/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 11ms/step - loss: 4.6474e-04 - val_loss: 5.0544e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 19ms/step - huber: 5.8758e-06 - loss: 0.0032 - mass_balance: 0.0032 - val_huber: 5.4214e-06 - val_loss: 0.0016 - val_mass_balance: 0.0016\n", "Epoch 40/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 4.6506e-04 - val_loss: 4.3838e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 22ms/step - huber: 5.6621e-06 - loss: 0.0026 - mass_balance: 0.0026 - val_huber: 5.2990e-06 - val_loss: 0.0034 - val_mass_balance: 0.0034\n", "Epoch 41/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 4.5502e-04 - val_loss: 4.6796e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 20ms/step - huber: 5.5953e-06 - loss: 0.0026 - mass_balance: 0.0026 - val_huber: 5.1084e-06 - val_loss: 0.0017 - val_mass_balance: 0.0016\n", "Epoch 42/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 4.5163e-04 - val_loss: 4.4342e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 14ms/step - huber: 5.4874e-06 - loss: 0.0027 - mass_balance: 0.0027 - val_huber: 5.0405e-06 - val_loss: 0.0015 - val_mass_balance: 0.0015\n", "Epoch 43/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 11ms/step - loss: 4.4623e-04 - val_loss: 4.4409e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 18ms/step - huber: 5.3323e-06 - loss: 0.0022 - mass_balance: 0.0022 - val_huber: 4.9327e-06 - val_loss: 0.0017 - val_mass_balance: 0.0017\n", "Epoch 44/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 10ms/step - loss: 4.4326e-04 - val_loss: 4.6563e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 22ms/step - huber: 5.1880e-06 - loss: 0.0022 - mass_balance: 0.0022 - val_huber: 4.8816e-06 - val_loss: 0.0023 - val_mass_balance: 0.0023\n", "Epoch 45/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m16s\u001b[0m 10ms/step - loss: 4.3963e-04 - val_loss: 4.4313e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 20ms/step - huber: 5.2677e-06 - loss: 0.0019 - mass_balance: 0.0019 - val_huber: 4.8684e-06 - val_loss: 0.0030 - val_mass_balance: 0.0030\n", "Epoch 46/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 10ms/step - loss: 4.3694e-04 - val_loss: 4.4041e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 13ms/step - huber: 5.0820e-06 - loss: 0.0016 - mass_balance: 0.0016 - val_huber: 4.7764e-06 - val_loss: 0.0017 - val_mass_balance: 0.0017\n", "Epoch 47/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 4.3481e-04 - val_loss: 4.6735e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 19ms/step - huber: 5.1720e-06 - loss: 0.0017 - mass_balance: 0.0017 - val_huber: 4.6949e-06 - val_loss: 0.0014 - val_mass_balance: 0.0014\n", "Epoch 48/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 12ms/step - loss: 4.3270e-04 - val_loss: 4.5155e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 22ms/step - huber: 4.9894e-06 - loss: 0.0015 - mass_balance: 0.0015 - val_huber: 4.6528e-06 - val_loss: 0.0013 - val_mass_balance: 0.0013\n", "Epoch 49/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 12ms/step - loss: 4.2641e-04 - val_loss: 4.2664e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 18ms/step - huber: 5.0818e-06 - loss: 0.0014 - mass_balance: 0.0014 - val_huber: 4.6386e-06 - val_loss: 0.0013 - val_mass_balance: 0.0013\n", "Epoch 50/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 4.2606e-04 - val_loss: 4.1384e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 13ms/step - huber: 4.9151e-06 - loss: 0.0014 - mass_balance: 0.0014 - val_huber: 4.5971e-06 - val_loss: 0.0017 - val_mass_balance: 0.0017\n", "Epoch 51/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m980s\u001b[0m 581ms/step - loss: 4.2314e-04 - val_loss: 4.3865e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 22ms/step - huber: 5.1078e-06 - loss: 0.0013 - mass_balance: 0.0013 - val_huber: 4.5822e-06 - val_loss: 0.0012 - val_mass_balance: 0.0012\n", "Epoch 52/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 4.2277e-04 - val_loss: 4.4696e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 22ms/step - huber: 4.8951e-06 - loss: 0.0012 - mass_balance: 0.0012 - val_huber: 4.5595e-06 - val_loss: 0.0012 - val_mass_balance: 0.0012\n", "Epoch 53/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 4.2034e-04 - val_loss: 4.1750e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 19ms/step - huber: 4.7999e-06 - loss: 0.0012 - mass_balance: 0.0011 - val_huber: 4.5535e-06 - val_loss: 0.0011 - val_mass_balance: 0.0011\n", "Epoch 54/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 39ms/step - loss: 4.1834e-04 - val_loss: 4.2273e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 14ms/step - huber: 5.0074e-06 - loss: 0.0010 - mass_balance: 0.0010 - val_huber: 4.5312e-06 - val_loss: 0.0011 - val_mass_balance: 0.0011\n", "Epoch 55/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 11ms/step - loss: 4.1589e-04 - val_loss: 4.1261e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 21ms/step - huber: 4.7403e-06 - loss: 0.0011 - mass_balance: 0.0010 - val_huber: 4.5230e-06 - val_loss: 0.0011 - val_mass_balance: 0.0011\n", "Epoch 56/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 13ms/step - loss: 4.1487e-04 - val_loss: 4.4959e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 22ms/step - huber: 4.8505e-06 - loss: 0.0010 - mass_balance: 0.0010 - val_huber: 4.4992e-06 - val_loss: 9.9706e-04 - val_mass_balance: 9.9211e-04\n", "Epoch 57/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 13ms/step - loss: 4.1586e-04 - val_loss: 4.1003e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m28s\u001b[0m 16ms/step - huber: 4.7829e-06 - loss: 0.0010 - mass_balance: 0.0010 - val_huber: 4.4840e-06 - val_loss: 0.0011 - val_mass_balance: 0.0011\n", "Epoch 58/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m157s\u001b[0m 93ms/step - loss: 4.1412e-04 - val_loss: 4.1569e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 13ms/step - huber: 4.6865e-06 - loss: 9.4714e-04 - mass_balance: 9.4245e-04 - val_huber: 4.4743e-06 - val_loss: 0.0010 - val_mass_balance: 0.0010\n", "Epoch 59/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 12ms/step - loss: 4.1268e-04 - val_loss: 4.0756e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 21ms/step - huber: 4.7369e-06 - loss: 9.1854e-04 - mass_balance: 9.1381e-04 - val_huber: 4.4658e-06 - val_loss: 9.0883e-04 - val_mass_balance: 9.0412e-04\n", "Epoch 60/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 12ms/step - loss: 4.1062e-04 - val_loss: 4.1501e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 21ms/step - huber: 4.7842e-06 - loss: 8.9714e-04 - mass_balance: 8.9235e-04 - val_huber: 4.4619e-06 - val_loss: 0.0011 - val_mass_balance: 0.0010\n", "Epoch 61/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 14ms/step - loss: 4.0971e-04 - val_loss: 4.1436e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 19ms/step - huber: 4.7509e-06 - loss: 9.0488e-04 - mass_balance: 9.0013e-04 - val_huber: 4.4496e-06 - val_loss: 8.7976e-04 - val_mass_balance: 8.7495e-04\n", "Epoch 62/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 15ms/step - loss: 4.0963e-04 - val_loss: 4.0847e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 14ms/step - huber: 4.7354e-06 - loss: 8.7100e-04 - mass_balance: 8.6626e-04 - val_huber: 4.4387e-06 - val_loss: 8.0406e-04 - val_mass_balance: 7.9931e-04\n", "Epoch 63/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 17ms/step - loss: 4.0908e-04 - val_loss: 4.1114e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 22ms/step - huber: 4.7464e-06 - loss: 8.3838e-04 - mass_balance: 8.3364e-04 - val_huber: 4.4327e-06 - val_loss: 7.9101e-04 - val_mass_balance: 7.8626e-04\n", "Epoch 64/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 19ms/step - loss: 4.0847e-04 - val_loss: 4.0660e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 23ms/step - huber: 4.6876e-06 - loss: 8.1951e-04 - mass_balance: 8.1482e-04 - val_huber: 4.4294e-06 - val_loss: 8.9929e-04 - val_mass_balance: 8.9460e-04\n", "Epoch 65/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 21ms/step - loss: 4.0808e-04 - val_loss: 4.0996e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 18ms/step - huber: 4.6590e-06 - loss: 8.0697e-04 - mass_balance: 8.0231e-04 - val_huber: 4.4291e-06 - val_loss: 8.6386e-04 - val_mass_balance: 8.5926e-04\n", "Epoch 66/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 22ms/step - loss: 4.0698e-04 - val_loss: 4.0384e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 14ms/step - huber: 4.7361e-06 - loss: 8.0089e-04 - mass_balance: 7.9615e-04 - val_huber: 4.4201e-06 - val_loss: 9.0955e-04 - val_mass_balance: 9.0501e-04\n", "Epoch 67/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 23ms/step - loss: 4.0676e-04 - val_loss: 4.0728e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 23ms/step - huber: 4.6704e-06 - loss: 7.8888e-04 - mass_balance: 7.8421e-04 - val_huber: 4.4193e-06 - val_loss: 8.9738e-04 - val_mass_balance: 8.9274e-04\n", "Epoch 68/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 23ms/step - loss: 4.0539e-04 - val_loss: 4.0679e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 23ms/step - huber: 4.6470e-06 - loss: 7.7605e-04 - mass_balance: 7.7141e-04 - val_huber: 4.4142e-06 - val_loss: 8.5801e-04 - val_mass_balance: 8.5335e-04\n", "Epoch 69/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 23ms/step - loss: 4.0455e-04 - val_loss: 4.0366e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m28s\u001b[0m 16ms/step - huber: 4.7550e-06 - loss: 7.7262e-04 - mass_balance: 7.6787e-04 - val_huber: 4.4084e-06 - val_loss: 7.9255e-04 - val_mass_balance: 7.8781e-04\n", "Epoch 70/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 23ms/step - loss: 4.0342e-04 - val_loss: 4.0677e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m29s\u001b[0m 17ms/step - huber: 4.7623e-06 - loss: 7.5767e-04 - mass_balance: 7.5291e-04 - val_huber: 4.4077e-06 - val_loss: 7.4866e-04 - val_mass_balance: 7.4407e-04\n", "Epoch 71/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 23ms/step - loss: 4.0365e-04 - val_loss: 4.0675e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 23ms/step - huber: 4.7104e-06 - loss: 7.4709e-04 - mass_balance: 7.4238e-04 - val_huber: 4.4048e-06 - val_loss: 7.6893e-04 - val_mass_balance: 7.6434e-04\n", "Epoch 72/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m48s\u001b[0m 28ms/step - loss: 4.0370e-04 - val_loss: 4.0298e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 22ms/step - huber: 4.7597e-06 - loss: 7.4175e-04 - mass_balance: 7.3699e-04 - val_huber: 4.4023e-06 - val_loss: 7.5106e-04 - val_mass_balance: 7.4639e-04\n", "Epoch 73/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 40ms/step - loss: 4.0327e-04 - val_loss: 4.0212e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 13ms/step - huber: 4.6848e-06 - loss: 7.3518e-04 - mass_balance: 7.3050e-04 - val_huber: 4.3981e-06 - val_loss: 8.2756e-04 - val_mass_balance: 8.2306e-04\n", "Epoch 74/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 39ms/step - loss: 4.0230e-04 - val_loss: 4.0181e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 19ms/step - huber: 4.6485e-06 - loss: 7.3155e-04 - mass_balance: 7.2690e-04 - val_huber: 4.3989e-06 - val_loss: 8.4362e-04 - val_mass_balance: 8.3890e-04\n", "Epoch 75/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 39ms/step - loss: 4.0186e-04 - val_loss: 4.0174e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 22ms/step - huber: 4.7278e-06 - loss: 7.2393e-04 - mass_balance: 7.1920e-04 - val_huber: 4.3956e-06 - val_loss: 7.3810e-04 - val_mass_balance: 7.3353e-04\n", "Epoch 76/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 39ms/step - loss: 4.0194e-04 - val_loss: 4.0180e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 21ms/step - huber: 4.7837e-06 - loss: 7.2246e-04 - mass_balance: 7.1768e-04 - val_huber: 4.3947e-06 - val_loss: 7.2104e-04 - val_mass_balance: 7.1644e-04\n", "Epoch 77/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 39ms/step - loss: 4.0250e-04 - val_loss: 4.0450e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m28s\u001b[0m 17ms/step - huber: 4.7795e-06 - loss: 7.1239e-04 - mass_balance: 7.0761e-04 - val_huber: 4.3899e-06 - val_loss: 7.5226e-04 - val_mass_balance: 7.4761e-04\n", "Epoch 78/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m64s\u001b[0m 38ms/step - loss: 4.0166e-04 - val_loss: 4.0060e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 21ms/step - huber: 4.5890e-06 - loss: 7.1344e-04 - mass_balance: 7.0885e-04 - val_huber: 4.3891e-06 - val_loss: 7.4826e-04 - val_mass_balance: 7.4358e-04\n", "Epoch 79/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 39ms/step - loss: 4.0279e-04 - val_loss: 4.0026e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 18ms/step - huber: 4.8303e-06 - loss: 7.1237e-04 - mass_balance: 7.0754e-04 - val_huber: 4.3876e-06 - val_loss: 7.2122e-04 - val_mass_balance: 7.1660e-04\n", "Epoch 80/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m65s\u001b[0m 38ms/step - loss: 4.0156e-04 - val_loss: 4.0022e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 14ms/step - huber: 4.7512e-06 - loss: 7.0720e-04 - mass_balance: 7.0245e-04 - val_huber: 4.3860e-06 - val_loss: 7.8552e-04 - val_mass_balance: 7.8102e-04\n", "Epoch 81/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 39ms/step - loss: 4.0187e-04 - val_loss: 4.0012e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 19ms/step - huber: 4.9366e-06 - loss: 7.0371e-04 - mass_balance: 6.9877e-04 - val_huber: 4.3859e-06 - val_loss: 7.4151e-04 - val_mass_balance: 7.3684e-04\n", "Epoch 82/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m66s\u001b[0m 39ms/step - loss: 4.0070e-04 - val_loss: 4.0000e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 24ms/step - huber: 4.5501e-06 - loss: 6.9870e-04 - mass_balance: 6.9415e-04 - val_huber: 4.3839e-06 - val_loss: 7.2937e-04 - val_mass_balance: 7.2469e-04\n", "Epoch 83/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 42ms/step - loss: 3.9981e-04 - val_loss: 3.9985e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 19ms/step - huber: 4.7512e-06 - loss: 6.9658e-04 - mass_balance: 6.9183e-04 - val_huber: 4.3828e-06 - val_loss: 6.9935e-04 - val_mass_balance: 6.9476e-04\n", "Epoch 84/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m50s\u001b[0m 30ms/step - loss: 4.0303e-04 - val_loss: 4.0034e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 14ms/step - huber: 4.9666e-06 - loss: 6.9299e-04 - mass_balance: 6.8802e-04 - val_huber: 4.3836e-06 - val_loss: 6.9820e-04 - val_mass_balance: 6.9360e-04\n", "Epoch 85/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 3.9996e-04 - val_loss: 3.9949e-04\n", + "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 22ms/step - huber: 4.7241e-06 - loss: 6.8971e-04 - mass_balance: 6.8498e-04 - val_huber: 4.3817e-06 - val_loss: 7.0906e-04 - val_mass_balance: 7.0448e-04\n", "Epoch 86/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 10ms/step - loss: 4.0223e-04 - val_loss: 3.9965e-04\n", - "Epoch 87/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 4.0010e-04 - val_loss: 4.0027e-04\n", - "Epoch 88/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 3.9915e-04 - val_loss: 3.9899e-04\n", - "Epoch 89/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 10ms/step - loss: 4.0031e-04 - val_loss: 3.9913e-04\n", - "Epoch 90/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 4.0037e-04 - val_loss: 3.9903e-04\n", - "Epoch 91/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 10ms/step - loss: 4.0011e-04 - val_loss: 3.9930e-04\n", - "Epoch 92/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 3.9916e-04 - val_loss: 3.9924e-04\n", - "Epoch 93/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 3.9930e-04 - val_loss: 3.9885e-04\n", - "Epoch 94/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 10ms/step - loss: 4.0009e-04 - val_loss: 3.9866e-04\n", - "Epoch 95/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 3.9961e-04 - val_loss: 3.9870e-04\n", - "Epoch 96/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 4.0012e-04 - val_loss: 3.9863e-04\n", - "Epoch 97/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 11ms/step - loss: 4.0073e-04 - val_loss: 3.9872e-04\n", - "Epoch 98/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 4.0112e-04 - val_loss: 3.9862e-04\n", - "Epoch 99/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 10ms/step - loss: 3.9970e-04 - val_loss: 3.9864e-04\n", - "Epoch 100/100\n", - "\u001b[1m1688/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 10ms/step - loss: 4.0060e-04 - val_loss: 3.9856e-04\n", - "Training took 3712.1917679309845 seconds\n" + "\u001b[1m1599/1688\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m2s\u001b[0m 23ms/step - huber: 4.6831e-06 - loss: 6.8842e-04 - mass_balance: 6.8373e-04" ] } ], "source": [ - "model_training(model_large)" + "history = model_training(model_large)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'huber': [0.002203812124207616],\n", + " 'loss': [0.15536518394947052],\n", + " 'metric': [0.1531183123588562],\n", + " 'val_huber': [0.0013130842708051205],\n", + " 'val_loss': [0.13849961757659912],\n", + " 'val_metric': [0.1371718943119049]}" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "history.history" ] }, { @@ -952,7 +1059,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -961,7 +1068,7 @@ " # predict the chemistry\n", " columns = X.iloc[:, X.columns != \"Class\"].columns\n", " prediction = pd.DataFrame(model.predict(X[columns]), columns=columns)\n", - " # backtransform min/max\n", + " # backtransform min/max or standard scaler\n", " X = pd.DataFrame(preprocess.scaler_X.inverse_transform(X.iloc[:, X.columns != \"Class\"]), columns=columns)\n", " prediction = pd.DataFrame(preprocess.scaler_y.inverse_transform(prediction), columns=columns)\n", " \n", @@ -970,31 +1077,451 @@ " print(dBa.min())\n", " dSr = np.abs((prediction[\"Sr\"] + prediction[\"Celestite\"]) - (X[\"Sr\"] + X[\"Celestite\"]))\n", " print(dSr.min())\n", - " return dBa, dSr" + " return dBa, dSr, prediction" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "model_large.save(\"results/model_large_standardization.keras\")" + ] + }, + { + "cell_type": "code", + "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m3938/3938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 664us/step\n", - "1.1719081515317378e-08\n", - "4.366040862180398e-11\n" + "\u001b[1m26993/26993\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m27s\u001b[0m 1ms/step\n" ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
HOBaClSSrBariteCelestite
0111.01246655.5065770.0000260.0561769.027177e-050.0281580.0010071.000519
1111.01264255.506767-0.0000030.0135931.372010e-040.0069340.0010921.000284
2111.01245155.5065650.0000260.0662498.709153e-050.0331920.0010111.000633
3111.01258155.5062180.0341570.1404443.951677e-070.0360231.006732-0.000064
4111.01240555.5078050.0000140.0013133.968081e-040.0010300.0009881.000100
...........................
863768111.01239055.506592-0.0000090.0480709.337875e-050.0241320.0010081.000566
863769111.01256655.506775-0.0000120.0131121.393815e-040.0066990.0009911.000386
863770111.01236055.5064960.0000690.1083427.026148e-050.0542380.1048830.891984
863771111.01252055.5062180.0636230.1677278.158847e-080.0202471.001999-0.000021
863772111.01241355.5062180.0417040.1504932.325937e-070.0334681.0067570.000043
\n", + "

863773 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " H O Ba Cl S Sr \\\n", + "0 111.012466 55.506577 0.000026 0.056176 9.027177e-05 0.028158 \n", + "1 111.012642 55.506767 -0.000003 0.013593 1.372010e-04 0.006934 \n", + "2 111.012451 55.506565 0.000026 0.066249 8.709153e-05 0.033192 \n", + "3 111.012581 55.506218 0.034157 0.140444 3.951677e-07 0.036023 \n", + "4 111.012405 55.507805 0.000014 0.001313 3.968081e-04 0.001030 \n", + "... ... ... ... ... ... ... \n", + "863768 111.012390 55.506592 -0.000009 0.048070 9.337875e-05 0.024132 \n", + "863769 111.012566 55.506775 -0.000012 0.013112 1.393815e-04 0.006699 \n", + "863770 111.012360 55.506496 0.000069 0.108342 7.026148e-05 0.054238 \n", + "863771 111.012520 55.506218 0.063623 0.167727 8.158847e-08 0.020247 \n", + "863772 111.012413 55.506218 0.041704 0.150493 2.325937e-07 0.033468 \n", + "\n", + " Barite Celestite \n", + "0 0.001007 1.000519 \n", + "1 0.001092 1.000284 \n", + "2 0.001011 1.000633 \n", + "3 1.006732 -0.000064 \n", + "4 0.000988 1.000100 \n", + "... ... ... \n", + "863768 0.001008 1.000566 \n", + "863769 0.000991 1.000386 \n", + "863770 0.104883 0.891984 \n", + "863771 1.001999 -0.000021 \n", + "863772 1.006757 0.000043 \n", + "\n", + "[863773 rows x 8 columns]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "dBa, dSr = mass_balance(model_large, X_test, preprocess)" + "pd.DataFrame(preprocess.scaler_X.inverse_transform(model_large.predict(X_train[species_columns])), columns=species_columns)" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
HOBaClSSrBariteCelestite
0111.01243455.5065781.977602e-050.0561609.022655e-050.0281510.0010001.000490
1111.01243455.5067674.662127e-060.0135501.374302e-040.0069080.0010001.000091
2111.01243455.5065652.349696e-050.0662358.705933e-050.0331810.0010011.000613
3111.01243455.5062173.411673e-020.1401641.617992e-070.0359661.0067560.000000
4111.01243455.5078097.424997e-070.0013383.981606e-040.0010670.0010001.000093
...........................
863768111.01243455.5065911.684073e-050.0481209.347094e-050.0241370.0010011.000615
863769111.01243455.5067764.502549e-060.0130761.397029e-040.0066730.0010001.000591
863770111.01243455.5064742.738630e-040.1084226.420915e-050.0540010.1046550.892149
863771111.01243455.5062176.360786e-020.1676731.098785e-070.0202291.0020100.000000
863772111.01243455.5062174.167711e-020.1503241.392182e-070.0334851.0067630.000000
\n", + "

863773 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " H O Ba Cl S Sr \\\n", + "0 111.012434 55.506578 1.977602e-05 0.056160 9.022655e-05 0.028151 \n", + "1 111.012434 55.506767 4.662127e-06 0.013550 1.374302e-04 0.006908 \n", + "2 111.012434 55.506565 2.349696e-05 0.066235 8.705933e-05 0.033181 \n", + "3 111.012434 55.506217 3.411673e-02 0.140164 1.617992e-07 0.035966 \n", + "4 111.012434 55.507809 7.424997e-07 0.001338 3.981606e-04 0.001067 \n", + "... ... ... ... ... ... ... \n", + "863768 111.012434 55.506591 1.684073e-05 0.048120 9.347094e-05 0.024137 \n", + "863769 111.012434 55.506776 4.502549e-06 0.013076 1.397029e-04 0.006673 \n", + "863770 111.012434 55.506474 2.738630e-04 0.108422 6.420915e-05 0.054001 \n", + "863771 111.012434 55.506217 6.360786e-02 0.167673 1.098785e-07 0.020229 \n", + "863772 111.012434 55.506217 4.167711e-02 0.150324 1.392182e-07 0.033485 \n", + "\n", + " Barite Celestite \n", + "0 0.001000 1.000490 \n", + "1 0.001000 1.000091 \n", + "2 0.001001 1.000613 \n", + "3 1.006756 0.000000 \n", + "4 0.001000 1.000093 \n", + "... ... ... \n", + "863768 0.001001 1.000615 \n", + "863769 0.001000 1.000591 \n", + "863770 0.104655 0.892149 \n", + "863771 1.002010 0.000000 \n", + "863772 1.006763 0.000000 \n", + "\n", + "[863773 rows x 8 columns]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(preprocess.scaler_X.inverse_transform(X_train[species_columns]), columns=species_columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m3938/3938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 1ms/step\n", + "6.703051481926625e-11\n", + "1.1166534363837854e-10\n" + ] + } + ], + "source": [ + "dBa, dSr, prediction = mass_balance(model_large, X_test, preprocess)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, "metadata": {}, "outputs": [], "source": [ @@ -1003,16 +1530,16 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 70, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.0004126984126984127" + "0.11562698412698413" ] }, - "execution_count": 43, + "execution_count": 70, "metadata": {}, "output_type": "execute_result" } @@ -1023,68 +1550,27 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "1571 9.777670e-06\n", - "4804 6.682305e-06\n", - "9522 5.360124e-06\n", - "19062 7.792255e-06\n", - "20931 7.635390e-06\n", - "25699 8.067375e-06\n", - "26621 9.558936e-06\n", - "27291 3.264182e-06\n", - "28758 9.788952e-06\n", - "30798 9.144786e-06\n", - "30868 8.206085e-06\n", - "33577 5.763282e-06\n", - "35603 7.277309e-06\n", - "36166 8.139519e-07\n", - "37063 7.179245e-06\n", - "43690 9.914585e-06\n", - "43815 9.545191e-06\n", - "44262 6.470130e-06\n", - "44943 6.567906e-06\n", - "52627 8.729186e-06\n", - "55763 4.385958e-06\n", - "57566 3.628730e-06\n", - "60090 9.793098e-06\n", - "62479 4.789578e-06\n", - "63477 7.146393e-06\n", - "64471 7.182930e-06\n", - "66959 6.616205e-06\n", - "67640 8.551544e-06\n", - "68503 9.501419e-06\n", - "70704 9.920509e-06\n", - "75976 5.456992e-06\n", - "76018 5.254534e-06\n", - "78582 4.474446e-06\n", - "81150 7.195583e-06\n", - "87159 5.605938e-06\n", - "89481 5.571020e-06\n", - "91118 8.934794e-06\n", - "91502 9.652786e-06\n", - "92207 9.917967e-06\n", - "94182 9.915878e-06\n", - "94506 4.791335e-06\n", - "95973 6.741278e-06\n", - "99816 7.449719e-06\n", - "101503 5.096865e-06\n", - "105575 3.955416e-06\n", - "107682 5.253287e-06\n", - "107940 5.935249e-06\n", - "115812 9.169740e-06\n", - "116353 5.333948e-06\n", - "120035 9.495618e-06\n", - "120275 5.560308e-06\n", - "124877 8.157624e-06\n", - "dtype: float64" + "5 0.000006\n", + "26 0.000004\n", + "35 0.000004\n", + "62 0.000004\n", + "69 0.000003\n", + " ... \n", + "863757 0.000002\n", + "863760 0.000004\n", + "863763 0.000002\n", + "863766 0.000006\n", + "863771 0.000006\n", + "Length: 111168, dtype: float64" ] }, - "execution_count": 41, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" } @@ -1605,19 +2091,19 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step \n" + "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step \n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1627,7 +2113,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1641,14 +2127,11 @@ "\n", "species = \"Barite\"\n", "iterations = 250\n", - "cell_offset = 9\n", + "cell_offset = 120\n", "y_design = []\n", "y_results = []\n", "y_differences = []\n", "\n", - "# if(preprocess.state['log'] == True):\n", - "# df_design_transformed, df_results_transformed = preprocess.funcTranform(df_design[species_columns], df_results[species_columns])\n", - "\n", "df_design_transformed_scaled = preprocess.scaler_X.transform(df_design[species_columns])\n", "df_results_transformed_scaled = preprocess.scaler_y.transform(df_results[species_columns])\n", "\n", @@ -1966,93 +2449,86 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 62, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m3938/3938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 827us/step - loss: 70.7642\n" + "\u001b[1m3938/3938\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 953us/step - loss: 1.6434e-04\n" ] }, { "data": { "text/plain": [ - "70.69287872314453" + "0.00016705328016541898" ] }, - "execution_count": 33, + "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# test on all test data\n", - "model_simple.evaluate(X_test.loc[:, X_test.columns != \"Class\"], y_test.loc[:, y_test.columns != \"Class\"])" + "model_large.evaluate(X_test.loc[:, X_test.columns != \"Class\"], y_test.loc[:, y_test.columns != \"Class\"])" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 63, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m3747/3747\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 733us/step - loss: 67.2305\n" + "\u001b[1m3747/3747\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 979us/step - loss: 1.6752e-04\n" ] }, { "data": { "text/plain": [ - "67.27115631103516" + "0.00017050358292181045" ] }, - "execution_count": 34, + "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# test on non-reactive data\n", - "model_simple.evaluate(X_test[X_test['Class'] == 0].iloc[:,X_test.columns != \"Class\"], y_test[X_test['Class'] == 0].iloc[:, y_test.columns != \"Class\"])" + "model_large.evaluate(X_test[X_test['Class'] == 0].iloc[:,X_test.columns != \"Class\"], y_test[X_test['Class'] == 0].iloc[:, y_test.columns != \"Class\"])" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 64, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1m 1/192\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m2s\u001b[0m 12ms/step - loss: 148.6424" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m192/192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 749us/step - loss: 139.3093\n" + "\u001b[1m192/192\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 1ms/step - loss: 1.0253e-04\n" ] }, { "data": { "text/plain": [ - "137.7884521484375" + "9.94073852780275e-05" ] }, - "execution_count": 36, + "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# test on reactive data\n", - "model_simple.evaluate(X_test[X_test['Class'] == 1].iloc[:,:-1], y_test[X_test['Class'] == 1].iloc[:, :-1])" + "model_large.evaluate(X_test[X_test['Class'] == 1].iloc[:,:-1], y_test[X_test['Class'] == 1].iloc[:, :-1])" ] }, { @@ -2075,7 +2551,7 @@ ], "metadata": { "kernelspec": { - "display_name": "ai", + "display_name": "training", "language": "python", "name": "python3" }, diff --git a/convert_data.jl b/src/convert_data.jl similarity index 100% rename from convert_data.jl rename to src/convert_data.jl diff --git a/src/optuna_runs.py b/src/optuna_runs.py new file mode 100644 index 0000000..8b09182 --- /dev/null +++ b/src/optuna_runs.py @@ -0,0 +1,106 @@ +import keras +from keras.layers import Dense, Dropout, Input,BatchNormalization +import tensorflow as tf +import h5py +import numpy as np +import pandas as pd +import time +import sklearn.model_selection as sk +import matplotlib.pyplot as plt +from sklearn.cluster import KMeans +from sklearn.pipeline import Pipeline, make_pipeline +from sklearn.preprocessing import StandardScaler, MinMaxScaler +from imblearn.over_sampling import SMOTE +from imblearn.under_sampling import RandomUnderSampler +from imblearn.over_sampling import RandomOverSampler +from collections import Counter +import os +from preprocessing import * +from sklearn import set_config +from importlib import reload +set_config(transform_output = "pandas") +import optuna +import pickle + +data_file = h5py.File("../datasets/barite_50_4_corner.h5") + +def objective(trial, preprocess, X, y, species_columns): + + model_type = trial.suggest_categorical("model", ["simple", "large", "paper"]) + scaler_type = trial.suggest_categorical("scaler", ["standard", "minmax"]) + sampling_type = trial.suggest_categorical("sampling", ["over", "off"]) + + preprocess = preprocessing() + X, y = preprocess.cluster(df_design[species_columns], df_results[species_columns]) + X_train, X_test, y_train, y_test = preprocess.split(X, y, ratio = 0.2) + X_train, y_train = preprocess.balancer(X_train, y_train, strategy = sampling_type) + preprocess.scale_fit(X_train, y_train, scaling = "global", type=scaler_type) + X_train, X_test, y_train, y_test = preprocess.scale_transform(X_train, X_test, y_train, y_test) + X_train, X_val, y_train, y_val = preprocess.split(X_train, y_train, ratio = 0.1) + + column_dict = {"Ba": X.columns.get_loc("Ba"), "Barite":X.columns.get_loc("Barite"), "Sr":X.columns.get_loc("Sr"), "Celestite":X.columns.get_loc("Celestite"), "H":X.columns.get_loc("H"), "H":X.columns.get_loc("H"), "O":X.columns.get_loc("O")} + + h1 = trial.suggest_float("h1", 0.1, 1) + h2 = trial.suggest_float("h2", 0.1, 1) + h3 = trial.suggest_float("h3", 0.1, 1) + + + model = model_definition(model_type) + + lr_schedule = keras.optimizers.schedules.ExponentialDecay( + initial_learning_rate=0.001, + decay_steps=2000, + decay_rate=0.9, + staircase=True + ) + optimizer = keras.optimizers.Adam(learning_rate=lr_schedule) + + model.compile(optimizer=optimizer, loss=custom_loss(preprocess, column_dict, h1, h2, h3, scaler_type), metrics=[huber_metric(1.0), mass_balance_metric(preprocess, column_dict, scaler_type="minmax")]) + + callback = keras.callbacks.EarlyStopping(monitor='loss', patience=3) + history = model.fit(X_train.loc[:, X_train.columns != "Class"], + y_train.loc[:, y_train.columns != "Class"], + batch_size=512, + epochs=100, + validation_data=(X_val.loc[:, X_val.columns != "Class"], y_val.loc[:, y_val.columns != "Class"]), + callbacks=[callback]) + + prediction_loss = model.evaluate(X_test.loc[:, X_test.columns != "Class"], y_test.loc[:, y_test.columns != "Class"]) + mass_balance_results = mass_balance_evaluation(model, X_test, preprocess) + + mass_balance_ratio = len(mass_balance_results[mass_balance_results < 1e-5]) / len(mass_balance_results) + + model_save_path_trial = os.path.join("../results/models/", f"model_trial_{trial.number}.h5") + history_save_path_trial = os.path.join("../results/history/", f"history_trial_{trial.number}.pkl") + + model.save(model_save_path_trial) + with open(history_save_path_trial, 'wb') as f: + pickle.dump(history.history, f) + + return prediction_loss, mass_balance_ratio + +if __name__ == "__main__": + + design = data_file["design"] + results = data_file["result"] + + df_design = pd.DataFrame(np.array(design["data"]).transpose(), columns = np.array(design["names"].asstr())) + df_results = pd.DataFrame(np.array(results["data"]).transpose(), columns = np.array(results["names"].asstr())) + + data_file.close() + + species_columns = ['H', 'O', 'Charge', 'Ba', 'Cl', 'S', 'Sr', 'Barite', 'Celestite'] + + study = optuna.create_study(storage="sqlite:///model_optimization.db", study_name="model_optimization", directions=["minimize", "maximize"]) + study.optimize(lambda trial: objective(trial, df_design, df_results, species_columns), n_trials=1000) + + print("Number of finished trials: ", len(study.trials)) + + print("Best trial:") + trial = study.best_trial + + print(" Value: ", trial.value) + + print(" Params: ") + for key, value in trial.params.items(): + print(" {}: {}".format(key, value)) \ No newline at end of file diff --git a/src/preprocessing.py b/src/preprocessing.py new file mode 100644 index 0000000..9348436 --- /dev/null +++ b/src/preprocessing.py @@ -0,0 +1,357 @@ +import keras +from keras.layers import Dense, Dropout, Input,BatchNormalization, LeakyReLU +import tensorflow as tf +import h5py +import numpy as np +import pandas as pd +import time +import sklearn.model_selection as sk +import matplotlib.pyplot as plt +from sklearn.cluster import KMeans +from sklearn.pipeline import Pipeline, make_pipeline +from sklearn.preprocessing import StandardScaler, MinMaxScaler +from imblearn.over_sampling import SMOTE +from imblearn.under_sampling import RandomUnderSampler +from imblearn.over_sampling import RandomOverSampler +from collections import Counter +import os +from preprocessing import * +from sklearn import set_config +from importlib import reload +set_config(transform_output = "pandas") + +# preprocessing pipeline +# + +def Safelog(val): + # get range of vector + if val > 0: + return np.log10(val) + elif val < 0: + return -np.log10(-val) + else: + return 0 + +def Safeexp(val): + if val > 0: + return -10 ** -val + elif val < 0: + return 10 ** val + else: + return 0 + + +def model_definition(architecture): + dtype = "float32" + + if architecture == "small": + model = keras.Sequential( + [ + keras.Input(shape=(8,), dtype="float32"), + keras.layers.Dense(units=128, dtype="float32"), + LeakyReLU(alpha=0.01), + # Dropout(0.2), + keras.layers.Dense(units=128, dtype="float32"), + LeakyReLU(alpha=0.01), + keras.layers.Dense(units=8, dtype="float32") + ] + ) + + + elif architecture == "large": + model = keras.Sequential( + [ + keras.layers.Input(shape=(8,), dtype=dtype), + keras.layers.Dense(512, dtype=dtype), + LeakyReLU(alpha=0.01), + keras.layers.Dense(1024, dtype=dtype), + LeakyReLU(alpha=0.01), + keras.layers.Dense(512, dtype=dtype), + LeakyReLU(alpha=0.01), + keras.layers.Dense(8, dtype=dtype) + ] + ) + + elif architecture == "paper": + model = keras.Sequential( + [keras.layers.Input(shape=(8,), dtype=dtype), + keras.layers.Dense(128, dtype=dtype), + LeakyReLU(alpha=0.01), + keras.layers.Dense(256, dtype=dtype), + LeakyReLU(alpha=0.01), + keras.layers.Dense(512, dtype=dtype), + LeakyReLU(alpha=0.01), + keras.layers.Dense(256, dtype=dtype), + LeakyReLU(alpha=0.01), + keras.layers.Dense(8, dtype=dtype) + ]) + + return model + + +def custom_loss(preprocess, column_dict, h1, h2, h3, scaler_type="minmax"): + # extract the scaling parameters + + if scaler_type == "minmax": + scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32) + min_X = tf.convert_to_tensor(preprocess.scaler_X.min_, dtype=tf.float32) + scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32) + min_y = tf.convert_to_tensor(preprocess.scaler_y.min_, dtype=tf.float32) + + elif scaler_type == "standard": + scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32) + mean_X = tf.convert_to_tensor(preprocess.scaler_X.mean_, dtype=tf.float32) + scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32) + mean_y = tf.convert_to_tensor(preprocess.scaler_y.mean_, dtype=tf.float32) + + def loss(results, predicted): + + # inverse min/max scaling + if scaler_type == "minmax": + predicted_inverse = predicted * scale_y + min_y + results_inverse = results * scale_X + min_X + + elif scaler_type == "standard": + predicted_inverse = predicted * scale_y + mean_y + results_inverse = results * scale_X + mean_X + + # mass balance + dBa = tf.keras.backend.abs( + (predicted_inverse[:, column_dict["Ba"]] + predicted_inverse[:, column_dict["Barite"]]) - + (results_inverse[:, column_dict["Ba"]] + results_inverse[:, column_dict["Barite"]]) + ) + dSr = tf.keras.backend.abs( + (predicted_inverse[:, column_dict["Sr"]] + predicted_inverse[:, column_dict["Celestite"]]) - + (results_inverse[:, column_dict["Sr"]] + results_inverse[:, column_dict["Celestite"]]) + ) + + # H/O ratio has to be 2 + # h2o_ratio = tf.keras.backend.abs( + # (predicted_inverse[:, column_dict["H"]] / predicted_inverse[:, column_dict["O"]]) - 2 + # ) + + # huber loss + huber_loss = tf.keras.losses.Huber()(results, predicted) + + # total loss + total_loss = h1 * huber_loss + h2 * dBa + h3 * dSr #+ h4 * h2o_ratio + # total_loss = huber_loss + return total_loss + + return loss + +def mass_balance_evaluation(model, X, preprocess): + + # predict the chemistry + columns = X.iloc[:, X.columns != "Class"].columns + prediction = pd.DataFrame(model.predict(X[columns]), columns=columns) + + # backtransform min/max or standard scaler + X = pd.DataFrame(preprocess.scaler_X.inverse_transform(X.iloc[:, X.columns != "Class"]), columns=columns) + prediction = pd.DataFrame(preprocess.scaler_y.inverse_transform(prediction), columns=columns) + + # calculate mass balance + dBa = np.abs((prediction["Ba"] + prediction["Barite"]) - (X["Ba"] + X["Barite"])) + print(dBa.min()) + dSr = np.abs((prediction["Sr"] + prediction["Celestite"]) - (X["Sr"] + X["Celestite"])) + print(dSr.min()) + return dBa, dSr, prediction + + +def mass_balance_metric(preprocess, column_dict, scaler_type="minmax"): + + if scaler_type == "minmax": + scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32) + min_X = tf.convert_to_tensor(preprocess.scaler_X.min_, dtype=tf.float32) + scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32) + min_y = tf.convert_to_tensor(preprocess.scaler_y.min_, dtype=tf.float32) + + elif scaler_type == "standard": + scale_X = tf.convert_to_tensor(preprocess.scaler_X.scale_, dtype=tf.float32) + mean_X = tf.convert_to_tensor(preprocess.scaler_X.mean_, dtype=tf.float32) + scale_y = tf.convert_to_tensor(preprocess.scaler_y.scale_, dtype=tf.float32) + mean_y = tf.convert_to_tensor(preprocess.scaler_y.mean_, dtype=tf.float32) + + + def mass_balance(results, predicted): + # inverse min/max scaling + if scaler_type == "minmax": + predicted_inverse = predicted * scale_y + min_y + results_inverse = results * scale_X + min_X + + elif scaler_type == "standard": + predicted_inverse = predicted * scale_y + mean_y + results_inverse = results * scale_X + mean_X + + # mass balance + dBa = tf.keras.backend.abs( + (predicted_inverse[:, column_dict["Ba"]] + predicted_inverse[:, column_dict["Barite"]]) - + (results_inverse[:, column_dict["Ba"]] + results_inverse[:, column_dict["Barite"]]) + ) + dSr = tf.keras.backend.abs( + (predicted_inverse[:, column_dict["Sr"]] + predicted_inverse[:, column_dict["Celestite"]]) - + (results_inverse[:, column_dict["Sr"]] + results_inverse[:, column_dict["Celestite"]]) + ) + + return tf.reduce_mean(dBa + dSr) + + return mass_balance + + +def huber_metric(delta=1.0): + def huber(results, predicted): + return tf.keras.losses.huber(results, predicted, delta=delta) + + return huber + + +class preprocessing: + + def __init__(self, func_dict_in=None, func_dict_out=None, random_state=42): + self.random_state = random_state + self.scaler_X = None + self.scaler_y = None + self.func_dict_in = None + self.func_dict_in = func_dict_in if func_dict_in is not None else None + self.func_dict_out = func_dict_out if func_dict_out is not None else None + self.state = {"cluster": False, "log": False, "balance": False, "scale": False} + + def funcTranform(self, X, y): + for key in X.keys(): + if "Class" not in key: + X[key] = X[key].apply(self.func_dict_in[key]) + y[key] = y[key].apply(self.func_dict_in[key]) + self.state["log"] = True + + return X, y + + def funcInverse(self, X, y): + + for key in X.keys(): + if "Class" not in key: + X[key] = X[key].apply(self.func_dict_out[key]) + y[key] = y[key].apply(self.func_dict_out[key]) + self.state["log"] = False + return X, y + + def cluster(self, X, y, species='Barite', n_clusters=2, x_length=50, y_length=50): + + class_labels = np.array([]) + grid_length = x_length * y_length + iterations = int(len(X) / grid_length) + + for i in range(0, iterations): + field = np.array(X[species][(i*grid_length):(i*grid_length+grid_length)] + ).reshape(x_length, y_length) + kmeans = KMeans(n_clusters=n_clusters, random_state=self.random_state).fit(field.reshape(-1, 1)) + class_labels = np.append(class_labels.astype(int), kmeans.labels_) + + if ("Class" in X.columns and "Class" in y.columns): + print("Class column already exists") + else: + class_labels_df = pd.DataFrame(class_labels, columns=['Class']) + X = pd.concat([X, class_labels_df], axis=1) + y = pd.concat([y, class_labels_df], axis=1) + self.state["cluster"] = True + + return X, y + + + def balancer(self, X, y, strategy, sample_fraction=0.5): + + number_features = (X.columns != "Class").sum() + if("Class" not in X.columns): + if("Class" in y.columns): + classes = y['Class'] + else: + raise Exception("No class column found") + else: + classes = X['Class'] + counter = classes.value_counts() + print("Amount class 0 before:", counter[0] / (counter[0] + counter[1]) ) + print("Amount class 1 before:", counter[1] / (counter[0] + counter[1]) ) + df = pd.concat([X.loc[:,X.columns != "Class"], y.loc[:, y.columns != "Class"], classes], axis=1) + + if strategy == 'smote': + print("Using SMOTE strategy") + smote = SMOTE(sampling_strategy=sample_fraction) + df_resampled, classes_resampled = smote.fit_resample(df.loc[:, df.columns != "Class"], df.loc[:, df. columns == "Class"]) + + elif strategy == 'over': + print("Using Oversampling") + over = RandomOverSampler() + df_resampled, classes_resampled = over.fit_resample(df.loc[:, df.columns != "Class"], df.loc[:, df. columns == "Class"]) + + elif strategy == 'under': + print("Using Undersampling") + under = RandomUnderSampler() + df_resampled, classes_resampled = under.fit_resample(df.loc[:, df.columns != "Class"], df.loc[:, df. columns == "Class"]) + + else: + return X, y + + counter = classes_resampled["Class"].value_counts() + print("Amount class 0 after:", counter[0] / (counter[0] + counter[1]) ) + print("Amount class 1 after:", counter[1] / (counter[0] + counter[1]) ) + + design_resampled = pd.concat([df_resampled.iloc[:,0:number_features], classes_resampled], axis=1) + target_resampled = pd.concat([df_resampled.iloc[:,number_features:], classes_resampled], axis=1) + + self.state['balance'] = True + return design_resampled, target_resampled + + + def scale_fit(self, X, y, scaling, type='Standard'): + + if type == 'minmax': + self.scaler_X = MinMaxScaler() + self.scaler_y = MinMaxScaler() + elif type == 'standard': + self.scaler_X = StandardScaler() + self.scaler_y = StandardScaler() + + else: + raise Exception("No valid scaler type found") + + if scaling == 'individual': + self.scaler_X.fit(X.iloc[:, X.columns != "Class"]) + self.scaler_y.fit(y.iloc[:, y.columns != "Class"]) + + elif scaling == 'global': + self.scaler_X.fit(pd.concat([X.iloc[:, X.columns != "Class"], y.iloc[:, y.columns != "Class"]], axis=0)) + self.scaler_y = self.scaler_X + + self.state['scale'] = True + + def scale_transform(self, X_train, X_test, y_train, y_test): + X_train = pd.concat([self.scaler_X.transform(X_train.loc[:, X_train.columns != "Class"]), X_train.loc[:, "Class"]], axis=1) + + X_test = pd.concat([self.scaler_X.transform(X_test.loc[:, X_test.columns != "Class"]), X_test.loc[:, "Class"]], axis=1) + + y_train = pd.concat([self.scaler_y.transform(y_train.loc[:, y_train.columns != "Class"]), y_train.loc[:, "Class"]], axis=1) + + y_test = pd.concat([self.scaler_y.transform(y_test.loc[:, y_test.columns != "Class"]), y_test.loc[:, "Class"]], axis=1) + + return X_train, X_test, y_train, y_test + + def scale_inverse(self, X): + + if("Class" in X.columns): + X = pd.concat([self.scaler_X.inverse_transform(X.loc[:, X.columns != "Class"]), X.loc[:, "Class"]], axis=1) + else: + X = self.scaler_X.inverse_transform(X) + + return X + + def split(self, X, y, ratio=0.8): + X_train, y_train, X_test, y_test = sk.train_test_split(X, y, test_size = ratio, random_state=self.random_state) + + return X_train, y_train, X_test, y_test + + + + + + + + \ No newline at end of file