alchemist-nrel 0.2.1__py3-none-any.whl → 0.3.1__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,29 @@ 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 explicitly
+            new_point['Iteration'] = int(iteration)
+        else:
+            # Auto-calculate next iteration based on existing data
+            # This ensures proper iteration tracking across all clients
+            if len(self.df) > 0 and 'Iteration' in self.df.columns:
+                max_iteration = int(self.df['Iteration'].max())
+                new_point['Iteration'] = max_iteration + 1
+            else:
+                # First experiment defaults to iteration 0
+                new_point['Iteration'] = 0
+        
+        # Keep _current_iteration in sync with latest iteration for backward compatibility
+        try:
+            self._current_iteration = int(new_point['Iteration'])
+        except Exception:
+            pass
+        
+        # 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 +79,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 +110,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 +135,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 +188,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
         
@@ -358,8 +396,12 @@ class SklearnModel(BaseModel):
         if return_std:
             pred_mean, pred_std = predictions
             
+            # Safety check: replace invalid/negative std with small positive value
+            # Sklearn GP can produce negative variances due to numerical issues
+            pred_std = np.maximum(pred_std, 1e-6)
+            
             # Apply calibration to standard deviation if enabled
-            if self.calibration_enabled:
+            if self.calibration_enabled and np.isfinite(self.calibration_factor):
                 pred_std = pred_std * self.calibration_factor
             
             # Inverse transform the mean predictions
@@ -598,11 +640,35 @@ class SklearnModel(BaseModel):
         y_pred = self.cv_cached_results['y_pred']
         y_std = self.cv_cached_results['y_std']
         
+        # Check for numerical issues (zero/negative variances)
+        if np.any(y_std <= 0) or np.any(~np.isfinite(y_std)):
+            logger.warning("Sklearn GP produced invalid uncertainties (zero/negative/inf). Disabling calibration.")
+            self.calibration_enabled = False
+            self.calibration_factor = 1.0
+            return
+        
         # Compute standardized residuals (z-scores)
-        z_scores = (y_true - y_pred) / y_std
+        # Add small epsilon to avoid division by zero
+        epsilon = 1e-10
+        z_scores = (y_true - y_pred) / (y_std + epsilon)
+        
+        # Check for numerical validity
+        if not np.all(np.isfinite(z_scores)):
+            logger.warning("Z-scores contain NaN/inf. Disabling calibration.")
+            self.calibration_enabled = False
+            self.calibration_factor = 1.0
+            return
         
         # Calibration factor = std(z)
         self.calibration_factor = np.std(z_scores, ddof=1)
+        
+        # Final check for valid calibration factor
+        if not np.isfinite(self.calibration_factor) or self.calibration_factor <= 0:
+            logger.warning(f"Invalid calibration factor: {self.calibration_factor}. Disabling calibration.")
+            self.calibration_enabled = False
+            self.calibration_factor = 1.0
+            return
+        
         self.calibration_enabled = True
         
         # Create calibrated copy of CV results for plotting