Newer
Older
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_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")
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
# 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.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
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:
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="⚠️")
DIANE
committed
st.header("I - Data visualization", divider='blue')
X_train, X_test,y_train, y_test, colnames, train_index, test_index, stats, fig1, fig2= visualize(hash_data(y+np.median(spectra)))
DIANE
committed
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")
DIANE
committed
M000.write('Loaded data summary')
####################################### Model creation ###################################################
regression_algo = None # initialize the selected regression algorithm
Reg = None # initialize the regression model object
DIANE
committed
st.header("II - Model creation", divider='blue')
DIANE
committed
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>")
DIANE
committed
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 !')
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]
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
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"))
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)
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.dataframe(model_per) # duplicate with line 371
@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")
################# 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)
DIANE
committed
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",
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"))
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")
DIANE
committed
st.header("III - Model Diagnosis", divider='blue')
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
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():
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 = ';')
DIANE
committed
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)
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
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!')
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
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,
# )