from Packages import *
st.set_page_config(page_title="NIRS Utils", page_icon=":goat:", layout="wide")
from Modules import *
from Class_Mod.DATA_HANDLING import *
add_header()
add_sidebar(pages_folder)
@st.cache_data
def delete():
repertoire_a_vider = Path('Report/figures')
if os.path.exists(repertoire_a_vider):
for fichier in os.listdir(repertoire_a_vider):
chemin_fichier = repertoire_a_vider / fichier
if os.path.isfile(chemin_fichier) or os.path.islink(chemin_fichier):
os.unlink(chemin_fichier)
elif os.path.isdir(chemin_fichier):
os.rmdir(chemin_fichier)
delete()
local_css(css_file / "style_model.css")
# Initialize the variable in session state if it doesn't exist for st.cache_data
if 'counter' not in st.session_state:
st.session_state.counter = 0
if 'files_deletion' not in st.session_state:
st.session_state.files_deletion = 1
def delete_dir():
if st.session_state.files_deletion == 1:
st.session_state.files_deletion -= 1
elif st.session_state.files_deletion == 0:
st.session_state.files_deletion += 1
def increment():
st.session_state.counter += 1
# #################################### Methods ##############################################
@st.cache_data
def csv_loader(x,y):
file_name = str(xcal_csv.name) +' and '+ str(ycal_csv.name)
xfile = pd.read_csv(xcal_csv, decimal='.', sep=sepx, index_col=col, header=0)
yfile = pd.read_csv(ycal_csv, decimal='.', sep=sepy, index_col=col)
return xfile, yfile, file_name
@st.cache_data
def dx_loader(change):
with NamedTemporaryFile(delete=False, suffix=".dx") as tmp:
tmp.write(data_file.read())
tmp_path = tmp.name
chem_data, spectra, meta_data, meta_data_st = read_dx(file = tmp_path)
os.unlink(tmp_path)
return chem_data, spectra, meta_data, meta_data_st
@st.cache_data
def visualize(change):
if np.array(spectra.columns).dtype.kind in ['i','f']:
colnames = spectra.columns
else:
colnames = np.arange(spectra.shape[1])
# Split data into training and test sets using the kennard_stone method and correlation metric, 25% of data is used for testing
train_index, test_index = train_test_split_idx(spectra, y = y, method="kennard_stone", metric="correlation", test_size=0.25, random_state=42)
# Assign data to training and test sets
X_train, y_train = pd.DataFrame(spectra.iloc[train_index,:]), y.iloc[train_index]
X_test, y_test = pd.DataFrame(spectra.iloc[test_index,:]), y.iloc[test_index]
#### insight on loaded data
# M0, M000 = st.columns([1, .4])
fig1, ax1 = plt.subplots( figsize = (12,3))
spectra.T.plot(legend=False, ax = ax1, linestyle = '--')
ax1.set_ylabel('Signal intensity')
ax1.margins(0)
plt.tight_layout()
# M0.pyplot(fig1) ######## Loaded graph
# fig1.savefig("./Report/figures/spectra_plot.png")
fig2, ax2 = plt.subplots(figsize = (12,3))
sns.histplot(y, color="deeppink", kde = True,label="y",ax = ax2, fill=True)
sns.histplot(y_train, color="blue", kde = True,label="y (train)",ax = ax2, fill=True)
sns.histplot(y_test, color="green", kde = True,label="y (test)",ax = ax2, fill=True)
ax2.set_xlabel('y')
plt.legend()
plt.tight_layout()
# M0.pyplot(fig2)
# fig2.savefig("./Report/figures/Histogram.png")
# M000.write('Loaded data summary')
# M000.write(pd.DataFrame([desc_stats(y_train),desc_stats(y_test),desc_stats(y)], index =['train', 'test', 'total'] ).round(2))
stats=pd.DataFrame([desc_stats(y_train),desc_stats(y_test),desc_stats(y)], index =['train', 'test', 'total'] ).round(2)
return X_train, X_test,y_train, y_test, colnames, train_index, test_index, stats, fig1, fig2
@st.cache_data
def pls_(change):
Reg = Plsr(train = [X_train, y_train], test = [X_test, y_test], n_iter=200)
reg_model = Reg.model_
rega = Reg.selected_features_
return Reg, reg_model, rega
@st.cache_data
def tpeipls_(change, n_intervall, n_iter):
Reg = TpeIpls(train = [X_train, y_train], test=[X_test, y_test], n_intervall = n_intervall, n_iter=n_iter)
time.sleep(1)
reg_model = Reg.model_
intervalls = Reg.selected_features_.T
intervalls_with_cols = Reg.selected_features_.T
for i in range(intervalls.shape[0]):
for j in range(intervalls.shape[1]):
intervalls_with_cols.iloc[i,j] = spectra.columns[intervalls.iloc[i,j]]
rega = Reg.selected_features_
return Reg, reg_model, intervalls, intervalls_with_cols, rega
# ####################################### page preamble #######################################
st.title("Calibration Model Development") # page title
st.markdown("Create a predictive model, then use it for predicting your target variable (chemical data) from NIRS spectra")
M0, M00 = st.columns([1, .4])
M0.image("./images/model_creation.png", use_column_width=True) # graphical abstract
####################################### I- Data preparation
files_format = ['.csv', '.dx'] # Supported files format
file = M00.radio('Select files format:', options = files_format,horizontal=True) # Select a file format
spectra = pd.DataFrame() # preallocate the spectral data block
y = pd.DataFrame() # preallocate the target(s) data block
match file:
## load .csv file
case '.csv':
# Load X-block data
xcal_csv = M00.file_uploader("Select NIRS Data", type="csv", help=" :mushroom: select a csv matrix with samples as rows and lambdas as columns")
if xcal_csv:
sepx = M00.radio("Select separator (X file) - _detected_: " + str(find_delimiter('data/'+xcal_csv.name)),
options=[";", ","], index=[";", ","].index(str(find_delimiter('data/'+xcal_csv.name))), key=0,horizontal=True)
hdrx = M00.radio("samples name (X file)? - _detected_: " + str(find_col_index('data/'+xcal_csv.name)),
options=["no", "yes"], index=["no", "yes"].index(str(find_col_index('data/'+xcal_csv.name))), key=1,horizontal=True)
match hdrx:
case "yes":
col = 0
case "no":
col = False
else:
M00.warning('Insert your spectral data file here!')
# Load Y-block data
ycal_csv = M00.file_uploader("Select corresponding Chemical Data", type="csv", help=" :mushroom: select a csv matrix with samples as rows and chemical values as a column")
if ycal_csv:
sepy = M00.radio("Select separator (Y file) - _detected_: " + str(find_delimiter('data/'+ycal_csv.name)),
options=[";", ","], index=[";", ","].index(str(find_delimiter('data/'+ycal_csv.name))), key=2,horizontal=True)
hdry = M00.radio("samples name (Y file)? - _detected_: " + str(find_col_index('data/'+ycal_csv.name)),
options=["no", "yes"], index=["no", "yes"].index(str(find_col_index('data/'+ycal_csv.name))), key=3,horizontal=True)
match hdry:
case "yes":
col = 0
case "no":
col = False
else:
M00.warning('Insert your target data file here!')
if xcal_csv and ycal_csv:
xfile, yfile, file_name = csv_loader(x = hash_data(xcal_csv.name+str(xcal_csv.size)), y =hash_data(ycal_csv.name+str(ycal_csv.size)))
if yfile.shape[1]>0 and xfile.shape[1]>0 :
spectra, meta_data = col_cat(xfile)
chem_data, idx = col_cat(yfile)
if chem_data.shape[1]>1:
yname = M00.selectbox('Select target', options=chem_data.columns)
y = chem_data.loc[:,yname]
else:
y = chem_data.iloc[:,0]
spectra = pd.DataFrame(spectra).astype(float)
# if not meta_data.empty :
# st.write(meta_data)
if spectra.shape[0] != y.shape[0]:
M00.warning('X and Y have different sample size')
y = pd.DataFrame
spectra = pd.DataFrame
else:
M00.error('Error: The data has not been loaded successfully, please consider tuning the decimal and separator !')
## Load .dx file
case '.dx':
data_file = M00.file_uploader("Select Data", type=".dx", help=" :mushroom: select a dx file")
if not data_file:
M00.warning('Load your file here!')
else :
file_name = str(data_file.name)
chem_data, spectra, meta_data, meta_data_st = dx_loader(change = hash_data(str(data_file.size)))
if not spectra.empty:
M00.success("The data have been loaded successfully", icon="✅")
if chem_data.shape[1]>0:
yname = M00.selectbox('Select target', options=chem_data.columns)
measured = chem_data.loc[:,yname] > 0
y = chem_data.loc[:,yname].loc[measured]
spectra = spectra.loc[measured]
else:
M00.warning('Warning: your file includes no target variables to model !', icon="⚠️")
# visualize and split the data
st.header("I - Data visualization", divider='blue')
if not spectra.empty and not y.empty:
X_train, X_test,y_train, y_test, colnames, train_index, test_index, stats, fig1, fig2= visualize(hash_data(y+np.median(spectra)))
M0, M000 = st.columns([1, .4])
M0.pyplot(fig1) ######## Loaded graph
fig1.savefig("./Report/figures/spectra_plot.png")
M0.pyplot(fig2)
fig2.savefig("./Report/figures/Histogram.png")
M000.write('Loaded data summary')
M000.write(stats)
####################################### Model creation ###################################################
regression_algo = None # initialize the selected regression algorithm
Reg = None # initialize the regression model object
intervalls_with_cols = pd.DataFrame()
st.header("II - Model creation", divider='blue')
if not (spectra.empty and y.empty):
M10, M20, M30, M40, M50 = st.columns([1,1,1,1,1])
# select type of supervised modelling problem
modes = ['regression', 'classification']
mode =M10.radio("Analysis Methods", options=modes)
match mode:
case "regression":
reg_algo = ["","PLS", "LW-PLS", "TPE-iPLS"]
regression_algo = M20.selectbox("Choose the regression algorithm", options= reg_algo, key = "regression_algo", format_func=lambda x: x if x else "<Select>")
case 'classification':
reg_algo = ["","PLS", "LW-PLS", "TPE-iPLS"]
regression_algo = M20.selectbox("Choose the classification algorithm", options= reg_algo, key = 12, format_func=lambda x: x if x else "<Select>")
# # Training set preparation for cross-validation(CV)
nb_folds = 3
folds = KF_CV.CV(X_train, y_train, nb_folds)# split train data into nb_folds for cross_validation
# Model creation
match regression_algo:
case "":
M20.warning('Choose a modelling algorithm from the dropdown list !')
case "PLS":
Reg, reg_model, rega = pls_(change =st.session_state.counter)
case 'LW-PLS':
M20.write(f'K-Fold for Cross-Validation (K = {str(nb_folds)})')
info = M20.info('Starting LWPLSR model creation... Please wait a few minutes.')
# export data to csv for Julia train/test
data_to_work_with = ['x_train_np', 'y_train_np', 'x_test_np', 'y_test_np']
x_train_np, y_train_np, x_test_np, y_test_np = X_train.to_numpy(), y_train.to_numpy(), X_test.to_numpy(), y_test.to_numpy()
# Cross-Validation calculation
d = {}
for i in range(nb_folds):
d["xtr_fold{0}".format(i+1)], d["ytr_fold{0}".format(i+1)], d["xte_fold{0}".format(i+1)], d["yte_fold{0}".format(i+1)] = np.delete(x_train_np, folds[list(folds)[i]], axis=0), np.delete(y_train_np, folds[list(folds)[i]], axis=0), x_train_np[folds[list(folds)[i]]], y_train_np[folds[list(folds)[i]]]
data_to_work_with.append("xtr_fold{0}".format(i+1))
data_to_work_with.append("ytr_fold{0}".format(i+1))
data_to_work_with.append("xte_fold{0}".format(i+1))
data_to_work_with.append("yte_fold{0}".format(i+1))
# check best pre-treatment with a global PLSR model
preReg = Plsr(train = [X_train, y_train], test = [X_test, y_test], n_iter=20)
temp_path = Path('temp/')
with open(temp_path / "lwplsr_preTreatments.json", "w+") as outfile:
json.dump(preReg.best_hyperparams_, outfile)
# export Xtrain, Xtest, Ytrain, Ytest and all CV folds to temp folder as csv files
for i in data_to_work_with:
if 'fold' in i:
j = d[i]
else:
j = globals()[i]
np.savetxt(temp_path / str(i + ".csv"), j, delimiter=",")
# run Julia Jchemo as subprocess
import subprocess
subprocess_path = Path("Class_Mod/")
subprocess.run([f"{sys.executable}", subprocess_path / "LWPLSR_Call.py"])
# retrieve json results from Julia JChemo
try:
with open(temp_path / "lwplsr_outputs.json", "r") as outfile:
Reg_json = json.load(outfile)
# delete csv files
for i in data_to_work_with: os.unlink(temp_path / str(i + ".csv"))
# # delete json file after import
os.unlink(temp_path / "lwplsr_outputs.json")
os.unlink(temp_path / "lwplsr_preTreatments.json")
# format result data into Reg object
pred = ['pred_data_train', 'pred_data_test']### keys of the dict
for i in range(nb_folds):
pred.append("CV" + str(i+1)) ### add cv folds keys to pred
Reg = type('obj', (object,), {'model_' : Reg_json['model'], 'best_hyperparams_' : Reg_json['best_lwplsr_params'],
'pred_data_' : [pd.json_normalize(Reg_json[i]) for i in pred]})
reg_model = Reg.model_
Reg.CV_results_ = pd.DataFrame()
Reg.cv_data_ = {'YpredCV' : {}, 'idxCV' : {}}
# # set indexes to Reg.pred_data (train, test, folds idx)
for i in range(len(pred)):
Reg.pred_data_[i] = Reg.pred_data_[i].T.reset_index().drop(columns = ['index'])
if i == 0: # data_train
# Reg.pred_data_[i] = np.array(Reg.pred_data_[i])
Reg.pred_data_[i].index = list(y_train.index)
Reg.pred_data_[i] = Reg.pred_data_[i].iloc[:,0]
elif i == 1: # data_test
# Reg.pred_data_[i] = np.array(Reg.pred_data_[i])
Reg.pred_data_[i].index = list(y_test.index)
Reg.pred_data_[i] = Reg.pred_data_[i].iloc[:,0]
else:
# CVi
Reg.pred_data_[i].index = folds[list(folds)[i-2]]
# Reg.CV_results_ = pd.concat([Reg.CV_results_, Reg.pred_data_[i]])
Reg.cv_data_['YpredCV']['Fold' + str(i-1)] = np.array(Reg.pred_data_[i]).reshape(-1)
Reg.cv_data_['idxCV']['Fold' + str(i-1)] = np.array(folds[list(folds)[i-2]]).reshape(-1)
Reg.CV_results_= KF_CV.metrics_cv(y = y_train, ypcv = Reg.cv_data_['YpredCV'], folds = folds)[1]
#### cross validation results print
Reg.best_hyperparams_print = Reg.best_hyperparams_
## plots
Reg.cv_data_ = KF_CV().meas_pred_eq(y = np.array(y_train), ypcv= Reg.cv_data_['YpredCV'], folds=folds)
Reg.pretreated_spectra_ = preReg.pretreated_spectra_
Reg.best_hyperparams_print = {**preReg.best_hyperparams_, **Reg.best_hyperparams_}
Reg.best_hyperparams_ = {**preReg.best_hyperparams_, **Reg.best_hyperparams_}
info.empty()
M20.success('Model created!')
except FileNotFoundError as e:
# Display error message on the interface if modeling is wrong
info.empty()
M20.warning('- ERROR during model creation -')
Reg = None
for i in data_to_work_with: os.unlink(temp_path / str(i + ".csv"))
case 'TPE-iPLS':
s = M20.number_input(label='Enter the maximum number of intervals', min_value=1, max_value=6)
it = M20.number_input(label='Enter the number of iterations', min_value=50, max_value=500, value=50)
progress_text = "The model is being created. Please wait."
Reg, reg_model, intervalls, intervalls_with_cols, rega = tpeipls_(change = st.session_state.counter, n_intervall= s, n_iter = it)
# pro = M1.info("The model is being created. Please wait!")
# pro.empty()
M20.info("The model has successfully been created!")
if Reg:
if st.button('re-model the data', key=4, help=None, type="primary", use_container_width=True):
increment()
M1, M2 = st.columns([2 ,4])
M1.write('-- Spectral preprocessing info --')
M1.write(Reg.best_hyperparams_print)
with open("data/params/Preprocessing.json", "w") as outfile:
json.dump(Reg.best_hyperparams_, outfile)
yc = Reg.pred_data_[0]
yt = Reg.pred_data_[1]
# ##########
if regression_algo != reg_algo[2]:
M1.dataframe(metrics(c = [y_train, yc], t = [y_test, yt], method='regression').scores_)
else:
M1.dataframe(metrics(t = [y_test, yt], method='regression').scores_)
model_per=pd.DataFrame(metrics(c = [y_train, yc], t = [y_test, yt], method='regression').scores_)
M1.write("-- Model performance --")
M1.dataframe(model_per)
@st.cache_data
def prep_important(change,regression_algo):
fig, (ax1, ax2) = plt.subplots(2,1, figsize = (12, 4), sharex=True)
ax1.plot(colnames, np.mean(X_train, axis = 0), color = 'black', label = 'Average spectrum (Raw)')
# if regression_algo != reg_algo[2]:
ax2.plot(colnames, np.mean(Reg.pretreated_spectra_ , axis = 0), color = 'black', label = 'Average spectrum (Pretreated)')
ax2.set_xlabel('Wavelenghts')
plt.tight_layout()
for i in range(2):
eval(f'ax{i+1}').grid(color='grey', linestyle=':', linewidth=0.2)
eval(f'ax{i+1}').margins(x = 0)
eval(f'ax{i+1}').legend(loc = 'upper right')
eval(f'ax{i+1}').set_ylabel('Intensity')
if regression_algo == 'TPE-iPLS':
a = change
for j in range(s):
if np.array(spectra.columns).dtype.kind in ['i','f']:
min, max = intervalls_with_cols['from'][j], intervalls_with_cols['to'][j]
else:
min, max = intervalls['from'][j], intervalls['to'][j]
eval(f'ax{i+1}').axvspan(min, max, color='#00ff00', alpha=0.5, lw=0)
if regression_algo == 'PLS':
ax1.scatter(colnames[np.array(Reg.sel_ratio_.index)], np.mean(X_train, axis = 0)[np.array(Reg.sel_ratio_.index)],
color = '#7ab0c7', label = 'Important variables')
ax2.scatter(colnames[Reg.sel_ratio_.index], np.mean(Reg.pretreated_spectra_, axis = 0)[np.array(Reg.sel_ratio_.index)],
color = '#7ab0c7', label = 'Important variables')
ax1.legend()
ax2.legend()
return fig
fig = prep_important(change = st.session_state.counter, regression_algo = regression_algo)
if not intervalls_with_cols.empty:
M2.write('-- Important Spectral regions used for model creation --')
M2.table(intervalls_with_cols)
M2.write('-- Visualization of the spectral regions used for model creation --')
fig.savefig("./Report/figures/Variable_importance.png")
M2.pyplot(fig)
################# CV results ############
if Reg:
# fig, (ax1, ax2) = plt.subplots(2,1, figsize = (12, 6))
# fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.02)
st.header("Cross-Validation results")
cv1, cv2 = st.columns([2,2])
############
cv2.write('-- Cross-Validation Summary--')
cv2.write(Reg.CV_results_)
cv_results=pd.DataFrame(Reg.CV_results_)
cv2.write('-- Out-of-Fold Predictions Visualization (All in one) --')
fig1 = px.scatter(Reg.cv_data_[0], x ='Measured', y = 'Predicted' , trendline='ols', color='Folds', symbol="Folds",
color_discrete_sequence=px.colors.qualitative.G10)
fig1.add_shape(type='line', x0 = .95 * min(Reg.cv_data_[0].loc[:,'Measured']), x1 = 1.05 * max(Reg.cv_data_[0].loc[:,'Measured']),
y0 = .95 * min(Reg.cv_data_[0].loc[:,'Measured']), y1 = 1.05 * max(Reg.cv_data_[0].loc[:,'Measured']), line = dict(color='black', dash = "dash"))
fig1.update_traces(marker_size=7, showlegend=False)
cv2.plotly_chart(fig1, use_container_width=True)
fig0 = px.scatter(Reg.cv_data_[0], x ='Measured', y = 'Predicted' , trendline='ols', color='Folds', symbol="Folds", facet_col = 'Folds',facet_col_wrap=1,
color_discrete_sequence=px.colors.qualitative.G10, text='index', width=800, height=1000)
fig0.update_traces(marker_size=8, showlegend=False)
fig0.write_image("./Report/figures/meas_vs_pred_cv_onebyone.png")
cv1.write('-- Out-of-Fold Predictions Visualization (Separate plots) --')
cv1.plotly_chart(fig0, use_container_width=True)
fig1.write_image("./Report/figures/meas_vs_pred_cv_all.png")
st.header("III - Model Diagnosis", divider='blue')
if Reg:
# signal preprocessing results preparation for latex report
prep_para = Reg.best_hyperparams_
if regression_algo != reg_algo[2]:
prep_para.pop('n_components')
for i in ['deriv','polyorder']:
if Reg.best_hyperparams_[i] == 0:
prep_para[i] = '0'
elif Reg.best_hyperparams_[i] == 1:
prep_para[i] = '1st'
elif Reg.best_hyperparams_[i] > 1:
prep_para[i] = f"{Reg.best_hyperparams_[i]}nd"
### reg plot and residuals plot
if regression_algo != reg_algo[2]:
regression_plot = reg_plot([y_train, y_test],[yc, yt], train_idx = train_index, test_idx = test_index)
residual_plot = resid_plot([y_train, y_test], [yc, yt], train_idx=train_index, test_idx=test_index)
else:
regression_plot = reg_plot([y_train, y_test],[yc, yt], train_idx = train_index, test_idx = test_index)
residual_plot = resid_plot([y_train, y_test], [yc, yt], train_idx=train_index, test_idx=test_index)
M7, M8 = st.columns([2,2])
M7.write('Predicted vs Measured values')
M8.write('Residuals plot')
M7.pyplot(regression_plot)
M8.pyplot(residual_plot)
residual_plot.savefig('./Report/figures/residuals_plot.png')
regression_plot.savefig('./Report/figures/measured_vs_predicted.png')
#########################################
if Reg:
st.header('Download Analysis Results', divider='blue')
def export_model():
path = 'data/models/model_'
match file:
case '.csv':
#export_package = __import__(model_export)
with open(path + model_name + date_time + '_created_on_' + xcal_csv.name[:xcal_csv.name.find(".")] +""+
'_and_' + ycal_csv.name[:ycal_csv.name.find(".")] + '_data_' + '.pkl','wb') as f:
joblib.dump(reg_model, f)
if regression_algo == reg_algo[3]:
Reg.selected_features_.T.to_csv(path + model_name + date_time + '_on_' + xcal_csv.name[:xcal_csv.name.find(".")]
+ '_and_' + ycal_csv.name[:ycal_csv.name.find(".")] + '_data_'+'Wavelengths_index.csv', sep = ';')
case '.dx':
#export_package = __import__(model_export)
with open(path + model_name + '_on_'+ data_file.name[:data_file.name.find(".")] + '_data_' + '.pkl','wb') as f:
joblib.dump(reg_model, f)
if regression_algo == reg_algo[3]:
Reg.selected_features_.T.to_csv(path +data_file.name[:data_file.name.find(".")]+ model_name + date_time+ '_on_' + '_data_'+'Wavelengths_index.csv', sep = ';')
def export_report():
match regression_algo:
case 'PLS':
latex_report = report.report('Predictive model development', file_name, stats, list(Reg.best_hyperparams_.values()), regression_algo, model_per, cv_results)
case 'LW-PLS':
latex_report = report.report('Predictive model development', file_name, stats,
list({key: Reg.best_hyperparams_[key] for key in ['deriv', 'normalization', 'polyorder', 'window_length'] if key in Reg.best_hyperparams_}.values()), regression_algo, model_per, cv_results)
case 'TPE-iPLS':
latex_report = report.report('Predictive model development', file_name, stats,
list({key: Reg.best_hyperparams_[key] for key in ['deriv', 'normalization', 'polyorder', 'window_length'] if key in Reg.best_hyperparams_}.values()), regression_algo, model_per, cv_results)
case _:
st.warning('Data processing has not been performed or finished yet!', icon = "⚠️")
report.compile_latex()
M9, M10 = st.columns([1,1])
M10.info('The results are automatically converted into LaTeX code, a strong typesetting system noted for its remarkable document formatting.\
The comprehensive capabilities of LaTeX ensure that your data and findings are cleanly and properly presented,\
swith accurate formatting and organizing.')
# M9.write("-- Save the model --")
model_name = M9.text_input("Please provide a name for the created model: ",value = 'UNNAMED' , placeholder = 'model name')
items_download = M9.selectbox('To proceed, please choose the file or files you want to download from the list below:',
options = ['','Model', 'Report', 'Both Model & Report'], index=0, format_func=lambda x: x if x else "<Select>",
key=None, help=None, on_change=None, args=None, kwargs=None, placeholder="Choose an option", disabled=False, label_visibility="visible")
## Save model and download report
# st.session_state.a = "Please wait while your LaTeX report is being compiled..."
date_time = datetime.datetime.strftime(datetime.date.today(), '_%Y_%m_%d_')
# match items_download:
# case '':
if items_download:
if M9.button('Download', type="primary"):
match items_download:
case '':
M9.warning('Please select an item from the dropdown list!')
case 'Model':
export_model()
case 'Report':
# M9.info("Please wait while your LaTeX report is being compiled...")
export_report()
case 'Both Model & Report':
export_model()
export_report()
M9.success('The selected item has been exported successfully!')
if Reg:
if st.session_state['interface'] == 'simple':
pages_folder = Path("pages/")
show_pages(
[Page("app.py", "Home"),
Page(str(pages_folder / "4-inputs.py"), "Inputs"),
Page(str(pages_folder / "1-samples_selection.py"), "Samples Selection"),
Page(str(pages_folder / "2-model_creation.py"), "Models Creation"),
Page(str(pages_folder / "3-prediction.py"), "Predictions"),
]
)
st.page_link('pages\\3-prediction.py', label = 'Keep on keepin\' on to predict your values !')
##### for outliers removal
# data_df = pd.DataFrame(
# {
# "widgets": ["st.selectbox", "st.number_input", "st.text_area", "st.button"],
# "favorite": [True, False, False, True],
# }
# )
# st.data_editor(
# data_df,
# column_config={
# "favorite": st.column_config.CheckboxColumn(
# "Your favorite",
# help="Select your widgets",
# default=False,
# )
# },
# disabled=["widgets"],
# hide_index=True,
# )