PyPI - alchemist-nrel - Versions diffs - 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl - Mend

alchemist-nrel 0.3.0py3-none-any.whl → 0.3.2py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

alchemist_core/__init__.py +2 -2
alchemist_core/acquisition/botorch_acquisition.py +84 -126
alchemist_core/data/experiment_manager.py +196 -20
alchemist_core/models/botorch_model.py +292 -63
alchemist_core/models/sklearn_model.py +175 -15
alchemist_core/session.py +3532 -76
alchemist_core/utils/__init__.py +3 -1
alchemist_core/utils/acquisition_utils.py +60 -0
alchemist_core/visualization/__init__.py +45 -0
alchemist_core/visualization/helpers.py +130 -0
alchemist_core/visualization/plots.py +1449 -0
alchemist_nrel-0.3.2.dist-info/METADATA +185 -0
{alchemist_nrel-0.3.0.dist-info → alchemist_nrel-0.3.2.dist-info}/RECORD +34 -29
{alchemist_nrel-0.3.0.dist-info → alchemist_nrel-0.3.2.dist-info}/WHEEL +1 -1
{alchemist_nrel-0.3.0.dist-info → alchemist_nrel-0.3.2.dist-info}/entry_points.txt +1 -1
{alchemist_nrel-0.3.0.dist-info → alchemist_nrel-0.3.2.dist-info}/top_level.txt +0 -1
api/example_client.py +7 -2
api/main.py +3 -2
api/models/requests.py +76 -1
api/models/responses.py +102 -2
api/routers/acquisition.py +25 -0
api/routers/experiments.py +352 -11
api/routers/sessions.py +195 -11
api/routers/visualizations.py +6 -4
api/routers/websocket.py +132 -0
run_api.py → api/run_api.py +8 -7
api/services/session_store.py +370 -71
api/static/assets/index-B6Cf6s_b.css +1 -0
api/static/assets/{index-C0_glioA.js → index-B7njvc9r.js} +223 -208
api/static/index.html +2 -2
ui/gpr_panel.py +11 -5
ui/target_column_dialog.py +299 -0
ui/ui.py +52 -5
alchemist_core/models/ax_model.py +0 -159
alchemist_nrel-0.3.0.dist-info/METADATA +0 -223
api/static/assets/index-CB4V1LI5.css +0 -1
{alchemist_nrel-0.3.0.dist-info → alchemist_nrel-0.3.2.dist-info}/licenses/LICENSE +0 -0

api/static/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/NEW_ICON.png" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>ALchemist - Active Learning Toolkit</title>
-    <script type="module" crossorigin src="/assets/index-C0_glioA.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CB4V1LI5.css">
+    <script type="module" crossorigin src="/assets/index-B7njvc9r.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B6Cf6s_b.css">
   </head>
   <body>
     <div id="root"></div>

ui/gpr_panel.py CHANGED Viewed

@@ -505,14 +505,17 @@ class GaussianProcessPanel(ctk.CTkFrame):
             print(f"  RMSE = {session_metrics.get('rmse', 'N/A'):.3f}")
             print("Learned hyperparameters:", self.main_app.learned_hyperparameters)
-            # Initialize visualizations
+            # Initialize visualization with model results
+            # Get target column name from experiment manager
+            target_col = self.main_app.experiment_manager.target_columns[0]
             self.visualizations = Visualizations(
                 parent=self,
                 search_space=self.main_app.search_space,
                 gpr_model=self.main_app.gpr_model,
                 exp_df=self.main_app.exp_df,
-                encoded_X=self.main_app.exp_df.drop(columns='Output'),
-                encoded_y=self.main_app.exp_df['Output']
+                encoded_X=self.main_app.exp_df.drop(columns=target_col),
+                encoded_y=self.main_app.exp_df[target_col]
             )
             self.visualizations.rmse_values = self.main_app.rmse_values
             self.visualizations.mae_values = self.main_app.mae_values
