pycompound 0.1.4__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
@@ -394,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):"),
@@ -435,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":
@@ -465,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
         ),
@@ -473,12 +474,117 @@ def run_parameter_tuning_ui(platform: str):
 
 
 
-'''
-app_ui = ui.page_fluid(
-    ui.output_ui("main_ui"),
-    ui.output_text("status_output")
-)
-'''
+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")),
@@ -498,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)
@@ -519,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("")
@@ -551,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)
 
 
@@ -563,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
@@ -573,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()
 
 
@@ -601,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)
@@ -680,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())
@@ -726,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"
@@ -777,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())
 
 
 
@@ -1020,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()
 
@@ -1044,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,
         )
 
@@ -1072,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,
@@ -1089,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)
@@ -1122,32 +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)
 
 
 
-'''
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-
-class _InjectBaseURLMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        hdrs = dict(request.scope.get("headers", []))
-        if b"rstudio-connect-app-base-url" not in hdrs:
-            host = request.headers.get("x-forwarded-host") or request.headers.get("host") or ""
-            proto = request.headers.get("x-forwarded-proto") or "https"
-            root_path = (request.scope.get("root_path") or "").rstrip("/")
-            base = f"{proto}://{host}{root_path}"
-            new_headers = list(request.scope.get("headers", [])) + [
-                (b"rstudio-connect-app-base-url", base.encode("utf-8"))
-            ]
-            request.scope["headers"] = new_headers
-        return await call_next(request)
-
-app.starlette_app.add_middleware(_InjectBaseURLMiddleware)
-'''
-
-

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]}
@@ -78,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
 
@@ -154,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, 
@@ -262,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
 
@@ -336,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, 
@@ -444,6 +577,7 @@ 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, verbose=True):
 
+    #print('\n\n\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n\n')
     n_top_matches_to_save = 1
 
     all_similarity_scores =  []

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycompound
-Version: 0.1.4
+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.4.dist-info → pycompound-0.1.5.dist-info}/RECORD

@@ -1,15 +1,16 @@
-app.py,sha256=e_QULBLubrZLk_huIyDvL64lFzgDRo_vaYV0MIx9VJQ,51950
+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=TBH7cZLeIWNk5XkXcN7kiBfCSe6eRkseXIPMMLB54iI,67261
+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.4.dist-info/licenses/LICENSE,sha256=fPFFlkSGg60VQWyWqTSv8yoJnpLzppzdihVWY5NKom8,1064
-pycompound-0.1.4.dist-info/METADATA,sha256=qlCzW19-6MpmuGoHbmQVL9ljKRCO4JXZ55-GTyKc3_I,1732
-pycompound-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pycompound-0.1.4.dist-info/top_level.txt,sha256=wFBLVrqpC07HghIU8tsEdgdvgkdOE3GN_1Gfjk-uEUc,15
-pycompound-0.1.4.dist-info/RECORD,,
+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.4.dist-info → pycompound-0.1.5.dist-info}/top_level.txt

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