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

alchemist_core/data/experiment_manager.py

@@ -13,13 +13,15 @@ class ExperimentManager:
         self.df = pd.DataFrame()  # Raw experimental data
         self.search_space = search_space  # Reference to the search space
         self.filepath = None  # Path to saved experiment file
+        self._current_iteration = 0  # Track current iteration for audit log
         
     def set_search_space(self, search_space):
         """Set or update the search space reference."""
         self.search_space = search_space
         
     def add_experiment(self, point_dict: Dict[str, Union[float, str, int]], output_value: Optional[float] = None, 
-                       noise_value: Optional[float] = None):
+                       noise_value: Optional[float] = None, iteration: Optional[int] = None, 
+                       reason: Optional[str] = None):
         """
         Add a single experiment point.
         
@@ -27,6 +29,8 @@ class ExperimentManager:
             point_dict: Dictionary with variable names as keys and values
             output_value: The experiment output/target value (if known)
             noise_value: Optional observation noise/uncertainty value for regularization
+            iteration: Iteration number (auto-assigned if None)
+            reason: Reason for this experiment (e.g., 'Initial Design (LHS)', 'Expected Improvement')
         """
         # Create a copy of the point_dict to avoid modifying the original
         new_point = point_dict.copy()
@@ -38,6 +42,22 @@ class ExperimentManager:
         # Add noise value if provided
         if noise_value is not None:
             new_point['Noise'] = noise_value
+        
+        # Add iteration tracking
+        if iteration is not None:
+            # Use provided iteration and ensure _current_iteration reflects it
+            new_point['Iteration'] = int(iteration)
+            # Keep _current_iteration in sync with the latest explicit iteration
+            try:
+                self._current_iteration = int(iteration)
+            except Exception:
+                pass
+        else:
+            # Use current iteration (doesn't increment until lock_acquisition)
+            new_point['Iteration'] = int(self._current_iteration)
+        
+        # Add reason
+        new_point['Reason'] = reason if reason is not None else 'Manual'
             
         # Convert to DataFrame and append
         new_df = pd.DataFrame([new_point])
@@ -52,6 +72,20 @@ class ExperimentManager:
             if missing_cols:
                 raise ValueError(f"DataFrame is missing required columns: {missing_cols}")
         
+        # Ensure each row has an Iteration value; default to current iteration
+        if 'Iteration' not in data_df.columns:
+            data_df = data_df.copy()
+            data_df['Iteration'] = int(self._current_iteration)
+        else:
+            # Fill missing iterations with current iteration
+            data_df = data_df.copy()
+            data_df['Iteration'] = pd.to_numeric(data_df['Iteration'], errors='coerce').fillna(self._current_iteration).astype(int)
+            # Update _current_iteration to the max iteration present
+            if len(data_df) > 0:
+                max_iter = int(data_df['Iteration'].max())
+                if max_iter > self._current_iteration:
+                    self._current_iteration = max_iter
+
         # Append the data
         self.df = pd.concat([self.df, data_df], ignore_index=True)
     
@@ -69,8 +103,17 @@ class ExperimentManager:
         """
         if 'Output' not in self.df.columns:
             raise ValueError("DataFrame doesn't contain 'Output' column")
-            
-        X = self.df.drop(columns=['Output'] + (['Noise'] if 'Noise' in self.df.columns else []))
+        
+        # Drop metadata columns (Output, Noise, Iteration, Reason)
+        metadata_cols = ['Output']
+        if 'Noise' in self.df.columns:
+            metadata_cols.append('Noise')
+        if 'Iteration' in self.df.columns:
+            metadata_cols.append('Iteration')
+        if 'Reason' in self.df.columns:
+            metadata_cols.append('Reason')
+        
+        X = self.df.drop(columns=metadata_cols)
         y = self.df['Output']
         return X, y
     
@@ -85,8 +128,17 @@ class ExperimentManager:
         """
         if 'Output' not in self.df.columns:
             raise ValueError("DataFrame doesn't contain 'Output' column")
-            
-        X = self.df.drop(columns=['Output'] + (['Noise'] if 'Noise' in self.df.columns else []))
+        
+        # Drop metadata columns
+        metadata_cols = ['Output']
+        if 'Noise' in self.df.columns:
+            metadata_cols.append('Noise')
+        if 'Iteration' in self.df.columns:
+            metadata_cols.append('Iteration')
+        if 'Reason' in self.df.columns:
+            metadata_cols.append('Reason')
+        
+        X = self.df.drop(columns=metadata_cols)
         y = self.df['Output']
         noise = self.df['Noise'] if 'Noise' in self.df.columns else None
         return X, y, noise
@@ -129,6 +181,18 @@ class ExperimentManager:
                 print("Warning: Noise column contains non-numeric values. Converting to default noise level.")
                 self.df['Noise'] = 1e-10  # Default small noise
         