@@ -532,13 +535,16 @@ class GaussianProcessPanel(ctk.CTkFrame):
     # VISUALIZATIONS
     # ==========================
     def initialize_visualizations(self):
+        # Get target column name from experiment manager
+        target_col = self.main_app.experiment_manager.target_columns[0]
         self.visualizations = Visualizations(
             parent=self,
             search_space=self.main_app.search_space,
             gpr_model=self.main_app.gpr_model,
             exp_df=self.main_app.exp_df,
-            encoded_X=self.main_app.exp_df.drop(columns='Output'),
-            encoded_y=self.main_app.exp_df['Output']
+            encoded_X=self.main_app.exp_df.drop(columns=target_col),
+            encoded_y=self.main_app.exp_df[target_col]
         )
         self.visualizations.rmse_values = self.main_app.rmse_values
         self.visualizations.mae_values = self.main_app.mae_values

ui/target_column_dialog.py ADDED Viewed

@@ -0,0 +1,299 @@
+"""
+Target Column Selection Dialog
+Allows users to select which column(s) in their CSV should be treated as optimization targets.
+Supports both single-objective and multi-objective optimization.
+"""
+import customtkinter as ctk
+from typing import List, Optional, Tuple
+import tkinter as tk
+class TargetColumnDialog(ctk.CTkToplevel):
+    """
+    Dialog for selecting target columns when loading experimental data.
+    Features:
+    - Single/Multi-objective mode toggle
+    - Column selection (dropdown for single, checkboxes for multi)
+    - Validation before confirming
+    """
+    def __init__(self, parent, available_columns: List[str], default_column: str = None):
+        """
+        Initialize the target column selection dialog.
+        Args:
+            parent: Parent window
+            available_columns: List of column names available in the CSV
+            default_column: Default column to select (if it exists in available_columns)
+        """
+        super().__init__(parent)
+        self.title("Select Target Column(s)")
+        self.geometry("500x400")
+        self.resizable(False, False)
+        # Make dialog modal
+        self.transient(parent)
+        self.grab_set()
+        # Store data
+        self.available_columns = available_columns
+        self.default_column = default_column if default_column in available_columns else None
+        self.result = None  # Will store selected column(s) when confirmed
+        # UI state
+        self.mode = "single"  # "single" or "multi"
+        self.checkbox_vars = {}  # For multi-objective mode
+        self._create_ui()
+        # Center the dialog
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")
+    def _create_ui(self):
+        """Create the dialog UI elements."""
+        # Header
+        header_frame = ctk.CTkFrame(self, fg_color="transparent")
+        header_frame.pack(fill="x", padx=20, pady=(20, 10))
+        ctk.CTkLabel(
+            header_frame,
+            text="Select Target Column(s)",
+            font=ctk.CTkFont(size=16, weight="bold")
+        ).pack(anchor="w")
+        ctk.CTkLabel(
+            header_frame,
+            text="Choose which column(s) to optimize:",
+            font=ctk.CTkFont(size=12),
+            text_color="gray"
+        ).pack(anchor="w", pady=(5, 0))
+        # Mode selector (Single vs Multi-objective)
+        mode_frame = ctk.CTkFrame(self)
+        mode_frame.pack(fill="x", padx=20, pady=10)
+        ctk.CTkLabel(
+            mode_frame,
+            text="Optimization Mode:",
+            font=ctk.CTkFont(size=12, weight="bold")
+        ).pack(side="left", padx=(10, 20))
+        self.mode_var = ctk.StringVar(value="single")
+        self.single_radio = ctk.CTkRadioButton(
+            mode_frame,
+            text="Single-Objective",
+            variable=self.mode_var,
+            value="single",
+            command=self._on_mode_change
+        )
+        self.single_radio.pack(side="left", padx=10)
+        self.multi_radio = ctk.CTkRadioButton(
+            mode_frame,
+            text="Multi-Objective",
+            variable=self.mode_var,
+            value="multi",
+            command=self._on_mode_change
+        )
+        self.multi_radio.pack(side="left", padx=10)
+        # Column selection area (content changes based on mode)
+        self.selection_frame = ctk.CTkFrame(self)
+        self.selection_frame.pack(fill="both", expand=True, padx=20, pady=10)
+        self._update_selection_ui()
+        # Buttons
+        button_frame = ctk.CTkFrame(self, fg_color="transparent")
+        button_frame.pack(fill="x", padx=20, pady=(10, 20))
+        ctk.CTkButton(
+            button_frame,
+            text="Cancel",
+            command=self._on_cancel,
+            width=100
+        ).pack(side="right", padx=(10, 0))
+        ctk.CTkButton(
+            button_frame,
+            text="Confirm",
+            command=self._on_confirm,
+            width=100
+        ).pack(side="right")
+    def _on_mode_change(self):
+        """Handle mode change between single and multi-objective."""
+        self.mode = self.mode_var.get()
+        self._update_selection_ui()
+    def _update_selection_ui(self):
+        """Update the column selection UI based on current mode."""
+        # Clear existing widgets
+        for widget in self.selection_frame.winfo_children():
+            widget.destroy()
+        if self.mode == "single":
+            self._create_single_objective_ui()
+        else:
+            self._create_multi_objective_ui()
+    def _create_single_objective_ui(self):
+        """Create UI for single-objective mode (dropdown)."""
+        ctk.CTkLabel(
+            self.selection_frame,
+            text="Select target column:",
+            font=ctk.CTkFont(size=12)
+        ).pack(anchor="w", padx=20, pady=(20, 10))
+        # Dropdown menu
+        self.column_var = ctk.StringVar(value=self.default_column or self.available_columns[0])
+        self.column_dropdown = ctk.CTkOptionMenu(
+            self.selection_frame,
+            variable=self.column_var,
+            values=self.available_columns,
+            width=400
+        )
+        self.column_dropdown.pack(padx=20, pady=10)
+        # Info text
+        info_frame = ctk.CTkFrame(self.selection_frame, fg_color="transparent")
+        info_frame.pack(fill="x", padx=20, pady=(20, 10))
+        ctk.CTkLabel(
+            info_frame,
+            text="💡 Tip: This column will be maximized or minimized during optimization.",
+            font=ctk.CTkFont(size=11),
+            text_color="gray",
+            wraplength=400,
+            justify="left"
+        ).pack(anchor="w")
+    def _create_multi_objective_ui(self):
+        """Create UI for multi-objective mode (checkboxes)."""
+        ctk.CTkLabel(
+            self.selection_frame,
+            text="Select target columns (2 or more):",
+            font=ctk.CTkFont(size=12)
+        ).pack(anchor="w", padx=20, pady=(20, 10))
+        # Scrollable frame for checkboxes
+        checkbox_frame = ctk.CTkScrollableFrame(
+            self.selection_frame,
+            height=150
+        )
+        checkbox_frame.pack(fill="both", expand=True, padx=20, pady=10)
+        # Create checkboxes for each column
+        self.checkbox_vars = {}
+        for col in self.available_columns:
+            var = ctk.BooleanVar(value=False)
+            self.checkbox_vars[col] = var
+            checkbox = ctk.CTkCheckBox(
+                checkbox_frame,
+                text=col,
+                variable=var
+            )
+            checkbox.pack(anchor="w", pady=5, padx=10)
+        # Info text
+        info_frame = ctk.CTkFrame(self.selection_frame, fg_color="transparent")
+        info_frame.pack(fill="x", padx=20, pady=(10, 10))
+        ctk.CTkLabel(
+            info_frame,
+            text="💡 Tip: Multi-objective optimization finds trade-offs between objectives.",
+            font=ctk.CTkFont(size=11),
+            text_color="gray",
+            wraplength=400,
+            justify="left"
+        ).pack(anchor="w")
+    def _on_confirm(self):
+        """Handle confirm button click."""
+        if self.mode == "single":
+            # Single-objective: return selected column as string
+            selected = self.column_var.get()
+            if selected:
+                self.result = selected
+                self.destroy()
+        else:
+            # Multi-objective: return list of selected columns
+            selected = [col for col, var in self.checkbox_vars.items() if var.get()]
+            if len(selected) < 2:
+                # Show error - need at least 2 objectives
+                error_dialog = ctk.CTkToplevel(self)
+                error_dialog.title("Invalid Selection")
+                error_dialog.geometry("350x150")
+                error_dialog.transient(self)
+                error_dialog.grab_set()
+                ctk.CTkLabel(
+                    error_dialog,
+                    text="⚠️ Multi-Objective Mode",
+                    font=ctk.CTkFont(size=14, weight="bold")
+                ).pack(pady=(20, 10))
+                ctk.CTkLabel(
+                    error_dialog,
+                    text="Please select at least 2 target columns\nfor multi-objective optimization.",
+                    font=ctk.CTkFont(size=12)
+                ).pack(pady=10)
+                ctk.CTkButton(
+                    error_dialog,
+                    text="OK",
+                    command=error_dialog.destroy,
+                    width=100
+                ).pack(pady=10)
+                # Center error dialog
+                error_dialog.update_idletasks()
+                x = self.winfo_x() + (self.winfo_width() // 2) - (error_dialog.winfo_width() // 2)
+                y = self.winfo_y() + (self.winfo_height() // 2) - (error_dialog.winfo_height() // 2)
+                error_dialog.geometry(f"+{x}+{y}")
+                return
+            self.result = selected
+            self.destroy()
+    def _on_cancel(self):
+        """Handle cancel button click."""
+        self.result = None
+        self.destroy()
+    def get_result(self) -> Optional[str | List[str]]:
+        """
+        Get the user's selection.
+        Returns:
+            String for single-objective, list for multi-objective, or None if cancelled
+        """
+        return self.result
+def show_target_column_dialog(parent, available_columns: List[str],
+                              default_column: str = None) -> Optional[str | List[str]]:
+    """
+    Show target column selection dialog and return user's choice.
+    Args:
+        parent: Parent window
+        available_columns: List of column names available in the CSV
+        default_column: Default column to select (if it exists)
+    Returns:
+        Selected column(s) or None if cancelled
+    """
+    dialog = TargetColumnDialog(parent, available_columns, default_column)
+    parent.wait_window(dialog)
+    return dialog.get_result()

ui/ui.py CHANGED Viewed

@@ -519,6 +519,46 @@ class ALchemistApp(ctk.CTk):
         if file_path:
             try:
+                # First, read the CSV to check for target column
+                import pandas as pd
+                preview_df = pd.read_csv(file_path)
+                # Check if any configured target column exists
+                # Default to looking for 'Output' if no target_columns configured
+                expected_targets = getattr(self.experiment_manager, 'target_columns', ['Output'])
+                missing_targets = [col for col in expected_targets if col not in preview_df.columns]
+                # If target column(s) missing, show selection dialog
+                target_columns_to_use = None
+                if missing_targets:
+                    # Get non-metadata columns that could be targets
+                    metadata_cols = {'Iteration', 'Reason', 'Noise'}
+                    available_cols = [col for col in preview_df.columns if col not in metadata_cols]
+                    if not available_cols:
+                        raise ValueError("CSV file contains no columns that could be target columns.")
+                    # Show target selection dialog
+                    from ui.target_column_dialog import show_target_column_dialog
+                    selected = show_target_column_dialog(
+                        parent=self,
+                        available_columns=available_cols,
+                        default_column='output' if 'output' in available_cols else None
+                    )
+                    if selected is None:
+                        # User cancelled
+                        print("Data loading cancelled by user.")
+                        return
+                    target_columns_to_use = selected if isinstance(selected, list) else [selected]
+                    print(f"User selected target column(s): {target_columns_to_use}")
+                else:
+                    target_columns_to_use = expected_targets
+                # Configure experiment manager with selected target columns
+                self.experiment_manager.target_columns = target_columns_to_use
                 # Load experiments using the ExperimentManager
                 self.experiment_manager.load_from_csv(file_path)
@@ -536,6 +576,7 @@ class ALchemistApp(ctk.CTk):
                 # Log the data loading
                 print(f"Loaded {len(self.exp_df)} experiment points from {file_path}")
+                print(f"Target column(s): {target_columns_to_use}")
                 if 'Noise' in self.exp_df.columns:
                     print("Notice: Noise column detected. This will be used for model regularization if available.")
@@ -1695,8 +1736,9 @@ class ALchemistApp(ctk.CTk):
                 # Ensure metadata columns have correct types
                 exp_df_clean = self.exp_df.copy()
-                # Define metadata columns
-                metadata_cols = {'Output', 'Noise', 'Iteration', 'Reason'}
+                # Define metadata columns (including configured target columns)
+                target_cols = set(self.experiment_manager.target_columns) if hasattr(self.experiment_manager, 'target_columns') else {'Output'}
+                metadata_cols = target_cols | {'Noise', 'Iteration', 'Reason'}
                 # Ensure Iteration is numeric
                 if 'Iteration' in exp_df_clean.columns:
@@ -1706,9 +1748,10 @@ class ALchemistApp(ctk.CTk):
                 if 'Reason' in exp_df_clean.columns:
                     exp_df_clean['Reason'] = exp_df_clean['Reason'].astype(str).replace('nan', 'Manual')
-                # Ensure Output is numeric
-                if 'Output' in exp_df_clean.columns:
-                    exp_df_clean['Output'] = pd.to_numeric(exp_df_clean['Output'], errors='coerce')
+                # Ensure target columns are numeric
+                for target_col in target_cols:
+                    if target_col in exp_df_clean.columns:
+                        exp_df_clean[target_col] = pd.to_numeric(exp_df_clean[target_col], errors='coerce')
                 # Ensure Noise is numeric if present
                 if 'Noise' in exp_df_clean.columns:
@@ -1745,6 +1788,10 @@ class ALchemistApp(ctk.CTk):
                 # Copy cleaned data to session's experiment manager
                 self.session.experiment_manager.df = exp_df_clean
+                # Copy target_columns configuration to session's experiment manager
+                if hasattr(self.experiment_manager, 'target_columns'):
+                    self.session.experiment_manager.target_columns = self.experiment_manager.target_columns
                 # Update local exp_df with cleaned version
                 self.exp_df = exp_df_clean

alchemist_core/models/ax_model.py DELETED Viewed

@@ -1,159 +0,0 @@
-from ax.service.ax_client import AxClient
-from .base_model import BaseModel
-import pandas as pd
-import numpy as np
-from skopt.space import Real, Integer, Categorical
-class AxModel(BaseModel):
-    def __init__(self, search_space, experiment_name="experiment", random_state=42):
-        """
-        Initialize the AxModel.
-        Args:
-            search_space: A list of skopt.space objects (Real, Integer, or Categorical).
-            experiment_name: A name for the Ax experiment.
-            random_state: Random seed for reproducibility.
-        """
-        self.experiment_name = experiment_name
-        self.search_space = search_space
-        self.random_state = random_state
-        self.ax_client = AxClient(random_seed=random_state)
-        self.trained = False
-    def _build_parameters(self):
-        """
-        Build the Ax parameters list from the search_space.
-        """
-        parameters = []
-        for dim in self.search_space:
-            if isinstance(dim, Real):
-                # For Real dimensions, use a continuous range.
-                parameters.append({
-                    "name": dim.name,
-                    "type": "range",
-                    "bounds": list(dim.bounds),
-                    "value_type": "float",
-                })
-            elif isinstance(dim, Integer):
-                # For Integer dimensions, use a range and specify value type as int.
-                parameters.append({
-                    "name": dim.name,
-                    "type": "range",
-                    "bounds": list(dim.bounds),
-                    "value_type": "int",
-                })
-            elif isinstance(dim, Categorical):
-                # For categorical dimensions, use "choice" and list the categories.
-                # Here we assume that the categories are strings; if numeric, adjust "value_type" accordingly.
-                parameters.append({
-                    "name": dim.name,
-                    "type": "choice",
-                    "values": list(dim.categories),
-                    "value_type": "str",
-                })
-            else:
-                raise ValueError(f"Unsupported search space dimension type: {type(dim)}")
-        return parameters
-    def train(self, exp_df, **kwargs):
-        """Train the Ax model using the raw experiment DataFrame."""
-        X = exp_df.drop(columns="Output")
-        y = exp_df["Output"]
-        parameters = self._build_parameters()
-        self.ax_client.create_experiment(
-            name=self.experiment_name,
-            parameters=parameters,
-        )
-        for i, row in X.iterrows():
-            params = row.to_dict()
-            outcome = float(y.iloc[i])
-            self.ax_client.complete_trial(trial_index=i, raw_data={"objective": outcome})
-        self.trained = True
-    def predict(self, X, return_std=False, **kwargs):
-        """
-        For Ax, prediction means asking for the next candidate.
-        Args:
-            X: Not used (the next candidate is computed based on the experiment history).
-            return_std: Not applicable; always returns just the candidate.
-        Returns:
-            A dictionary with parameter names and suggested values.
-        """
-        if not self.trained:
-            raise ValueError("The Ax experiment has not been trained with past data yet.")
-        parameters, trial_index = self.ax_client.get_next_trial()
-        return parameters
-    def predict_with_std(self, X):
-        """
-        Make predictions with standard deviation.
-        Args:
-            X: Input features (DataFrame or array)
-        Returns:
-            Tuple of (predictions, standard deviations)
-        """
-        if not self.is_trained:
-            raise ValueError("Model is not trained yet")
-        # Convert to DataFrame if needed
-        if not isinstance(X, pd.DataFrame):
-            if hasattr(self, 'feature_names') and self.feature_names:
-                X = pd.DataFrame(X, columns=self.feature_names)
-            else:
-                raise ValueError("Cannot convert input to DataFrame - feature names unknown")
-        # Prepare the observations in Ax format
-        obs = []
-        for _, row in X.iterrows():
-            arm_parameters = row.to_dict()
-            obs.append(arm_parameters)
-        # Get the predictions
-        means, covariances = self.surrogate.predict(obs)
-        # Extract standard deviations from covariances
-        stds = np.sqrt(np.diag(covariances))
-        return means, stds
-    def evaluate(self, X, y, **kwargs):
-        """
-        Evaluate the Ax model's performance using stored outcomes.
-        In a more complete implementation, you could compute metrics such as RMSE across trials.
-        Returns:
-            A dictionary with evaluation metrics (here empty as a placeholder).
-        """
-        # Example: Extract and compute statistics from the experiment.
-        return {}
-    def get_hyperparameters(self):
-        """
-        Get model hyperparameters.
-        Returns:
-            A dictionary with hyperparameter names and values.
-        """
-        if not self.is_trained:
-            return {"status": "Model not trained"}
-        try:
-            params = {}
-            # For Ax models, we can extract some basic info
-            if hasattr(self, 'surrogate') and hasattr(self.surrogate, 'model'):
-                model_type = type(self.surrogate.model).__name__
-                params['model_type'] = model_type
-                # Try to get some GPEI-specific attributes if available
-                if hasattr(self.surrogate.model, 'model'):
-                    inner_model = self.surrogate.model.model
-                    if hasattr(inner_model, 'covar_module'):
-                        params['covar_module'] = str(inner_model.covar_module)
-            return params
-        except Exception as e:
-            return {"error": str(e)}

alchemist-nrel 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

alchemist-nrel 0.3.0py3-none-any.whl → 0.3.2py3-none-any.whl