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

alchemist_core/models/sklearn_model.py

@@ -4,6 +4,7 @@ from alchemist_core.data.experiment_manager import ExperimentManager
 from alchemist_core.config import get_logger
 import numpy as np
 import pandas as pd
+from typing import Union, Tuple, Optional
 from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
 from sklearn.model_selection import KFold, cross_validate, train_test_split
 from sklearn.preprocessing import OneHotEncoder, StandardScaler, MinMaxScaler, RobustScaler
@@ -322,7 +323,13 @@ class SklearnModel(BaseModel):
         self.X_orig = X_orig  # Store original data for contour generation
         
         X, y = self._preprocess_data(experiment_manager)
-        self.kernel = self._build_kernel(X)
+        
+        # Check if we should reuse a pre-optimized kernel
+        if hasattr(self, '_reuse_kernel') and self._reuse_kernel is not None:
+            self.kernel = self._reuse_kernel
+            logger.info("Reusing pre-optimized kernel hyperparameters")
+        else:
+            self.kernel = self._build_kernel(X)
         
         # Create base parameters dictionary
         params = {
@@ -396,8 +403,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
@@ -459,13 +470,16 @@ class SklearnModel(BaseModel):
                 subset_X_train = X_train.iloc[:i]
                 subset_y_train = y_train.iloc[:i]
                 
-                # Use the ALREADY FITTED scalers (fit_scalers=False)
-                X_processed = self._preprocess_subset(subset_X_train, categorical_variables, fit_scalers=False)
-                y_processed = self._scale_output(subset_y_train.values.reshape(-1, 1), fit_scaler=False).ravel()
+                # Fit scalers on this subset
+                X_processed = self._preprocess_subset(subset_X_train, categorical_variables, fit_scalers=True)
+                y_processed = self._scale_output(subset_y_train.values.reshape(-1, 1), fit_scaler=True).ravel()
                 
-                # Create model with optimized hyperparameters but no re-optimization
+                # Build kernel for this subset's dimensionality
+                subset_kernel = self._build_kernel(X_processed)
+                
+                # Create model with subset-specific kernel but no re-optimization
                 eval_model = GaussianProcessRegressor(
-                    kernel=self.optimized_kernel,
+                    kernel=subset_kernel,
                     optimizer=None,  # Don't re-optimize
                     random_state=self.random_state
                 )
@@ -511,13 +525,16 @@ class SklearnModel(BaseModel):
                     X_test_fold = subset_X.iloc[test_idx]
                     y_test_fold = subset_y.iloc[test_idx]
                     
-                    # Use the ALREADY FITTED scalers (fit_scalers=False) - same scalers for all folds
-                    X_train_processed = self._preprocess_subset(X_train_fold, categorical_variables, fit_scalers=False)
-                    y_train_processed = self._scale_output(y_train_fold.values.reshape(-1, 1), fit_scaler=False).ravel()
+                    # Fit scalers on this fold's training data
+                    X_train_processed = self._preprocess_subset(X_train_fold, categorical_variables, fit_scalers=True)
+                    y_train_processed = self._scale_output(y_train_fold.values.reshape(-1, 1), fit_scaler=True).ravel()
+                    
+                    # Build kernel for this fold's dimensionality
+                    fold_kernel = self._build_kernel(X_train_processed)
                     
-                    # Create model with optimized hyperparameters but no re-optimization
+                    # Create model with fold-specific kernel but no re-optimization
                     eval_model = GaussianProcessRegressor(
-                        kernel=self.optimized_kernel,
+                        kernel=fold_kernel,
                         optimizer=None,  # Don't re-optimize
                         random_state=self.random_state
                     )
@@ -586,9 +603,13 @@ class SklearnModel(BaseModel):
             X_train_processed = self._preprocess_subset(X_train_fold, categorical_variables, fit_scalers=True)
             y_train_processed = self._scale_output(y_train_fold.values.reshape(-1, 1), fit_scaler=True).ravel()
             
-            # Create model with optimized hyperparameters but no re-optimization
+            # Create a kernel for this fold's dimensionality
+            # (categories might differ between folds, changing feature count)
+            fold_kernel = self._build_kernel(X_train_processed)
+            
+            # Create model with fold-specific kernel but no re-optimization
             cv_model = GaussianProcessRegressor(
-                kernel=self.optimized_kernel,
+                kernel=fold_kernel,
                 optimizer=None,  # Don't re-optimize
                 random_state=self.random_state
             )
@@ -636,11 +657,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
@@ -753,3 +798,118 @@ class SklearnModel(BaseModel):
         Z = predictions.reshape(X.shape)
         
         return X, Y, Z
+
+    def evaluate_acquisition(
+        self, 
+        X: Union[pd.DataFrame, np.ndarray], 
+        acq_func: str = 'ucb', 
+        acq_func_kwargs: Optional[dict] = None, 
+        maximize: bool = True
+    ) -> Tuple[np.ndarray, None]:
+        """
+        Evaluate acquisition function at given points using skopt functions.
+        
+        Args:
+            X: Points to evaluate (DataFrame or array with shape (n, d))
+            acq_func: Acquisition function name ('ei', 'pi', 'ucb/lcb')
+            acq_func_kwargs: Additional parameters (e.g., {'xi': 0.01, 'kappa': 1.96})
+            maximize: Whether we're maximizing (True) or minimizing (False)
+            
+        Returns:
+            Tuple of (acq_values, None) - None because acq functions are deterministic
+            
+        Example:
+            >>> points = pd.DataFrame({'temp': [300, 350, 400], 'pressure': [1, 2, 3]})\n            >>> acq_vals, _ = model.evaluate_acquisition(points, acq_func='ei', maximize=True)
+        """
+        from skopt.acquisition import gaussian_ei, gaussian_pi, gaussian_lcb
+        
+        if not self.is_trained:
+            raise ValueError("Model must be trained before evaluating acquisition functions.")
+        
+        # Convert input to expected format
+        X_processed = self._preprocess_X(X)
+        
+        # Get y_opt from training data (in scaled space)
+        if maximize:
+            y_opt = np.max(self.y_train_)
+        else:
+            y_opt = np.min(self.y_train_)
+        
+        # Map acquisition function names
+        acq_func_lower = acq_func.lower()
+        
+        # Parse kwargs with defaults
+        if acq_func_kwargs is None:
+            acq_func_kwargs = {}
+        
+        xi = acq_func_kwargs.get('xi', 0.01)
+        kappa = acq_func_kwargs.get('kappa', 1.96)
+        
+        # Evaluate acquisition function
+        # NOTE: skopt's gaussian_ei/pi/lcb are designed for MINIMIZATION
+        # For maximization, we need to adapt the formulas
+        if acq_func_lower in ['ei', 'expectedimprovement']:
+            if maximize:
+                # For maximization: EI = E[max(f(x) - f(x_best) - xi, 0)]
+                # where f(x_best) = y_opt = max(y_train)
+                mu, std = self.model.predict(X_processed, return_std=True)
+                from scipy.stats import norm
+                improve = mu - y_opt + xi  # Improvement over current max
+                z = improve / (std + 1e-9)  # Avoid division by zero
+                ei = improve * norm.cdf(z) + std * norm.pdf(z)
+                acq_values = ei
+            else:
+                # For minimization: use gaussian_ei directly
+                acq_values = gaussian_ei(
+                    X_processed, 
+                    self.model, 
+                    y_opt=y_opt, 
+                    xi=xi,
+                    return_grad=False
+                )
+            
+        elif acq_func_lower in ['pi', 'probabilityofimprovement']:
+            if maximize:
+                # For maximization: PI = P(f(x) > f(x_best) + xi)
+                mu, std = self.model.predict(X_processed, return_std=True)
+                from scipy.stats import norm
+                improve = mu - y_opt + xi
+                z = improve / (std + 1e-9)
+                pi = norm.cdf(z)
+                acq_values = pi
+            else:
+                # For minimization: use gaussian_pi directly
+                acq_values = gaussian_pi(
+                    X_processed, 
+                    self.model, 
+                    y_opt=y_opt, 
+                    xi=xi,
+                    return_grad=False
+                )
+                
+        elif acq_func_lower in ['ucb', 'lcb', 'upperconfidencebound', 'lowerconfidencebound']:
+            # For maximization: UCB = mean + kappa*std (higher is better)
+            # For minimization: LCB = mean - kappa*std (lower is better)
+            if maximize:
+                # Calculate UCB directly from predictions
+                mu, std = self.model.predict(X_processed, return_std=True)
+                acq_values = mu + kappa * std
+            else:
+                # Use gaussian_lcb for minimization
+                acq_values = gaussian_lcb(
+                    X_processed, 
+                    self.model, 
+                    kappa=kappa,
+                    return_grad=False
+                )
+        else:
+            raise ValueError(
+                f"Unknown acquisition function '{acq_func}' for sklearn backend. "
+                f"Valid options are: 'ei', 'pi', 'ucb/lcb'"
+            )
+        
+        # Ensure output is 1D array
+        if acq_values.ndim > 1:
+            acq_values = acq_values.ravel()
+        
+        return acq_values, None