+        # Initialize iteration tracking from data
+        if 'Iteration' in self.df.columns:
+            self._current_iteration = int(self.df['Iteration'].max())
+        else:
+            # Add iteration column if missing (legacy data)
+            self.df['Iteration'] = 0
+            self._current_iteration = 0
+        
+        # Add reason column if missing (legacy data)
+        if 'Reason' not in self.df.columns:
+            self.df['Reason'] = 'Initial Design'
+        
         return self
     
     @classmethod

alchemist_core/models/botorch_model.py

@@ -485,8 +485,10 @@ class BoTorchModel(BaseModel):
                         outcome_transform=fold_outcome_transform
                     )
                 
-                # Load the trained state - this keeps the hyperparameters without retraining
-                fold_model.load_state_dict(self.fitted_state_dict, strict=False)
+                # Train the fold model from scratch (don't load state_dict to avoid dimension mismatches)
+                # This is necessary because folds may have different categorical values or data shapes
+                mll = ExactMarginalLogLikelihood(fold_model.likelihood, fold_model)
+                fit_gpytorch_mll(mll)
                 
                 # Make predictions on test fold
                 fold_model.eval()
@@ -720,8 +722,8 @@ class BoTorchModel(BaseModel):
         y_vals = torch.linspace(y_range[0], y_range[1], 100)
         X, Y = torch.meshgrid(x_vals, y_vals, indexing='ij')
         
-        # Total dimensions in the model
-        input_dim = len(self.feature_names) if self.feature_names else 4
+        # Total dimensions in the model (use original_feature_names to match actual input dimensions)
+        input_dim = len(self.original_feature_names) if self.original_feature_names else 2
         
         # Create placeholder tensors for all dimensions
         grid_tensors = []

alchemist_core/models/sklearn_model.py

@@ -85,9 +85,30 @@ class SklearnModel(BaseModel):
     def _build_kernel(self, X):
         """Build the kernel using training data X to initialize length scales."""
         kernel_type = self.kernel_options.get("kernel_type", "RBF")
-        # Compute initial length scales as the mean of the data along each dimension.
-        ls_init = np.mean(X, axis=0)
-        ls_bounds = [(1e-5, l * 1e5) for l in ls_init]
+        # Compute initial length scales from the data.
+        # Use standard deviation (positive) as a robust length-scale initializer.
+        try:
+            ls_init = np.std(X, axis=0)
+            ls_init = np.array(ls_init, dtype=float)
+            # Replace non-finite or non-positive values with sensible defaults
+            bad_mask = ~np.isfinite(ls_init) | (ls_init <= 0)
+            if np.any(bad_mask):
+                logger.debug("Replacing non-finite or non-positive length-scales with 1.0")
+                ls_init[bad_mask] = 1.0
+
+            # Build finite, positive bounds for each length-scale
+            ls_bounds = []
+            for l in ls_init:
+                # Protect against extremely small or non-finite upper bounds
+                upper = float(l * 1e5) if np.isfinite(l) else 1e5
+                if not np.isfinite(upper) or upper <= 1e-8:
+                    upper = 1e3
+                ls_bounds.append((1e-5, upper))
+        except Exception as e:
+            logger.warning(f"Failed to compute sensible length-scales from data: {e}. Using safe defaults.")
+            n_dims = X.shape[1] if hasattr(X, 'shape') else 1
+            ls_init = np.ones(n_dims, dtype=float)
+            ls_bounds = [(1e-5, 1e5) for _ in range(n_dims)]
         constant = C()
         if kernel_type == "RBF":
             kernel = constant * RBF(length_scale=ls_init, length_scale_bounds=ls_bounds)
@@ -317,12 +338,29 @@ class SklearnModel(BaseModel):
         
         # Create model with appropriate parameters
         self.model = GaussianProcessRegressor(**params)
-        
+
         # Store the raw training data for possible reuse with skopt
         self.X_train_ = X
         self.y_train_ = y
-        
-        self.model.fit(X, y)
+
+        # Fit the model, but be defensive: if sklearn complains about non-finite
+        # bounds when n_restarts_optimizer>0, retry with no restarts.
+        try:
+            self.model.fit(X, y)
+        except ValueError as e:
+            msg = str(e)
+            if 'requires that all bounds are finite' in msg or 'bounds' in msg.lower():
+                logger.warning("GaussianProcessRegressor failed due to non-finite bounds. "
+                               "Retrying without optimizer restarts (n_restarts_optimizer=0).")
+                # Retry with safer parameters
+                safe_params = params.copy()
+                safe_params['n_restarts_optimizer'] = 0
+                safe_params['optimizer'] = None
+                self.model = GaussianProcessRegressor(**safe_params)
+                self.model.fit(X, y)
+            else:
+                # Re-raise other value errors
+                raise
         self.optimized_kernel = self.model.kernel_
         self._is_trained = True