pycompound 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

app.py

@@ -2,10 +2,11 @@
 from shiny import App, ui, reactive, render, req
 from pycompound.spec_lib_matching import run_spec_lib_matching_on_HRMS_data 
 from pycompound.spec_lib_matching import run_spec_lib_matching_on_NRMS_data 
-from pycompound.spec_lib_matching import tune_params_on_HRMS_data
-from pycompound.spec_lib_matching import tune_params_on_NRMS_data
-from pycompound.spec_lib_matching import tune_params_on_HRMS_data_shiny
-from pycompound.spec_lib_matching import tune_params_on_NRMS_data_shiny
+from pycompound.spec_lib_matching import tune_params_on_HRMS_data_grid
+from pycompound.spec_lib_matching import tune_params_on_NRMS_data_grid
+from pycompound.spec_lib_matching import tune_params_on_HRMS_data_grid_shiny
+from pycompound.spec_lib_matching import tune_params_on_NRMS_data_grid_shiny
+from pycompound.spec_lib_matching import tune_params_DE
 from pycompound.plot_spectra import generate_plots_on_HRMS_data
 from pycompound.plot_spectra import generate_plots_on_NRMS_data
 from pathlib import Path
@@ -25,7 +26,6 @@ import ast
 from numbers import Real
 
 
-
 _LOG_QUEUE: asyncio.Queue[str] = asyncio.Queue()
 
 def _run_with_redirects(fn, writer, *args, **kwargs):
@@ -395,7 +395,7 @@ def run_spec_lib_matching_ui(platform: str):
 
 
 
-def run_parameter_tuning_ui(platform: str):
+def run_parameter_tuning_grid_ui(platform: str):
     base_inputs = [
         ui.input_file("query_data", "Upload query dataset (mgf, mzML, cdf, msp, or csv):"),
         ui.input_file("reference_data", "Upload reference dataset (mgf, mzML, cdf, msp, or csv):"),
@@ -436,7 +436,7 @@ def run_parameter_tuning_ui(platform: str):
     ]
 
 
-    run_button_parameter_tuning = ui.download_button("run_btn_parameter_tuning", "Tune parameters", style="font-size:16px; padding:15px 30px; width:200px; height:80px")
+    run_button_parameter_tuning_grid = ui.download_button("run_btn_parameter_tuning_grid", "Tune parameters (grid search)", style="font-size:16px; padding:15px 30px; width:200px; height:80px")
     back_button = ui.input_action_button("back", "Back to main menu", style="font-size:16px; padding:15px 30px; width:200px; height:80px")
 
     if platform == "HRMS":
@@ -466,7 +466,7 @@ def run_parameter_tuning_ui(platform: str):
         ui.TagList(
             ui.h2("Tune parameters"),
             inputs_columns,
-            run_button_parameter_tuning,
+            run_button_parameter_tuning_grid,
             back_button,
             log_panel
         ),
@@ -474,8 +474,120 @@ def run_parameter_tuning_ui(platform: str):
 
 
 
