323 lines
9.5 KiB
Python
323 lines
9.5 KiB
Python
import marimo
|
|
|
|
__generated_with = "0.10.16"
|
|
app = marimo.App(width="medium")
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def title():
|
|
import marimo as mo
|
|
notebook_name = 'run_perfspec.py'
|
|
|
|
from lib_perfspec import perfspec_vars
|
|
(_,_defs) = perfspec_vars.run()
|
|
perfspec = _defs['perfspec']
|
|
|
|
from lib_perfspec import perfspec_header
|
|
(_,_defs) = perfspec_header.run()
|
|
lib_header = _defs['header']
|
|
lib_intro = _defs['intro']
|
|
|
|
mo.md(
|
|
f"""
|
|
{lib_header(notebook_name)}
|
|
### Use **{perfspec['app']['train_mode']}** trained model
|
|
"""
|
|
)
|
|
return (
|
|
lib_header,
|
|
lib_intro,
|
|
mo,
|
|
notebook_name,
|
|
perfspec,
|
|
perfspec_header,
|
|
perfspec_vars,
|
|
)
|
|
|
|
|
|
@app.cell
|
|
def imports():
|
|
from pathlib import Path
|
|
return (Path,)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def intro_load(Path, lib_intro, mo, notebook_name, perfspec):
|
|
verbose = perfspec['settings']['verbose']
|
|
perfspec['vars'] = {}
|
|
|
|
from lib_perfspec import perfspec_args
|
|
(_,_defs) = perfspec_args.run()
|
|
|
|
if not Path(perfspec['defaults']['models_dirpath']).exists():
|
|
exit(f"Trained models dir path not found: {perfspec['defaults']['models_dirpath']}")
|
|
|
|
if not Path(perfspec['defaults']['checkpoints_dirpath']).exists():
|
|
exit(f"Trained checkpoints models dir path not found: {perfspec['defaults']['checkpoints_dirpath']}")
|
|
|
|
if not Path(perfspec['defaults']['data_dirpath']).exists():
|
|
exit(f"data dir path not found: {perfspec['defaults']['data_dirpath']}")
|
|
|
|
verbose=perfspec['settings'].get('verbose')
|
|
|
|
from lib_perfspec import perfspec_load_actions
|
|
(_,_defs) = perfspec_load_actions.run()
|
|
lib_load_actions = _defs['load_actions']
|
|
|
|
from lib_perfspec import perfspec_input_sequence
|
|
(_,_defs) = perfspec_input_sequence.run()
|
|
lib_get_input_sequence = _defs['get_input_sequence']
|
|
|
|
from lib_perfspec import perfspec_predict
|
|
_, _defs = perfspec_predict.run()
|
|
lib_predict_action = _defs['predict_action']
|
|
|
|
perfspec['vars']['model'] = None
|
|
perfspec['vars']['history'] = None
|
|
|
|
(perfspec['vars']['actions'],
|
|
perfspec['vars']['unique_actions'],
|
|
perfspec['vars']['label_encoder'],
|
|
perfspec['vars']['encoded_actions']
|
|
) = lib_load_actions(
|
|
actions_path=perfspec['settings'].get('actions_filepath'),
|
|
verbose=None
|
|
)
|
|
|
|
perfspec['vars']['input_sequence'] = lib_get_input_sequence(
|
|
input_str=perfspec['settings']['input_str'],
|
|
unique_actions=perfspec['vars']['unique_actions']
|
|
)
|
|
|
|
from train_perfspec import perfspec_load_model_from_path
|
|
(_,_defs) = perfspec_load_model_from_path.run()
|
|
lib_load_model_from_path = _defs['load_model_from_path']
|
|
|
|
mo.md(
|
|
f"""
|
|
{lib_intro(notebook_name)}
|
|
|
|
"""
|
|
)
|
|
return (
|
|
lib_get_input_sequence,
|
|
lib_load_actions,
|
|
lib_load_model_from_path,
|
|
lib_predict_action,
|
|
perfspec_args,
|
|
perfspec_input_sequence,
|
|
perfspec_load_actions,
|
|
perfspec_load_model_from_path,
|
|
perfspec_predict,
|
|
verbose,
|
|
)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def settings(mo, notebook_name):
|
|
from lib_perfspec import perfspec_out_settings
|
|
(_,_defs) = perfspec_out_settings.run()
|
|
out_settings = _defs['out_settings']
|
|
|
|
mo.md(out_settings(notebook_name))
|
|
return out_settings, perfspec_out_settings
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def command_line(mo, notebook_name):
|
|
from lib_perfspec import perfspec_cli_ops
|
|
(_,_defs) = perfspec_cli_ops.run()
|
|
out_cli_ops = _defs['out_cli_ops']
|
|
mo.accordion({
|
|
"Mostrar command Line options ": out_cli_ops(notebook_name)
|
|
})
|
|
return out_cli_ops, perfspec_cli_ops
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def load_trained_model(lib_load_model_from_path, mo, perfspec):
|
|
def load_trained_model():
|
|
if perfspec['vars']['model'] == None:
|
|
_verbose = perfspec['settings']['verbose'] # if mo.running_in_notebook() else perfspec['settings']['verbose']
|
|
perfspec['vars']['model'] = lib_load_model_from_path(perfspec,_verbose)
|
|
if perfspec['vars']['model'] == None:
|
|
print ("No model loaded !")
|
|
|
|
mo.md(
|
|
r"""
|
|
## Load trained model
|
|
"""
|
|
)
|
|
return (load_trained_model,)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def model_summary(load_trained_model, mo, perfspec):
|
|
def model_sumary():
|
|
load_trained_model()
|
|
if perfspec['vars']['model'] != None:
|
|
perfspec['vars']['model'].summary()
|
|
|
|
if perfspec['settings']['verbose'] is not None or mo.running_in_notebook():
|
|
model_sumary()
|
|
mo.md(
|
|
r"""
|
|
## Model Summary
|
|
"""
|
|
)
|
|
return (model_sumary,)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def perfspec_def_predict_input(
|
|
input_multiselect,
|
|
lib_get_input_sequence,
|
|
lib_predict_action,
|
|
load_trained_model,
|
|
mo,
|
|
model_sumary,
|
|
perfspec,
|
|
run_evaluate,
|
|
):
|
|
def predict_input(pred_input, verbose):
|
|
#verbose = "1" if mo.running_in_notebook() else perfspec['settings']['verbose']
|
|
if type(pred_input) == str and pred_input != '':
|
|
input_sequence = lib_get_input_sequence(pred_input,perfspec['vars']['unique_actions'])
|
|
elif type(pred_input) != str and len(pred_input) > 0:
|
|
input_sequence = pred_input
|
|
elif mo.running_in_notebook() and len(input_multiselect.value) > 0:
|
|
input_sequence= input_multiselect.value
|
|
elif perfspec['defaults']['pred_input'] != '':
|
|
input_sequence = lib_get_input_sequence(perfspec['defaults']['pred_input'],perfspec['vars']['unique_actions'])
|
|
else:
|
|
print (f"No input found ! {input_sequence}")
|
|
return
|
|
if len(input_sequence) > 0:
|
|
if verbose == "x":
|
|
model_sumary()
|
|
run_evaluate()
|
|
print ("\nPrediction")
|
|
if perfspec['vars']['model'] == None:
|
|
load_trained_model()
|
|
if perfspec['vars']['model'] != None:
|
|
(encoded_input,predicted_probabilities) = lib_predict_action(
|
|
perfspec['vars']['model'],
|
|
perfspec['settings']['sequence_length'],
|
|
input_sequence,
|
|
perfspec['vars']['label_encoder'],
|
|
verbose
|
|
)
|
|
return (encoded_input,predicted_probabilities)
|
|
else:
|
|
print (f"No Model found to predict {input_sequence}")
|
|
return (None,None)
|
|
return (predict_input,)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def multiselect_def(mo, perfspec):
|
|
input_multiselect = mo.ui.multiselect(
|
|
options=perfspec['vars']['unique_actions'],
|
|
full_width=True,
|
|
max_selections=perfspec['settings']['sequence_length'],
|
|
)
|
|
return (input_multiselect,)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def perfspec_def_show_value_selector(
|
|
input_multiselect,
|
|
mo,
|
|
perfspec,
|
|
predict_input,
|
|
):
|
|
def show_value():
|
|
if len(input_multiselect.value) > 0:
|
|
if len(input_multiselect.value) > perfspec['settings']['sequence_length']:
|
|
return ""
|
|
(_,prediction) = predict_input(input_multiselect.value, None)
|
|
table_info = mo.md(f"""
|
|
| desc. | value | % |
|
|
| ---- | --- | --- |
|
|
| input | {",".join(input_multiselect.value)}| |
|
|
| prediction | {prediction['action'][0]} |{prediction['max_value']}|
|
|
""")
|
|
return mo.md(f"{mo.vstack(justify='center',items=[mo.md("<h3 style='margin-left: 7em'>Actions</h3>"),table_info])}")
|
|
else:
|
|
return ""
|
|
return (show_value,)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def title_run_prediction(mo, perfspec):
|
|
mo.md(
|
|
f"""
|
|
## Run Model Prediction
|
|
|
|
Use **{perfspec['vars']['input_sequence']}** with trained model <u>created</u> or <u>loaded</u>
|
|
<br>from {perfspec['settings']['model_filepath']}
|
|
|
|
input value can be changed in **command-line** with **--input** `value` argument<br>
|
|
with **--verbose** option more info is show in **command-line** mode
|
|
"""
|
|
)
|
|
return
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def _(mo, perfspec, predict_input):
|
|
def run_prediction():
|
|
_verbose = perfspec["settings"]["verbose"]
|
|
if perfspec["settings"]["verbose"] is None and mo.running_in_notebook():
|
|
_verbose=1
|
|
predict_input("", _verbose)
|
|
|
|
run_prediction()
|
|
|
|
mo.md(
|
|
"""
|
|
### Test default prediction
|
|
"""
|
|
)
|
|
return (run_prediction,)
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def main(mo):
|
|
mo.md("""<a id='main' />""")
|
|
return
|
|
|
|
|
|
@app.cell(hide_code=True)
|
|
def perfspec_predictions_selector(
|
|
input_multiselect,
|
|
mo,
|
|
perfspec,
|
|
show_value,
|
|
):
|
|
def show_selector():
|
|
if mo.running_in_notebook():
|
|
if perfspec['settings']['sequence_length'] > 1:
|
|
seq_msg = f"<br> <small>For better `prediction` use at least **{perfspec['settings']['sequence_length']}** options"
|
|
else:
|
|
seq_msg = ""
|
|
return f"""
|
|
{mo.hstack(widths="equal",gap=3,wrap=True,items=[
|
|
mo.vstack(items=[mo.md("""
|
|
## Predictions
|
|
Select values to get prediction
|
|
"""),input_multiselect]),
|
|
show_value()]
|
|
)}
|
|
> <small>if notebook **autorun** is not set, use <u>click on cell to run</u></small>
|
|
{seq_msg}
|
|
"""
|
|
else:
|
|
return ""
|
|
mo.md(show_selector())
|
|
return (show_selector,)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
app.run()
|