+PARAMS_HRMS = {
+    "window_size_centroiding": (0.0, 0.5),
+    "window_size_matching":    (0.0, 0.5),
+    "noise_threshold":         (0.0, 0.25),
+    "wf_mz":                   (0.0, 5.0),
+    "wf_int":                  (0.0, 5.0),
+    "LET_threshold":           (0.0, 5.0),
+    "entropy_dimension":       (1.0, 3.0)
+}
+
+PARAMS_NRMS = {
+    "noise_threshold":         (0.0, 0.25),
+    "wf_mz":                   (0.0, 5.0),
+    "wf_int":                  (0.0, 5.0),
+    "LET_threshold":           (0.0, 5.0),
+    "entropy_dimension":       (1.0, 3.0)
+}
+
+def run_parameter_tuning_DE_ui(platform: str):
+    if platform == 'HRMS':
+        PARAMS=PARAMS_HRMS
+    else:
+        PARAMS=PARAMS_NRMS
+
+    base_inputs = [
+        ui.input_file("query_data", "Upload query dataset (mgf, mzML, cdf, msp, or csv):"),
+        ui.input_file("reference_data", "Upload reference dataset (mgf, mzML, cdf, msp, or csv):"),
+        ui.input_select("similarity_measure", "Select similarity measure:", ["cosine","shannon","renyi","tsallis","mixture","jaccard","dice","3w_jaccard","sokal_sneath","binary_cosine","mountford","mcconnaughey","driver_kroeber","simpson","braun_banquet","fager_mcgowan","kulczynski","intersection","hamming","hellinger"]),
+        ui.input_text('weights', 'Weights for mixture similarity measure (cosine, shannon, renyi, tsallis):', '0.25, 0.25, 0.25, 0.25'),
+        ui.input_select("high_quality_reference_library", "Indicate whether the reference library is considered high quality. If True, filtering and noise removal are only applied to the query spectra.", [False, True],),
+    ]
+
+    if platform == "HRMS":
+        extra_inputs = [
+            ui.input_text(
+                "spectrum_preprocessing_order",
+                "Sequence of characters for preprocessing order (C (centroiding), F (filtering), M (matching), N (noise removal), L (low-entropy transformation), W (weight factor transformation)). M must be included, C before M if used.",
+                "FCNMWL",
+            ),
+            ui.input_numeric("window_size_centroiding", "Centroiding window-size:", 0.5),
+            ui.input_numeric("window_size_matching", "Matching window-size:", 0.5),
+        ]
+    else:
+        extra_inputs = [
+            ui.input_text(
+                "spectrum_preprocessing_order",
+                "Sequence of characters for preprocessing order (F (filtering), N (noise removal), L (low-entropy transformation), W (weight factor transformation)).",
+                "FNLW",
+            )
+        ]
+
+    numeric_inputs = [
+        ui.input_numeric("mz_min", "Minimum m/z for filtering:", 0),
+        ui.input_numeric("mz_max", "Maximum m/z for filtering:", 99999999),
+        ui.input_numeric("int_min", "Minimum intensity for filtering:", 0),
+        ui.input_numeric("int_max", "Maximum intensity for filtering:", 999999999),
+        ui.input_numeric("noise_threshold", "Noise removal threshold:", 0.0),
+        ui.input_numeric("wf_mz", "Mass/charge weight factor:", 0.0),
+        ui.input_numeric("wf_int", "Intensity weight factor:", 1.0),
+        ui.input_numeric("LET_threshold", "Low-entropy threshold:", 0.0),
+        ui.input_numeric("entropy_dimension", "Entropy dimension (Renyi/Tsallis only):", 1.1),
+    ]
+
+
+    #run_button_parameter_tuning_DE = ui.download_button("run_btn_parameter_tuning_DE", "Tune parameters (differential evolution optimization)", style="font-size:16px; padding:15px 30px; width:300px; height:100px")
+    run_button_parameter_tuning_DE = ui.input_action_button("run_btn_parameter_tuning_DE", "Tune parameters (differential evolution optimization)", style="font-size:16px; padding:15px 30px; width:300px; height:100px")
+    back_button = ui.input_action_button("back", "Back to main menu", style="font-size:16px; padding:15px 30px; width:300px; height:100px")
+
+    if platform == "HRMS":
+        inputs_columns = ui.layout_columns(
+            ui.div(base_inputs[0:6], style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div([base_inputs[6:7], *extra_inputs], style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div(numeric_inputs[0:5], style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div([numeric_inputs[5:10]], style="display:flex; flex-direction:column; gap:10px;"),
+            col_widths=(3,3,3,3),
+        )
+    elif platform == "NRMS":
+        inputs_columns = ui.layout_columns(
+            ui.div(base_inputs[0:6], style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div([base_inputs[6:7], *extra_inputs], style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div(numeric_inputs[0:5], style="display:flex; flex-direction:column; gap:10px;"),
+            ui.div([numeric_inputs[5:10]], style="display:flex; flex-direction:column; gap:10px;"),
+            col_widths=(3,3,3,3),
+        )
+
+    return ui.page_fillable(
+        ui.layout_sidebar(
+            ui.sidebar(
+                ui.h3("Select parameters"),
+                ui.input_checkbox_group(
+                    "params",
+                    None,
+                    choices=list(PARAMS.keys()),
+                    selected=["noise_threshold","LET_threshold"],
+                ),
+                ui.hr(),
+                ui.h4("Bounds for selected parameters"),
+                ui.output_ui("bounds_inputs"),
+                width=360,
+            ),
+            ui.div(
+                ui.h2("Tune parameters (differential evolution optimization)"),
+                *(inputs_columns if isinstance(inputs_columns, (list, tuple)) else [inputs_columns]),
+                run_button_parameter_tuning_DE,
+                back_button,
+            ),
+        )
+    )
+
+
+
 
 app_ui = ui.page_fluid(
+    ui.head_content(ui.tags.link(rel="icon", href="emblem.png")),
     ui.output_ui("main_ui"),
     ui.output_text("status_output")
 )
@@ -492,8 +604,10 @@ def server(input, output, session):
     run_status_plot_spectra = reactive.Value("")
     run_status_spec_lib_matching = reactive.Value("")
     run_status_plot_spectra_within_spec_lib_matching = reactive.Value("")
-    run_status_parameter_tuning = reactive.Value("")
-    is_tuning_running = reactive.Value(False)
+    run_status_parameter_tuning_grid = reactive.Value("")
+    run_status_parameter_tuning_DE = reactive.Value("")
+    is_tuning_grid_running = reactive.Value(False)
+    is_tuning_DE_running = reactive.Value(False)
     match_log_rv = reactive.Value("")
     is_matching_rv = reactive.Value(False)
     is_any_job_running = reactive.Value(False)
@@ -513,6 +627,64 @@ def server(input, output, session):
     converted_query_path_rv = reactive.Value(None)
     converted_reference_path_rv = reactive.Value(None)
 
+    @output
+    @render.ui
+    def bounds_inputs():
+        selected = input.params()
+        if not selected:
+            return ui.div(ui.em("Select one or more parameters above."))
+
+        if input.chromatography_platform() == 'HRMS':
+            PARAMS = PARAMS_HRMS
+        else:
+            PARAMS = PARAMS_NRMS
+        blocks = []
+        for name in selected:
+            lo, hi = PARAMS.get(name, (0.0, 1.0))
+            blocks.append(
+                ui.card(
+                    ui.card_header(name),
+                    ui.layout_columns(
+                        ui.input_numeric(f"min_{name}", "Lower", lo, step=0.001),
+                        ui.input_numeric(f"max_{name}", "Upper", hi, step=0.001),
+                    )
+                )
+            )
+        return ui.div(*blocks)
+
+    def _read_bounds_dict():
+        selected = input.params()
+        out = {}
+        for name in selected:
+            lo_default, hi_default = PARAMS.get(name, (0.0, 1.0))
+            lo_id = f"min_{name}"
+            hi_id = f"max_{name}"
+
+            lo_val = input[lo_id]() if lo_id in input else lo_default
+            hi_val = input[hi_id]() if hi_id in input else hi_default
+
+            out[name] = (float(lo_val), float(hi_val))
+        return out
+
+    def _read_bounds():
+        opt_params = input.params()
+        bounds_dict = {}
+        if input.chromatography_platform() == 'HRMS':
+            PARAMS = PARAMS_HRMS
+        else:
+            PARAMS = PARAMS_NRMS
+
+        for p in opt_params:
+            lo_id, hi_id = f"min_{p}", f"max_{p}"
+            lo_default, hi_default = PARAMS.get(p, (0.0, 1.0))
+            lo = input[lo_id]() if lo_id in input else lo_default
+            hi = input[hi_id]() if hi_id in input else hi_default
+            if lo > hi:
+                lo, hi = hi, lo
+            bounds_dict[p] = (float(lo), float(hi))
+
+        bounds_list = [bounds_dict[p] for p in opt_params]
+        return opt_params, bounds_dict, bounds_list
 
     def _reset_plot_spectra_state():
         query_status_rv.set("")
@@ -545,7 +717,8 @@ def server(input, output, session):
 
     def _reset_parameter_tuning_state():
         match_log_rv.set("")
-        is_tuning_running.set(False)
+        is_tuning_grid_running.set(False)
+        is_tuning_DE_running.set(False)
         is_any_job_running.set(False)
 
 
@@ -557,7 +730,9 @@ def server(input, output, session):
             _reset_plot_spectra_state()
         elif page == "run_spec_lib_matching":
             _reset_spec_lib_matching_state()
-        elif page == "run_parameter_tuning":
+        elif page == "run_parameter_tuning_grid":
+            _reset_parameter_tuning_state()
+        elif page == "run_parameter_tuning_DE":
             _reset_parameter_tuning_state()
 
     @reactive.effect
@@ -567,7 +742,9 @@ def server(input, output, session):
             _reset_plot_spectra_state()
         elif page == "run_spec_lib_matching":
             _reset_spec_lib_matching_state()
-        elif page == "run_parameter_tuning":
+        elif page == "run_parameter_tuning_grid":
+            _reset_parameter_tuning_state()
+        elif page == "run_parameter_tuning_DE":
             _reset_parameter_tuning_state()
 
 
@@ -595,7 +772,7 @@ def server(input, output, session):
 
     @reactive.effect
     async def _pump_logs():
-        if not (is_any_job_running.get() or is_tuning_running.get() or is_matching_rv.get()):
+        if not (is_any_job_running.get() or is_tuning_grid_running.get() or is_tuning_DE_running.get() or is_matching_rv.get()):
             return
         reactive.invalidate_later(0.05)
         msgs = _drain_queue_nowait(_LOG_QUEUE)
@@ -674,9 +851,12 @@ def server(input, output, session):
         elif input.run_spec_lib_matching() > match_clicks.get():
             current_page.set("run_spec_lib_matching")
             match_clicks.set(input.run_spec_lib_matching())
-        elif input.run_parameter_tuning() > match_clicks.get():
-            current_page.set("run_parameter_tuning")
-            match_clicks.set(input.run_parameter_tuning())
+        elif input.run_parameter_tuning_grid() > match_clicks.get():
+            current_page.set("run_parameter_tuning_grid")
+            match_clicks.set(input.run_parameter_tuning_grid())
+        elif input.run_parameter_tuning_DE() > match_clicks.get():
+            current_page.set("run_parameter_tuning_DE")
+            match_clicks.set(input.run_parameter_tuning_DE())
         elif hasattr(input, "back") and input.back() > back_clicks.get():
             current_page.set("main_menu")
             back_clicks.set(input.back())
@@ -688,7 +868,6 @@ def server(input, output, session):
         img: ImgData = {"src": str(dir / "www/emblem.png"), "width": "320px", "height": "250px"}
         return img
 
-
     @output
     @render.ui
     def main_ui():
@@ -697,6 +876,7 @@ def server(input, output, session):
                 ui.h2("Main Menu"),
                 ui.div(
                     ui.output_image("image"),
+                    #ui.img(src="emblem.png", width="320px", height="250px"),
                     style=(
                         "position:fixed; top:0; left:50%; transform:translateX(-50%); "
                         "z-index:1000; text-align:center; padding:10px; background-color:white;"
@@ -720,7 +900,8 @@ def server(input, output, session):
                 ),
                 ui.input_action_button("plot_spectra", "Plot two spectra before and after preprocessing transformations.", style="font-size:18px; padding:20px 40px; width:550px; height:100px; margin-top:10px; margin-right:50px"),
                 ui.input_action_button("run_spec_lib_matching", "Run spectral library matching to perform compound identification on a query library of spectra.", style="font-size:18px; padding:20px 40px; width:550px; height:100px; margin-top:10px; margin-right:50px"),
-                ui.input_action_button("run_parameter_tuning", "Tune parameters to maximize accuracy of compound identification given a query library with known spectrum IDs.", style="font-size:18px; padding:20px 40px; width:450px; height:120px; margin-top:10px; margin-right:50px"),
+                ui.input_action_button("run_parameter_tuning_grid", "Grid search: Tune parameters to maximize accuracy of compound identification given a query library with known spectrum IDs.", style="font-size:18px; padding:20px 40px; width:450px; height:120px; margin-top:10px; margin-right:50px"),
+                ui.input_action_button("run_parameter_tuning_DE", "Differential evolution optimization: Tune parameters to maximize accuracy of compound identification given a query library with known spectrum IDs.", style="font-size:18px; padding:20px 40px; width:500px; height:150px; margin-top:10px; margin-right:50px"),
                 ui.div(
                     "References:",
                     style="margin-top:35px; text-align:left; font-size:24px; font-weight:bold"
@@ -771,8 +952,10 @@ def server(input, output, session):
             return plot_spectra_ui(input.chromatography_platform())
         elif current_page() == "run_spec_lib_matching":
             return run_spec_lib_matching_ui(input.chromatography_platform())
-        elif current_page() == "run_parameter_tuning":
-            return run_parameter_tuning_ui(input.chromatography_platform())
+        elif current_page() == "run_parameter_tuning_grid":
+            return run_parameter_tuning_grid_ui(input.chromatography_platform())
+        elif current_page() == "run_parameter_tuning_DE":
+            return run_parameter_tuning_DE_ui(input.chromatography_platform())
 
 
 
@@ -1014,10 +1197,10 @@ def server(input, output, session):
             yield buf.getvalue()
 
 
-    @render.download(filename="parameter_tuning_output.txt")
-    async def run_btn_parameter_tuning():
+    @render.download(filename="parameter_tuning_grid_output.txt")
+    async def run_btn_parameter_tuning_grid():
         is_any_job_running.set(True)
-        is_tuning_running.set(True)
+        is_tuning_grid_running.set(True)
         match_log_rv.set("Running grid search of all parameters specified...\n")
         await reactive.flush()
 
@@ -1038,7 +1221,7 @@ def server(input, output, session):
         common_kwargs = dict(
             query_data=input.query_data()[0]["datapath"],
             reference_data=input.reference_data()[0]["datapath"],
-            output_path=str(Path.cwd() / "parameter_tuning_output.txt"),
+            output_path=str(Path.cwd() / "parameter_tuning_grid_output.txt"),
             return_output=True,
         )
 
@@ -1066,7 +1249,7 @@ def server(input, output, session):
                     'window_size_centroiding': window_size_centroiding_tmp,
                     'window_size_matching': window_size_matching_tmp,
                 }
-                df_out = await asyncio.to_thread(_run_with_redirects, tune_params_on_HRMS_data_shiny, rw, **common_kwargs, grid=grid)
+                df_out = await asyncio.to_thread(_run_with_redirects, tune_params_on_HRMS_data_grid_shiny, rw, **common_kwargs, grid=grid)
             else:
                 grid = {
                     'similarity_measure': similarity_measure_tmp,
@@ -1083,26 +1266,59 @@ def server(input, output, session):
                     'entropy_dimension': entropy_dimension_tmp,
                     'high_quality_reference_library': high_quality_reference_library_tmp,
                 }
-                df_out = await asyncio.to_thread(_run_with_redirects, tune_params_on_NRMS_data_shiny, rw, **common_kwargs, grid=grid)
+                df_out = await asyncio.to_thread(_run_with_redirects, tune_params_on_NRMS_data_grid_shiny, rw, **common_kwargs, grid=grid)
 
             match_log_rv.set(match_log_rv.get() + "\n✅ Parameter tuning finished.\n")
         except Exception as e:
             match_log_rv.set(match_log_rv.get() + f"\n❌ Error: {e}\n")
             raise
         finally:
-            is_tuning_running.set(False)
+            is_tuning_grid_running.set(False)
             is_any_job_running.set(False)
             await reactive.flush()
 
         yield df_out.to_csv(index=False).encode("utf-8", sep='\t')
 
 
+    @reactive.effect
+    @reactive.event(input.run_btn_parameter_tuning_DE)
+    def _run_btn_parameter_tuning_DE():
+        is_any_job_running.set(True)
+        is_tuning_DE_running.set(True)
+        match_log_rv.set("Tuning specified continuous parameters using differential evolution...\n")
+
+        #print('\nhere!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
+        weights = [float(weight.strip()) for weight in input.weights().split(",") if weight.strip()]
+        weights = {'Cosine':weights[0], 'Shannon':weights[1], 'Renyi':weights[2], 'Tsallis':weights[3]}
+        opt_params, bounds_dict, bounds_list = _read_bounds()
+        #print(input.params())
+        #print("Optimizing over:", opt_params)
+        #print("Bounds list:", bounds_list)
+        #print("Bounds dict:", bounds_dict)
+        #tmp = {"window_size_centroiding":input.window_size_centroiding(), "window_size_matching":input.window_size_matching(), "noise_threshold":input.noise_threshold(), "wf_mz":input.wf_mz(), "wf_int":input.wf_int(), "LET_threshold":input.LET_threshold(), "entropy_dimension":input.entropy_dimension()}
+        #print(tmp)
+        if input.chromatography_platform() == 'HRMS':
+            tune_params_DE(query_data=input.query_data()[0]["datapath"],
+                           reference_data=input.reference_data()[0]["datapath"],
+                           similarity_measure=input.similarity_measure(),
+                           weights=weights,
+                           spectrum_preprocessing_order=input.spectrum_preprocessing_order(),
+                           mz_min=input.mz_min(),
+                           mz_max=input.mz_max(),
+                           int_min=input.int_min(),
+                           int_max=input.int_max(),
+                           high_quality_reference_library=input.high_quality_reference_library(),
+                           optimize_params=list(input.params()),
+                           param_bounds={"window_size_matching":(0.0,0.5),"noise_threshold":(0.0,0.25),"wf_mz":(0.0,5.0),"wf_int":(0.0,5.0)},
+                           #param_bounds=bounds_dict,
+                           default_params={"window_size_centroiding":input.window_size_centroiding(), "window_size_matching":input.window_size_matching(), "noise_threshold":input.noise_threshold(), "wf_mz":input.wf_mz(), "wf_int":input.wf_int(), "LET_threshold":input.LET_threshold(), "entropy_dimension":input.entropy_dimension()})
+        #print('here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n')
 
 
 
     @reactive.effect
     async def _pump_reactive_writer_logs():
-        if not is_tuning_running.get():
+        if not is_tuning_grid_running.get():
             return
 
         reactive.invalidate_later(0.1)
@@ -1116,9 +1332,11 @@ def server(input, output, session):
     def status_output():
         return run_status_plot_spectra.get()
         return run_status_spec_lib_matching.get()
-        return run_status_parameter_tuning.get()
+        return run_status_parameter_tuning_grid.get()
+        return run_status_parameter_tuning_DE.get()
 
 
 app = App(app_ui, server)
 
 
+

app2.py

@@ -0,0 +1,101 @@
+
+
+# app.py
+from shiny import App, ui, render, reactive
+import pandas as pd
+
+# Parameters to choose from + suggested default ranges
+PARAMS = {
+    "window_size_centroiding": (0.0, 0.5),
+    "window_size_matching":    (0.0, 0.5),
+    "noise_threshold":         (0.0, 0.25),
+    "wf_mz":                   (0.0, 5.0),
+    "wf_int":                  (0.0, 5.0),
+    "LET_threshold":           (0.0, 5.0),
+    "entropy_dimension":       (1.0, 3.0),
+}
+
+app_ui = ui.page_fillable(
+    ui.layout_sidebar(
+        ui.sidebar(
+            ui.h3("Select parameters"),
+            ui.input_checkbox_group(
+                id="params",
+                label=None,
+                choices=list(PARAMS.keys()),
+                selected=["window_size_centroiding", "noise_threshold"],
+            ),
+            ui.hr(),
+            ui.h4("Bounds for selected parameters"),
+            ui.output_ui("bounds_inputs"),
+            width=360,
+        ),
+    )
+)
+
+def server(input, output, session):
+    @output
+    @render.ui
+    def bounds_inputs():
+        selected = input.params()
+        if not selected:
+            return ui.div(ui.em("Select one or more parameters above."))
+
+        blocks = []
+        for name in selected:
+            lo, hi = PARAMS.get(name, (0.0, 1.0))
+            blocks.append(
+                ui.card(
+                    ui.card_header(name),
+                    ui.layout_columns(
+                        ui.input_numeric(f"min_{name}", "Lower", lo, step=0.001),
+                        ui.input_numeric(f"max_{name}", "Upper", hi, step=0.001),
+                    )
+                )
+            )
+        return ui.div(*blocks)
+
+    def _read_bounds_dict():
+        selected = input.params()
+        out = {}
+        for name in selected:
+            lo_default, hi_default = PARAMS.get(name, (0.0, 1.0))
+            lo_id = f"min_{name}"
+            hi_id = f"max_{name}"
+
+            # Use input[...]() and guard with "in input"
+            lo_val = input[lo_id]() if lo_id in input else lo_default
+            hi_val = input[hi_id]() if hi_id in input else hi_default
+
+            out[name] = (float(lo_val), float(hi_val))
+        return out
+
+
+
+    # Table of current bounds
+    @output
+    @render.data_frame
+    def bounds_table():
+        b = _read_bounds_dict()
+        if not b:
+            return pd.DataFrame(columns=["parameter", "lower", "upper"])
+        rows = [{"parameter": k, "lower": v[0], "upper": v[1]} for k, v in b.items()]
+        return pd.DataFrame(rows)
+
+    # JSON-ish view (string) you can parse/use elsewhere
+    @output
+    @render.text
+    def bounds_json():
+        b = _read_bounds_dict()
+        if not b:
+            return "{}"
+        # Pretty-print as Python dict literal for quick copy/paste
+        lines = ["{"]
+        for k, (lo, hi) in b.items():
+            lines.append(f"  '{k}': ({lo}, {hi}),")
+        lines.append("}")
+        return "\n".join(lines)
+
+app = App(app_ui, server)
+
+

pycompound/spec_lib_matching.py

@@ -9,6 +9,139 @@ from itertools import product
 from joblib import Parallel, delayed
 import csv
 import sys, csv
+from scipy.optimize import differential_evolution
+
+
+def _vector_to_full_params(X, default_params, optimize_params):
+    params = default_params.copy()
+    for name, val in zip(optimize_params, X):
+        params[name] = float(val)
+    return params
+
+
+def objective_function_HRMS(X, ctx):
+    p = _vector_to_full_params(X, ctx["default_params"], ctx["optimize_params"])
+    if 'window_size_centroiding' in ctx.keys():
+        acc = get_acc_HRMS(
+            ctx["df_query"], ctx["df_reference"],
+            ctx["unique_query_ids"], ctx["unique_reference_ids"],
+            ctx["similarity_measure"], ctx["weights"], ctx["spectrum_preprocessing_order"],
+            ctx["mz_min"], ctx["mz_max"], ctx["int_min"], ctx["int_max"],
+            p["window_size_centroiding"], p["window_size_matching"], p["noise_threshold"],
+            p["wf_mz"], p["wf_int"], p["LET_threshold"],
+            p["entropy_dimension"],
+            ctx["high_quality_reference_library"],
+            verbose=False
+        )
+    else:
+        acc = get_acc_NRMS(
+            ctx["df_query"], ctx["df_reference"],
+            ctx["unique_query_ids"], ctx["unique_reference_ids"],
+            ctx["similarity_measure"], ctx["weights"], ctx["spectrum_preprocessing_order"],
+            ctx["mz_min"], ctx["mz_max"], ctx["int_min"], ctx["int_max"],
+            p["noise_threshold"],
+            p["wf_mz"], p["wf_int"], p["LET_threshold"],
+            p["entropy_dimension"],
+            ctx["high_quality_reference_library"],
+            verbose=False
+        )
+    print(f"\nparams({ctx['optimize_params']}) = {np.array(X)}\naccuracy: {acc*100}%")
+    return 1.0 - acc
+
+
+
+
+def tune_params_DE(query_data=None, reference_data=None, similarity_measure='cosine', weights=None, spectrum_preprocessing_order='CNMWL', mz_min=0, mz_max=999999999, int_min=0, int_max=999999999, high_quality_reference_library=False, optimize_params=["window_size_centroiding","window_size_matching","noise_threshold","wf_mz","wf_int","LET_threshold","entropy_dimension"], param_bounds={"window_size_centroiding":(0.0,0.5),"window_size_matching":(0.0,0.5),"noise_threshold":(0.0,0.25),"wf_mz":(0.0,5.0),"wf_int":(0.0,5.0),"LET_threshold":(0.0,5.0),"entropy_dimension":(1.0,3.0)}, default_params={"window_size_centroiding": 0.5, "window_size_matching":0.5, "noise_threshold":0.10, "wf_mz":0.0, "wf_int":1.0, "LET_threshold":0.0, "entropy_dimension":1.1}):
+
+    '''
+    print('<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<')
+    print(param_bounds)
+    print(default_params)
+    print(type(param_bounds['noise_threshold'][0]))
+    print(type(param_bounds['noise_threshold'][1]))
+    print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
+    '''
+
+    if query_data is None:
+        print('\nError: No argument passed to the mandatory query_data. Please pass the path to the TXT file of the query data.')
+        sys.exit()
+    else:
+        extension = query_data.rsplit('.',1)
+        extension = extension[(len(extension)-1)]
+        if extension == 'mgf' or extension == 'MGF' or extension == 'mzML' or extension == 'mzml' or extension == 'MZML' or extension == 'cdf' or extension == 'CDF':
+            output_path_tmp = query_data[:-3] + 'csv'
+            build_library_from_raw_data(input_path=query_data, output_path=output_path_tmp, is_reference=False)
+            df_query = pd.read_csv(output_path_tmp)
+        if extension == 'csv' or extension == 'CSV':
+            df_query = pd.read_csv(query_data)
+        unique_query_ids = df_query.iloc[:,0].unique()
+
+    if reference_data is None:
+        print('\nError: No argument passed to the mandatory reference_data. Please pass the path to the CSV file of the reference data.')
+        sys.exit()
+    else:
+        if isinstance(reference_data,str):
+            df_reference = get_reference_df(reference_data=reference_data)
+            unique_reference_ids = df_reference.iloc[:,0].unique()
+        else:
+            dfs = []
+            unique_reference_ids = []
+            for f in reference_data:
+                tmp = get_reference_df(reference_data=f)
+                dfs.append(tmp)
+                unique_reference_ids.extend(tmp.iloc[:,0].unique())
+            df_reference = pd.concat(dfs, axis=0, ignore_index=True)
+
+    unique_query_ids = df_query['id'].unique().tolist()
+    unique_reference_ids = df_reference['id'].unique().tolist()
+
+    ctx = dict(
+        df_query=df_query,
+        df_reference=df_reference,
+        unique_query_ids=unique_query_ids,
+        unique_reference_ids=unique_reference_ids,
+        similarity_measure=similarity_measure,
+        weights=weights,
+        spectrum_preprocessing_order=spectrum_preprocessing_order,
+        mz_min=mz_min, mz_max=mz_max, int_min=int_min, int_max=int_max,
+        high_quality_reference_library=high_quality_reference_library,
+        default_params=default_params,
+        optimize_params=optimize_params,
+    )
+
+    bounds = [param_bounds[p] for p in optimize_params]
+
+    #print('<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<')
+    #print(df_query.head())
+    #print(df_reference.head())
+    #print(bounds)
+    #print(ctx)
+    #print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
+
+    result = differential_evolution(
+        objective_function_HRMS,
+        bounds=bounds,
+        args=(ctx,),
+        maxiter=3,
+        tol=0.0,
+        workers=-1,
+        seed=1,
+    )
+
+    best_full_params = _vector_to_full_params(result.x, default_params, optimize_params)
+    best_acc = 100.0 - (result.fun * 100.0)
+
+    print("\n=== Differential Evolution Result ===")
+    print(f"Optimized over: {optimize_params}")
+    print("Best values (selected params):")
+    for name in optimize_params:
+        print(f"  {name}: {best_full_params[name]}")
+    print("\nFull parameter set used in final evaluation:")
+    for k, v in best_full_params.items():
+        print(f"  {k}: {v}")
+    print(f"\nBest accuracy: {best_acc:.3f}%")
+
+
 
 
 default_HRMS_grid = {'similarity_measure':['cosine'], 'weight':[{'Cosine':0.25,'Shannon':0.25,'Renyi':0.25,'Tsallis':0.25}], 'spectrum_preprocessing_order':['FCNMWL'], 'mz_min':[0], 'mz_max':[9999999], 'int_min':[0], 'int_max':[99999999], 'window_size_centroiding':[0.5], 'window_size_matching':[0.5], 'noise_threshold':[0.0], 'wf_mz':[0.0], 'wf_int':[1.0], 'LET_threshold':[0.0], 'entropy_dimension':[1.1], 'high_quality_reference_library':[False]}
@@ -37,6 +170,7 @@ def _eval_one_HRMS(df_query, df_reference, unique_query_ids, unique_reference_id
         LET_threshold=LET_threshold_tmp,
         entropy_dimension=entropy_dimension_tmp,
         high_quality_reference_library=high_quality_reference_library_tmp,
+        verbose=True
     )
 
     return (
@@ -77,7 +211,7 @@ def _eval_one_NRMS(df_query, df_reference, unique_query_ids, unique_reference_id
 
 
 
-def tune_params_on_HRMS_data(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
+def tune_params_on_HRMS_data_grid(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
     """
     runs spectral library matching on high-resolution mass spectrometry (HRMS) data with all possible combinations of parameters in the grid dict, saves results from each choice of parameters to a TXT file, and prints top-performing parameters
 
@@ -153,7 +287,7 @@ def tune_params_on_HRMS_data(query_data=None, reference_data=None, grid=None, ou
 
 
 
-def tune_params_on_HRMS_data_shiny(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
+def tune_params_on_HRMS_data_grid_shiny(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
     """
     runs spectral library matching on high-resolution mass spectrometry (HRMS) data with all possible 
     combinations of parameters in the grid dict, saves results from each choice of parameters to a TXT file, 
@@ -261,7 +395,7 @@ def tune_params_on_HRMS_data_shiny(query_data=None, reference_data=None, grid=No
         print(f'Wrote results to {output_path}')
 
 
-def tune_params_on_NRMS_data(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
+def tune_params_on_NRMS_data_grid(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
     """
     runs spectral library matching on nominal-resolution mass spectrometry (NRMS) data with all possible combinations of parameters in the grid dict, saves results from each choice of parameters to a TXT file, and prints top-performing parameters
 
@@ -335,7 +469,7 @@ def tune_params_on_NRMS_data(query_data=None, reference_data=None, grid=None, ou
 
 
 
-def tune_params_on_NRMS_data_shiny(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
+def tune_params_on_NRMS_data_grid_shiny(query_data=None, reference_data=None, grid=None, output_path=None, return_output=False):
     """
     runs spectral library matching on nominal-resolution mass spectrometry (NRMS) data with all possible 
     combinations of parameters in the grid dict, saves results from each choice of parameters to a TXT file, 
@@ -441,21 +575,26 @@ def tune_params_on_NRMS_data_shiny(query_data=None, reference_data=None, grid=No
 
 
 
-def get_acc_HRMS(df_query, df_reference, unique_query_ids, unique_reference_ids, similarity_measure, weights, spectrum_preprocessing_order, mz_min, mz_max, int_min, int_max, window_size_centroiding, window_size_matching, noise_threshold, wf_mz, wf_int, LET_threshold, entropy_dimension, high_quality_reference_library):
+def get_acc_HRMS(df_query, df_reference, unique_query_ids, unique_reference_ids, similarity_measure, weights, spectrum_preprocessing_order, mz_min, mz_max, int_min, int_max, window_size_centroiding, window_size_matching, noise_threshold, wf_mz, wf_int, LET_threshold, entropy_dimension, high_quality_reference_library, verbose=True):
 
+    #print('\n\n\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n\n')
     n_top_matches_to_save = 1
 
     all_similarity_scores =  []
     for query_idx in range(0,len(unique_query_ids)):
-        print(f'query spectrum #{query_idx} is being identified')
+        if verbose is True:
+            print(f'query spectrum #{query_idx} is being identified')
         q_idxs_tmp = np.where(df_query.iloc[:,0] == unique_query_ids[query_idx])[0]
         q_spec_tmp = np.asarray(pd.concat([df_query.iloc[q_idxs_tmp,1], df_query.iloc[q_idxs_tmp,2]], axis=1).reset_index(drop=True))
+        #q_spec_tmp = q_spec_tmp.astype(float)
 
         similarity_scores = []
         for ref_idx in range(0,len(unique_reference_ids)):
             q_spec = q_spec_tmp
             r_idxs_tmp = np.where(df_reference.iloc[:,0] == unique_reference_ids[ref_idx])[0]
             r_spec = np.asarray(pd.concat([df_reference.iloc[r_idxs_tmp,1], df_reference.iloc[r_idxs_tmp,2]], axis=1).reset_index(drop=True))
+            #print(r_spec)
+            #r_spec = r_spec.astype(float)
 
             is_matched = False
             for transformation in spectrum_preprocessing_order:
@@ -529,7 +668,7 @@ def get_acc_HRMS(df_query, df_reference, unique_query_ids, unique_reference_ids,
 
 
 
-def get_acc_NRMS(df_query, df_reference, unique_query_ids, unique_reference_ids, similarity_measure, weights, spectrum_preprocessing_order, mz_min, mz_max, int_min, int_max, noise_threshold, wf_mz, wf_int, LET_threshold, entropy_dimension, high_quality_reference_library):
+def get_acc_NRMS(df_query, df_reference, unique_query_ids, unique_reference_ids, similarity_measure, weights, spectrum_preprocessing_order, mz_min, mz_max, int_min, int_max, noise_threshold, wf_mz, wf_int, LET_threshold, entropy_dimension, high_quality_reference_library, verbose=True):
 
     n_top_matches_to_save = 1
 
@@ -546,7 +685,7 @@ def get_acc_NRMS(df_query, df_reference, unique_query_ids, unique_reference_ids,
         similarity_scores = []
         for ref_idx in range(0,len(unique_reference_ids)):
             q_spec = q_spec_tmp
-            if ref_idx % 1000 == 0:
+            if verbose is True and ref_idx % 1000 == 0:
                 print(f'Query spectrum #{query_idx} has had its similarity with {ref_idx} reference library spectra computed')
             r_idxs_tmp = np.where(df_reference.iloc[:,0] == unique_reference_ids[ref_idx])[0]
             r_spec_tmp = np.asarray(pd.concat([df_reference.iloc[r_idxs_tmp,1], df_reference.iloc[r_idxs_tmp,2]], axis=1).reset_index(drop=True))
@@ -615,7 +754,7 @@ def get_acc_NRMS(df_query, df_reference, unique_query_ids, unique_reference_ids,
 
 
 
-def run_spec_lib_matching_on_HRMS_data(query_data=None, reference_data=None, likely_reference_ids=None, similarity_measure='cosine', weights={'Cosine':0.25,'Shannon':0.25,'Renyi':0.25,'Tsallis':0.25}, spectrum_preprocessing_order='FCNMWL', high_quality_reference_library=False, mz_min=0, mz_max=9999999, int_min=0, int_max=9999999, window_size_centroiding=0.5, window_size_matching=0.5, noise_threshold=0.0, wf_mz=0.0, wf_intensity=1.0, LET_threshold=0.0, entropy_dimension=1.1, n_top_matches_to_save=1, print_id_results=False, output_identification=None, output_similarity_scores=None, return_ID_output=False):
+def run_spec_lib_matching_on_HRMS_data(query_data=None, reference_data=None, likely_reference_ids=None, similarity_measure='cosine', weights={'Cosine':0.25,'Shannon':0.25,'Renyi':0.25,'Tsallis':0.25}, spectrum_preprocessing_order='FCNMWL', high_quality_reference_library=False, mz_min=0, mz_max=9999999, int_min=0, int_max=9999999, window_size_centroiding=0.5, window_size_matching=0.5, noise_threshold=0.0, wf_mz=0.0, wf_intensity=1.0, LET_threshold=0.0, entropy_dimension=1.1, n_top_matches_to_save=1, print_id_results=False, output_identification=None, output_similarity_scores=None, return_ID_output=False, verbose=True):
     '''
     runs spectral library matching on high-resolution mass spectrometry (HRMS) data
 
@@ -762,14 +901,13 @@ def run_spec_lib_matching_on_HRMS_data(query_data=None, reference_data=None, lik
 
     all_similarity_scores =  []
     for query_idx in range(0,len(unique_query_ids)):
-        print(f'query spectrum #{query_idx} is being identified')
+        if verbose is True:
+            print(f'query spectrum #{query_idx} is being identified')
         q_idxs_tmp = np.where(df_query.iloc[:,0] == unique_query_ids[query_idx])[0]
         q_spec_tmp = np.asarray(pd.concat([df_query.iloc[q_idxs_tmp,1], df_query.iloc[q_idxs_tmp,2]], axis=1).reset_index(drop=True))
 
         similarity_scores = []
         for ref_idx in range(0,len(unique_reference_ids)):
-            #if ref_idx % 100 == 0:
-            #    print(f'Query spectrum #{query_idx} has had its similarity with {ref_idx} reference library spectra computed')
             q_spec = q_spec_tmp
             r_idxs_tmp = np.where(df_reference.iloc[:,0] == unique_reference_ids[ref_idx])[0]
             r_spec = np.asarray(pd.concat([df_reference.iloc[r_idxs_tmp,1], df_reference.iloc[r_idxs_tmp,2]], axis=1).reset_index(drop=True))
@@ -1008,9 +1146,9 @@ def run_spec_lib_matching_on_NRMS_data(query_data=None, reference_data=None, lik
 
         similarity_scores = []
         for ref_idx in range(0,len(unique_reference_ids)):
-            q_spec = q_spec_tmp
-            if ref_idx % 1000 == 0:
+            if verbose is True and ref_idx % 1000 == 0:
                 print(f'Query spectrum #{query_idx} has had its similarity with {ref_idx} reference library spectra computed')
+            q_spec = q_spec_tmp
             r_idxs_tmp = np.where(df_reference.iloc[:,0] == unique_reference_ids[ref_idx])[0]
             r_spec_tmp = np.asarray(pd.concat([df_reference.iloc[r_idxs_tmp,1], df_reference.iloc[r_idxs_tmp,2]], axis=1).reset_index(drop=True))
             r_spec = convert_spec(r_spec_tmp,mzs)

pycompound/tuning_CLI_DE.py

@@ -0,0 +1,233 @@
+
+#!/usr/bin/env python3
+import argparse
+import sys
+import json
+from pathlib import Path
+from typing import Dict, List, Tuple
+import numpy as np
+import pandas as pd
+from scipy.optimize import differential_evolution
+from pycompound.spec_lib_matching import get_acc_HRMS, get_acc_NRMS
+
+
+ALL_PARAMS = [
+    "window_size_centroiding",
+    "window_size_matching",
+    "noise_threshold",
+    "wf_mz",
+    "wf_int",
+    "LET_threshold",
+    "entropy_dimension"
+]
+
+SUGGESTED_BOUNDS = {
+    "window_size_centroiding": (0.0, 0.5),
+    "window_size_matching":    (0.0, 0.5),
+    "noise_threshold":         (0.0, 0.25),
+    "wf_mz":                   (0.0, 5.0),
+    "wf_int":                  (0.0, 5.0),
+    "LET_threshold":           (0.0, 5.0),
+    "entropy_dimension":       (1.0, 3.0)
+}
+
+DEFAULT_PARAMS = {
+    "window_size_centroiding": 0.5,
+    "window_size_matching":    0.5,
+    "noise_threshold":         0.10,
+    "wf_mz":                   0.0,
+    "wf_int":                  1.0,
+    "LET_threshold":           0.0,
+    "entropy_dimension":       1.1
+}
+
+
+# ---------- Utilities ----------
+def parse_bound(s: str) -> Tuple[str, Tuple[float, float]]:
+    # "name=min:max" → (name, (min, max))
+    if "=" not in s or ":" not in s:
+        raise argparse.ArgumentTypeError(f"Bad --bound format '{s}'. Use name=min:max")
+    name, rng = s.split("=", 1)
+    lo, hi = rng.split(":", 1)
+    try:
+        lo_f, hi_f = float(lo), float(hi)
+    except ValueError as e:
+        raise argparse.ArgumentTypeError(f"Non-numeric bound in '{s}': {e}")
+    if lo_f > hi_f:
+        raise argparse.ArgumentTypeError(f"Lower bound > upper bound in '{s}'")
+    return name.strip(), (lo_f, hi_f)
+
+
+def parse_default(s: str) -> Tuple[str, float]:
+    # "name=value" → (name, value)
+    if "=" not in s:
+        raise argparse.ArgumentTypeError(f"Bad --default format '{s}'. Use name=value")
+    name, val = s.split("=", 1)
+    try:
+        v = float(val)
+    except ValueError as e:
+        raise argparse.ArgumentTypeError(f"Non-numeric default in '{s}': {e}")
+    return name.strip(), v
+
+
+def _vector_to_full_params(X: np.ndarray, default_params: Dict[str, float], optimize_params: List[str]) -> Dict[str, float]:
+    params = dict(default_params)
+    for name, val in zip(optimize_params, X):
+        params[name] = float(val)
+    return params
+
+
+# ---------- Objective wrappers (top-level, pickle-friendly) ----------
+def objective_HRMS(X: np.ndarray, ctx: dict) -> float:
+    p = _vector_to_full_params(X, ctx["default_params"], ctx["optimize_params"])
+    acc = get_acc_HRMS(
+        ctx["df_query"], ctx["df_reference"],
+        ctx["uq"], ctx["ur"],
+        ctx["similarity_measure"], ctx["weights"], ctx["spectrum_preprocessing_order"],
+        ctx["mz_min"], ctx["mz_max"], ctx["int_min"], ctx["int_max"],
+        p["window_size_centroiding"], p["window_size_matching"], p["noise_threshold"],
+        p["wf_mz"], p["wf_int"], p["LET_threshold"],
+        p["entropy_dimension"],
+        ctx["high_quality_reference_library"],
+        verbose=False
+    )
+    print(f"\n{ctx['optimize_params']} = {np.array(X)}\naccuracy: {acc*100}%")
+    return 1.0 - acc
+
+
+def objective_NRMS(X: np.ndarray, ctx: dict) -> float:
+    p = _vector_to_full_params(X, ctx["default_params"], ctx["optimize_params"])
+    acc = get_acc_NRMS(
+        ctx["df_query"], ctx["df_reference"],
+        ctx["uq"], ctx["ur"],
+        ctx["similarity_measure"], ctx["weights"], ctx["spectrum_preprocessing_order"],
+        ctx["mz_min"], ctx["mz_max"], ctx["int_min"], ctx["int_max"],
+        p["noise_threshold"], p["wf_mz"], p["wf_int"], p["LET_threshold"], p["entropy_dimension"],
+        ctx["high_quality_reference_library"],
+        verbose=False
+    )
+    print(f"\n{ctx['optimize_params']} = {np.array(X)}\naccuracy: {acc*100}%")
+    return 1.0 - acc
+
+
+# ---------- Main CLI ----------
+def main():
+    p = argparse.ArgumentParser(
+        description="Parameter tuning via Differential Evolution for HRMS/NRMS using pycompound."
+    )
+    p.add_argument("--chromatography_platform", choices=["HRMS", "NRMS"], default="HRMS", help="Chromatography Platform.")
+    p.add_argument("--query_data", required=True, help="Path to query CSV (must contain 'id' column).")
+    p.add_argument("--reference_data", required=True, nargs="+", help="Path(s) to reference CSV(s) (must contain 'id').")
+    p.add_argument("--similarity_measure", default="cosine", choices=["cosine", "renyi", "tsallis"], help="Similarity measure.")
+    p.add_argument("--weights", default="", help="Weights spec; empty means None.")
+    p.add_argument("--spectrum-order", default="CNMWL", help="Spectrum preprocessing order string.")
+    p.add_argument("--mz-min", type=float, default=0.0)
+    p.add_argument("--mz-max", type=float, default=999_999_999.0)
+    p.add_argument("--int-min", type=float, default=0.0)
+    p.add_argument("--int-max", type=float, default=999_999_999.0)
+    p.add_argument("--hq-ref-lib", action="store_true", help="Use high-quality reference library flag.")
+    p.add_argument("--opt", nargs="+", default=["window_size_centroiding", "noise_threshold", "wf_mz", "wf_int"],
+                   help=f"Parameters to optimize (subset of {ALL_PARAMS}).")
+    p.add_argument("--bound", action="append", default=[], type=parse_bound,
+                   help="Bound spec 'name=min:max'. Repeatable.")
+    p.add_argument("--default", dest="defaults", action="append", default=[], type=parse_default,
+                   help="Override a default 'name=value' for non-optimized params or initial values.")
+    p.add_argument("--maxiter", type=int, default=15)
+    p.add_argument("--seed", type=int, default=1)
+    p.add_argument("--workers", type=int, default=-1, help="Use -1 for all cores; 1 to disable parallelism.")
+    args = p.parse_args()
+
+    unknown = [x for x in args.opt if x not in ALL_PARAMS]
+    if unknown:
+        sys.exit(f"Error: unknown --opt params: {unknown}")
+
+    qpath = Path(args.query_data)
+    if not qpath.exists():
+        sys.exit(f"Query CSV not found: {qpath}")
+
+    df_query = pd.read_csv(qpath)
+    if "id" not in df_query.columns:
+        sys.exit("Query CSV must contain an 'id' column.")
+
+    ref_paths = [Path(pth) for pth in args.reference_data]
+    for r in ref_paths:
+        if not r.exists():
+            sys.exit(f"Reference CSV not found: {r}")
+    df_reference = pd.concat([pd.read_csv(r) for r in ref_paths], axis=0, ignore_index=True)
+    if "id" not in df_reference.columns:
+        sys.exit("Reference CSV must contain an 'id' column.")
+
+    uq = df_query["id"].unique().tolist()
+    ur = df_reference["id"].unique().tolist()
+
+    default_params = dict(DEFAULT_PARAMS)
+    for name, val in args.defaults:
+        if name not in DEFAULT_PARAMS:
+            sys.exit(f"--default refers to unknown parameter '{name}'. Allowed: {list(DEFAULT_PARAMS)}")
+        default_params[name] = val
+
+    param_bounds: Dict[str, Tuple[float, float]] = dict(SUGGESTED_BOUNDS)
+    for name, (lo, hi) in args.bound:
+        if name not in SUGGESTED_BOUNDS:
+            sys.exit(f"--bound refers to unknown parameter '{name}'. Allowed: {list(SUGGESTED_BOUNDS)}")
+        param_bounds[name] = (lo, hi)
+
+    bounds = [param_bounds[p] for p in args.opt]
+
+    ctx = dict(
+        df_query=df_query,
+        df_reference=df_reference,
+        uq=uq,
+        ur=ur,
+        similarity_measure=args.similarity_measure,
+        weights=(None if args.weights.strip() == "" else args.weights),
+        spectrum_preprocessing_order=args.spectrum_order,
+        mz_min=float(args.mz_min),
+        mz_max=float(args.mz_max),
+        int_min=float(args.int_min),
+        int_max=float(args.int_max),
+        high_quality_reference_library=bool(args.hq_ref_lib),
+        default_params=default_params,
+        optimize_params=args.opt,
+    )
+
+    history_acc: List[float] = []
+
+    def _cb(xk, convergence):
+        if args.chromatography_platform == "HRMS":
+            acc_pct = (1.0 - objective_HRMS(xk, ctx)) * 100.0
+        else:
+            acc_pct = (1.0 - objective_NRMS(xk, ctx)) * 100.0
+        history_acc.append(acc_pct)
+
+    objective = objective_HRMS if args.chromatography_platform == "HRMS" else objective_NRMS
+
+    result = differential_evolution(
+        objective,
+        bounds=bounds,
+        args=(ctx,),
+        maxiter=int(args.maxiter),
+        tol=0.0,
+        seed=int(args.seed),
+        workers=int(args.workers),
+        callback=_cb,
+    )
+
+    best_params = _vector_to_full_params(result.x, default_params, args.opt)
+    best_acc_pct = (1.0 - result.fun) * 100.0
+
+    print("\n=== Differential Evolution Result ===")
+    print(f"Mode: {args.chromatography_platform}")
+    print(f"Optimized over: {args.opt}")
+    print("Best values (selected params):")
+    for name in args.opt:
+        print(f"  {name}: {best_params[name]}")
+    print("\nFull parameter set used in final evaluation:")
+    for k in ALL_PARAMS:
+        print(f"  {k}: {best_params[k]}")
+    print(f"\nBest accuracy: {best_acc_pct:.3f}%")
+    print(f"DE raw: success={result.success}, nfev={result.nfev}, nit={result.nit}, message='{result.message}'")
+
+if __name__ == "__main__":
+    main()
+

pycompound/{tuning_CLI.py → tuning_CLI_grid.py}

@@ -1,6 +1,6 @@
 
-from pycompound.spec_lib_matching import tune_params_on_HRMS_data
-from pycompound.spec_lib_matching import tune_params_on_NRMS_data
+from pycompound.spec_lib_matching import tune_params_on_HRMS_data_grid
+from pycompound.spec_lib_matching import tune_params_on_NRMS_data_grid
 import argparse
 import json
 from pathlib import Path
@@ -61,9 +61,9 @@ grid['entropy_dimension'] = [float(x) for x in grid['entropy_dimension']]
 
 
 if args.chromatography_platform == 'HRMS':
-    tune_params_on_HRMS_data(query_data=args.query_data, reference_data=args.reference_data, grid=grid, output_path=args.output_path)
+    tune_params_on_HRMS_data_grid(query_data=args.query_data, reference_data=args.reference_data, grid=grid, output_path=args.output_path)
 
 if args.chromatography_platform == 'NRMS':
-    tune_params_on_NRMS_data(query_data=args.query_data, reference_data=args.reference_data, grid=grid, output_path=args.output_path)
+    tune_params_on_NRMS_data_grid(query_data=args.query_data, reference_data=args.reference_data, grid=grid, output_path=args.output_path)
 
 

{pycompound-0.1.3.dist-info → pycompound-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycompound
-Version: 0.1.3
+Version: 0.1.5
 Summary: Python package to perform compound identification in mass spectrometry via spectral library matching.
 Author-email: Hunter Dlugas <fy7392@wayne.edu>
 License-Expression: MIT

pycompound-0.1.5.dist-info/RECORD

@@ -0,0 +1,16 @@
+app.py,sha256=GdKSi0aRstcIeQulLMxANTwhScVJDNR4HlHC4bkUhXg,62350
+app2.py,sha256=ZTmShHRlv27_HhSzCj8JOVAPv5LLsjtgEkxt1c-7r6I,2950
+pycompound/build_library.py,sha256=sXG5MTJnPE7Gr8YMlLWjfMS7JQrW32lCeCGDw-DFe38,4826
+pycompound/plot_spectra.py,sha256=_yeHooNoJHYlTajaZ9hgUudisdWVlw1Zw1wJfV3tpqc,40632
+pycompound/plot_spectra_CLI.py,sha256=ObaLad5Z5DmfQB-j0HSCg1mLORbYj2BM3hb5Yd0ZdDI,8395
+pycompound/processing.py,sha256=q629rcDaMQMgef-4SbeV9cJnuiLXg97VT2F5AIsyqgI,10654
+pycompound/similarity_measures.py,sha256=NbeVIy9DE_KWlDMXXylekjKuYVrtzbeEXbTutKFxmfU,10460
+pycompound/spec_lib_matching.py,sha256=-4WNGUPqkAZwfrrmhdi7S3PcV-6d3O6nCe-efAtTzZA,73346
+pycompound/spec_lib_matching_CLI.py,sha256=qiekC52FP6ET_3NYvxUDN7km7y1OLUsd9FB4SHfne_Y,9690
+pycompound/tuning_CLI_DE.py,sha256=PXy95LD_jmVeWdgiMlMwEZU_KqPGqDao1skwe5U4Sfc,9147
+pycompound/tuning_CLI_grid.py,sha256=0XU-4ShZiZ2MQy5d0zydH0hphqXvqGtf4etl-ePNarU,8560
+pycompound-0.1.5.dist-info/licenses/LICENSE,sha256=fPFFlkSGg60VQWyWqTSv8yoJnpLzppzdihVWY5NKom8,1064
+pycompound-0.1.5.dist-info/METADATA,sha256=DIz-j3Hh4tXJMjXS-Epg_fy0auOcwYx2UUUWk3MyGN4,1732
+pycompound-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pycompound-0.1.5.dist-info/top_level.txt,sha256=cd0cQe1lhTXW9uwTTM5kZgjscKvRQV8XQ41qOwedgHU,20
+pycompound-0.1.5.dist-info/RECORD,,

{pycompound-0.1.3.dist-info → pycompound-0.1.5.dist-info}/top_level.txt

@@ -1,2 +1,3 @@
 app
+app2
 pycompound

pycompound-0.1.3.dist-info/RECORD

@@ -1,14 +0,0 @@
-app.py,sha256=JA2D6hMTqkvDWgpI7ZAhlyl7vhnSfZPQfI8HBgrJWW0,50781
-pycompound/build_library.py,sha256=sXG5MTJnPE7Gr8YMlLWjfMS7JQrW32lCeCGDw-DFe38,4826
-pycompound/plot_spectra.py,sha256=_yeHooNoJHYlTajaZ9hgUudisdWVlw1Zw1wJfV3tpqc,40632
-pycompound/plot_spectra_CLI.py,sha256=ObaLad5Z5DmfQB-j0HSCg1mLORbYj2BM3hb5Yd0ZdDI,8395
-pycompound/processing.py,sha256=q629rcDaMQMgef-4SbeV9cJnuiLXg97VT2F5AIsyqgI,10654
-pycompound/similarity_measures.py,sha256=NbeVIy9DE_KWlDMXXylekjKuYVrtzbeEXbTutKFxmfU,10460
-pycompound/spec_lib_matching.py,sha256=hEMUD5rAuEfvX1PnDEwilXIWVubnvgDBp-EVwVHu9ro,67141
-pycompound/spec_lib_matching_CLI.py,sha256=qiekC52FP6ET_3NYvxUDN7km7y1OLUsd9FB4SHfne_Y,9690
-pycompound/tuning_CLI.py,sha256=8gdT4EhIpvLHG3PcYtQBmUiPE9fJybwr3LCCilX-EfE,8540
-pycompound-0.1.3.dist-info/licenses/LICENSE,sha256=fPFFlkSGg60VQWyWqTSv8yoJnpLzppzdihVWY5NKom8,1064
-pycompound-0.1.3.dist-info/METADATA,sha256=AzTZQSX5eQZ--_7Bh-UAgAV0mQ3IgQQPoW8aOhkIwNA,1732
-pycompound-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pycompound-0.1.3.dist-info/top_level.txt,sha256=wFBLVrqpC07HghIU8tsEdgdvgkdOE3GN_1Gfjk-uEUc,15
-pycompound-0.1.3.dist-info/RECORD,,