chembayes 0.1.0__tar.gz

chembayes-0.1.0/LICENSE

@@ -0,0 +1,6 @@
+Copyright (c) 2026 Jesus Alberto Martin del Campo
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

chembayes-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: chembayes
+Version: 0.1.0
+Summary: Experimental design and Bayesian optimization with Gaussian Processes and QMC sampling
+Author-email: Jesus Alberto Martin del Campo <j.a.martin-campo@hotmail.com>
+Project-URL: Homepage, https://github.com/jesusalmartin/chembayes
+Project-URL: Bug Tracker, https://github.com/jesusalmartin/chembayes/issues
+Keywords: bayesian-optimization,gaussian-processes,experimental-design,qmc,sampling,chemistry
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: pandas>=1.3
+Requires-Dist: scikit-learn>=1.0
+Requires-Dist: optuna>=3.0
+Requires-Dist: matplotlib>=3.4
+Requires-Dist: scipy>=1.7
+Dynamic: license-file
+
+# ChemBayes
+
+**ChemBayes** is a Python library designed to streamline **experimental design (DoE)** and **Bayesian optimization** for scientific and chemical research. It leverages Gaussian Processes to model complex response surfaces and efficiently identify optimal conditions.
+
+## 🚀 Key Features
+
+* **Intelligent Sampling (QMC):** Generate initial experimental designs using Halton sequences (Quasi-Monte Carlo) for optimal space-filling coverage.
+* **Automatic Preprocessing:** Integrated handling of numeric variables (scaling) and categorical variables (one-hot encoding).
+* **Hyperparameter Tuning:** Automated Gaussian Process parameter adjustment (Matern + WhiteKernel) using Leave-One-Out (LOO) cross-validation and NLPD loss.
+* **Bayesian Optimization:** Global maximum search using the Expected Improvement (EI) acquisition function.
+* **Visual Diagnostics:** Automated generation of feature importance, partial dependence plots (1D and 2D), and model validation charts.
+
+## 📦 Installation
+
+From the project root (where `pyproject.toml` is located):
+
+```bash
+pip install .
+```
+
+Or for development mode:
+
+```bash
+pip install -e .
+```
+
+## 🛠️ Quick Start
+
+### 1. Generating an Experimental Design (Sampling)
+
+Define your search space with numeric and categorical parameters:
+
+```python
+import chembayes as cb
+
+parameters = {
+    'temperature': {'type': 'float', 'l_bound': 20.0, 'u_bound': 100.0},
+    'time': {'type': 'int', 'l_bound': 5, 'u_bound': 60},
+    'catalyst': {'type': 'categoric', 'categories': ['Pd', 'Ni', 'Cu']}
+}
+
+# Generate 20 optimal experimental points
+df_experiments = cb.qmc_sampling(parameters, n_points=20)
+
+# Visualize the distribution
+cb.plot_qmc_sampling(df_experiments)
+```
+
+### 2. Bayesian Optimization
+
+Once you have experimental data, find the optimal conditions:
+
+```python
+# Define input features and the target column
+inputs = ['temperature', 'time', 'catalyst']
+output = 'yield'
+
+# Run the complete optimization pipeline
+results = cb.optimize_experiment(
+    df=df_data, 
+    inputs=inputs, 
+    output=output,
+    n_tuning_trials=50,
+    n_opt_trials=100
+)
+
+# Access the best found parameters
+print(f"Best configuration: {results['best_params']}")
+```
+
+## 📂 Project Structure
+
+* `src/chembayes/sampler.py`: Tools for QMC sample generation.
+* `src/chembayes/optimizer.py`: Bayesian optimization engine and Gaussian Processes.
+* `src/chembayes/__init__.py`: Public API exposure.
+* `pyproject.toml`: Modern package configuration and dependencies.
+
+## ✉️ Contact & Contribution
+
+**Author:** Jesus Alberto Martin del Campo  
+**Email:** j.a.martin-campo@hotmail.com  
+**GitHub:** [jesusalmartin/chembayes](https://github.com/jesusalmartin/chembayes)

chembayes-0.1.0/README.md

@@ -0,0 +1,82 @@
+# ChemBayes
+
+**ChemBayes** is a Python library designed to streamline **experimental design (DoE)** and **Bayesian optimization** for scientific and chemical research. It leverages Gaussian Processes to model complex response surfaces and efficiently identify optimal conditions.
+
+## 🚀 Key Features
+
+* **Intelligent Sampling (QMC):** Generate initial experimental designs using Halton sequences (Quasi-Monte Carlo) for optimal space-filling coverage.
+* **Automatic Preprocessing:** Integrated handling of numeric variables (scaling) and categorical variables (one-hot encoding).
+* **Hyperparameter Tuning:** Automated Gaussian Process parameter adjustment (Matern + WhiteKernel) using Leave-One-Out (LOO) cross-validation and NLPD loss.
+* **Bayesian Optimization:** Global maximum search using the Expected Improvement (EI) acquisition function.
+* **Visual Diagnostics:** Automated generation of feature importance, partial dependence plots (1D and 2D), and model validation charts.
+
+## 📦 Installation
+
+From the project root (where `pyproject.toml` is located):
+
+```bash
+pip install .
+```
+
+Or for development mode:
+
+```bash
+pip install -e .
+```
+
+## 🛠️ Quick Start
+
+### 1. Generating an Experimental Design (Sampling)
+
+Define your search space with numeric and categorical parameters:
+
+```python
+import chembayes as cb
+
+parameters = {
+    'temperature': {'type': 'float', 'l_bound': 20.0, 'u_bound': 100.0},
+    'time': {'type': 'int', 'l_bound': 5, 'u_bound': 60},
+    'catalyst': {'type': 'categoric', 'categories': ['Pd', 'Ni', 'Cu']}
+}
+
+# Generate 20 optimal experimental points
+df_experiments = cb.qmc_sampling(parameters, n_points=20)
+
+# Visualize the distribution
+cb.plot_qmc_sampling(df_experiments)
+```
+
+### 2. Bayesian Optimization
+
+Once you have experimental data, find the optimal conditions:
+
+```python
+# Define input features and the target column
+inputs = ['temperature', 'time', 'catalyst']
+output = 'yield'
+
+# Run the complete optimization pipeline
+results = cb.optimize_experiment(
+    df=df_data, 
+    inputs=inputs, 
+    output=output,
+    n_tuning_trials=50,
+    n_opt_trials=100
+)
+
+# Access the best found parameters
+print(f"Best configuration: {results['best_params']}")
+```
+
+## 📂 Project Structure
+
+* `src/chembayes/sampler.py`: Tools for QMC sample generation.
+* `src/chembayes/optimizer.py`: Bayesian optimization engine and Gaussian Processes.
+* `src/chembayes/__init__.py`: Public API exposure.
+* `pyproject.toml`: Modern package configuration and dependencies.
+
+## ✉️ Contact & Contribution
+
+**Author:** Jesus Alberto Martin del Campo  
+**Email:** j.a.martin-campo@hotmail.com  
+**GitHub:** [jesusalmartin/chembayes](https://github.com/jesusalmartin/chembayes)

chembayes-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chembayes"
+version = "0.1.0"
+authors = [
+  { name="Jesus Alberto Martin del Campo", email="j.a.martin-campo@hotmail.com" },
+]
+# Descripción actualizada para incluir el muestreo experimental
+description = "Experimental design and Bayesian optimization with Gaussian Processes and QMC sampling"
+readme = "README.md"
+requires-python = ">=3.9"
+# Se añaden keywords para mejorar la búsqueda del paquete
+keywords = ["bayesian-optimization", "gaussian-processes", "experimental-design", "qmc", "sampling", "chemistry"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Chemistry",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "numpy>=1.21",
+    "pandas>=1.3",
+    "scikit-learn>=1.0",
+    "optuna>=3.0",
+    "matplotlib>=3.4",
+    "scipy>=1.7",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/jesusalmartin/chembayes"
+"Bug Tracker" = "https://github.com/jesusalmartin/chembayes/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

chembayes-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chembayes-0.1.0/src/chembayes/__init__.py

@@ -0,0 +1,13 @@
+"""
+ChemBayes - Bayesian optimization with Gaussian Processes for experimental design.
+"""
+
+from .optimizer import create_objective, optimize_experiment
+from .sampler import qmc_sampling, plot_qmc_sampling
+
+__all__ = [
+    'create_objective', 
+    'optimize_experiment', 
+    'qmc_sampling', 
+    'plot_qmc_sampling'
+]

chembayes-0.1.0/src/chembayes/optimizer.py

@@ -0,0 +1,366 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.gaussian_process import GaussianProcessRegressor
+from sklearn.gaussian_process.kernels import Matern, WhiteKernel
+from sklearn.model_selection import LeaveOneOut
+from sklearn.inspection import permutation_importance, partial_dependence
+from scipy.stats import norm
+import optuna
+
+def create_objective(df, weights):
+    """
+    Create a weighted objective column.
+    """
+    cols = list(weights.keys())
+    subset = df[cols]
+    scaler = StandardScaler()
+    scaled_data = scaler.fit_transform(subset)
+    weight_series = pd.Series(weights)
+    objective = scaled_data @ weight_series.values
+    return objective
+
+def optimize_experiment(df, inputs, output, n_tuning_trials=100, n_opt_trials=100, plot=True):
+    """
+    Run the complete optimization pipeline using Gaussian Processes and Bayesian optimization.
+
+    The pipeline consists of:
+        1. Preprocessing numeric features (StandardScaler) and categorical features (OneHotEncoder).
+        2. Tuning GP hyperparameters (Matern + WhiteKernel) via Leave-One-Out cross-validation
+           minimizing the average negative log predictive density (NLPD). Tuning uses Optuna.
+        3. Fitting the final GP model with the best hyperparameters.
+        4. (Optional) Diagnostic plots: true vs predicted (colored by uncertainty), permutation importance.
+        5. Bayesian optimization (Expected Improvement) to find the input parameters that maximize
+           the objective. This also uses Optuna.
+        6. Reconstructing the best numeric parameters on the original scale.
+        7. (Optional) Partial dependence plots:
+            - For numeric features: 1D line plots on the diagonal, 2D contour plots below the diagonal.
+            - For categorical features: bar charts showing the average partial dependence per category.
+        8. Printing the best parameters and predicted objective.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Input data. It must already be cleaned (e.g., NaNs handled) if needed.
+    inputs : list of str
+        Column names to use as input features.
+    output : str or dict
+        If str: name of the column to maximize.
+        If dict: weights for weighted objective (passed to create_objective).
+    n_tuning_trials : int, default=100
+        Number of Optuna trials for GP hyperparameter tuning.
+    n_opt_trials : int, default=100
+        Number of Optuna trials for Bayesian optimization (Expected Improvement).
+    plot : bool, default=True
+        Whether to show diagnostic plots:
+            - true vs predicted (with uncertainty)
+            - permutation importance
+            - partial dependence (1D/2D for numeric, bar charts for categorical)
+
+    Returns
+    -------
+    dict
+        A dictionary containing:
+        - 'best_params': dict of optimal input parameters (on original scale).
+        - 'best_value': float, predicted objective at best_params.
+        - 'model': fitted GaussianProcessRegressor.
+        - 'preprocessor': fitted ColumnTransformer.
+        - 'X': preprocessed input matrix (numpy array).
+        - 'y': objective array.
+    """
+    # Create reduced DataFrame with weighted objective if needed
+    if isinstance(output, dict):
+        df['objective'] = create_objective(df, output)
+        output = 'objective'
+
+    # Drop rows with missing values in selected inputs or output
+    model_df = df.dropna(subset=inputs+[output])
+
+    X_df = model_df[inputs]
+    y = model_df[output]
+
+    # Identify numeric and categorical columns
+    numeric_features = [col for col in X_df.columns if col in X_df.select_dtypes(include='number').columns]
+    categorical_features = [col for col in X_df.columns if col in X_df.select_dtypes(include=['object', 'category', 'string']).columns]
+
+    # Preprocess input columns using ColumnTransformer
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ('num', StandardScaler(), numeric_features),
+            ('cat', OneHotEncoder(handle_unknown='ignore', sparse_output=False), categorical_features)
+        ])
+
+    X = preprocessor.fit_transform(X_df)
+    model_features = preprocessor.get_feature_names_out()
+    X_model = pd.DataFrame(X, columns=model_features)
+
+    # Keep a reference to the scaler for inverse transformation later
+    scaler = preprocessor.named_transformers_['num']
+
+    # ----- Gaussian Process hyperparameter tuning (LOO-CV with NLPD) -----
+    def gp_tuning_objective(trial):
+        # Suggest hyperparameters
+        length_scale = trial.suggest_float('length_scale', 0.1, 10.0, log=True)
+        noise_level = trial.suggest_float('noise_level', 1e-3, 10.0, log=True)
+
+        nu_values = [0.5, 1.5, 2.5, np.inf]
+        nu_idx = trial.suggest_int('nu_idx', 0, 3)
+        nu = nu_values[nu_idx]
+
+        # Leave-one-out cross-validation
+        loo = LeaveOneOut()
+        nlpds = []  # store negative log predictive densities
+
+        for train_idx, test_idx in loo.split(X_df):
+            X_train_df = X_model.iloc[train_idx]
+            y_train = y.iloc[train_idx]
+            X_test_df = X_model.iloc[test_idx]
+            y_test = y.iloc[test_idx]
+
+            # Create kernel with current hyperparameters
+            kernel = Matern(length_scale=length_scale, nu=nu) + WhiteKernel(noise_level=noise_level)
+
+            # Build GP (no internal optimization, fixed kernel parameters)
+            gp = GaussianProcessRegressor(
+                kernel=kernel,
+                alpha=0.0,                # we use WhiteKernel instead
+                optimizer=None,
+                normalize_y=True,
+                random_state=42
+            )
+            gp.fit(X_train_df, y_train)
+
+            # Predict on test point (mean and std)
+            mu, sigma = gp.predict(X_test_df, return_std=True)
+            mu = mu[0]
+            sigma = sigma[0]
+
+            # Avoid sigma=0 by clipping
+            sigma = max(sigma, 1e-6)
+            nlpd = 0.5 * np.log(2 * np.pi * sigma**2) + (y_test - mu)**2 / (2 * sigma**2)
+            nlpds.append(nlpd)
+
+        # Average NLPD across folds (to be minimized)
+        return np.mean(nlpds)
+
+    gp_tuning_study = optuna.create_study(direction='minimize')
+    gp_tuning_study.optimize(gp_tuning_objective, n_trials=n_tuning_trials)
+    gp_best_params = gp_tuning_study.best_params
+
+    # Build final GP with best hyperparameters
+    nu_values = [0.5, 1.5, 2.5, np.inf]
+    length_scale = gp_best_params['length_scale']
+    noise_level = gp_best_params['noise_level']
+    nu = nu_values[gp_best_params['nu_idx']]
+
+    kernel = Matern(length_scale=length_scale, nu=nu) + WhiteKernel(noise_level)
+    model = GaussianProcessRegressor(
+        kernel=kernel,
+        alpha=0.0,
+        optimizer=None,
+        normalize_y=True,
+        random_state=42
+    )
+    model.fit(X_model, y)
+
+
+    # ----- Bayesian optimization (Expected Improvement) -----
+    y_best = y.max()
+
+    def objective(trial):
+        numeric_model_features = [f for f in model_features if f.startswith('num__')]
+        categorical_model_features = [f for f in model_features if f.startswith('cat__')]
+        trial_dict = {}
+        for feature in numeric_model_features:
+            trial_dict[feature] = [trial.suggest_float(feature, X_model[feature].min(), X_model[feature].max())]
+        for feature in categorical_features:
+            ohe_group = [ohe_feature for ohe_feature in categorical_model_features if f'cat__{feature}' in ohe_feature]
+            trial_category = trial.suggest_categorical(feature, X_df[feature].unique())
+            for ohe_feature in ohe_group:
+                trial_dict[ohe_feature] = 1 if ohe_feature == f'cat__{feature}_{trial_category}' else 0
+        trial_df = pd.DataFrame(trial_dict)
+        trial_df = trial_df[model_features]
+
+        # Predict mean and standard deviation
+        mu, sigma = model.predict(trial_df, return_std=True)
+        mu = mu[0]
+        sigma = sigma[0]
+
+        # Expected Improvement for maximization
+        if sigma <= 0:
+            return 0.0
+        imp = mu - y_best
+        z = imp / sigma
+        ei = imp * norm.cdf(z) + sigma * norm.pdf(z)
+        return ei
+
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=n_opt_trials)
+    best_params = study.best_params
+
+    # ----- Reconstruct best numeric values on original scale -----
+    best_num_values_scaled = np.array([value for feature, value in best_params.items() if 'num__' in feature]).reshape(1, -1)
+    best_num_values = scaler.inverse_transform(best_num_values_scaled)
+    opt_params = {}
+    for index, feature in enumerate(numeric_features):
+        opt_params[feature] = best_num_values[0, index]
+    for feature in categorical_features:
+        opt_params[feature] = best_params[feature]
+
+    # ----- Diagnostic plots (if requested) -----
+    if plot:
+        # True vs predicted with uncertainty
+        y_pred, sigma = model.predict(pd.DataFrame(X, columns=model.feature_names_in_), return_std=True)
+        plt.figure()
+        sc = plt.scatter(y, y_pred, c=sigma, alpha=0.6, cmap='coolwarm', edgecolor='k', linewidth=0.5)
+        plt.colorbar(sc, label=f'Prediction std ({output})')
+        plt.xlabel(f"True {output}")
+        plt.ylabel(f"Predicted {output}")
+        plt.title(f"{output}: true vs. predicted (colored by uncertainty)")
+        plt.plot([y.min(), y.max()], [y.min(), y.max()], 'k--', linewidth=1)
+        plt.tight_layout()
+        plt.show()
+
+        # Permutation importance
+        permutation_result = permutation_importance(model, X_model, y, scoring='r2', n_repeats=30, random_state=42)
+        importances = permutation_result.importances_mean
+        sorted_idx = importances.argsort()[::-1]
+        sorted_importances = importances[sorted_idx]
+        sorted_features = model.feature_names_in_[sorted_idx]
+        plt.figure()
+        plt.barh(sorted_features[:15], sorted_importances[:15])
+        plt.gca().invert_yaxis()
+        plt.xlabel("Permutation importance")
+        plt.tight_layout()
+        plt.show()
+
+        # Partial dependence for numeric features: 1D on diagonal, 2D below diagonal
+        if numeric_features:
+            numeric_model_features = [f for f in model_features if f.startswith('num__')]
+
+            n_plots = len(numeric_model_features)
+            grid_point_number = 25
+
+            fig, axes = plt.subplots(n_plots, n_plots, figsize=(3*n_plots, 3*n_plots))
+
+            for i, feature_i in enumerate(numeric_model_features):
+                for j, feature_j in enumerate(numeric_model_features):
+                    ax = axes[i, j] if n_plots > 1 else axes
+
+                    if i == j:
+                        # 1D partial dependence on diagonal
+                        part_dep = partial_dependence(
+                            model,
+                            X=X_model,
+                            features=[feature_i],
+                            custom_values={feature_i: np.linspace(X_model[feature_i].min(), X_model[feature_i].max(), grid_point_number)}
+                        )
+                        xi = part_dep['grid_values'][0]
+                        yi = part_dep['average'][0]
+
+                        # Transform back to original scale for labeling
+                        original_feature_i = feature_i[5:]
+                        original_idx_i = numeric_features.index(original_feature_i)
+                        dummy_array = np.zeros((grid_point_number, len(numeric_features)))
+                        dummy_array[:, original_idx_i] = xi
+                        transformed_array = scaler.inverse_transform(dummy_array)
+                        xi = transformed_array[:, original_idx_i]
+
+                        ax.plot(xi, yi)
+                        ax.axvline(x=opt_params[original_feature_i], color='black', alpha=0.5)
+                        ax.set_xlabel(original_feature_i)
+                        ax.set_ylabel(output)
+
+                    elif j < i:
+                        # 2D partial dependence below diagonal
+                        part_dep = partial_dependence(
+                            model,
+                            X=X_model,
+                            features=[feature_i, feature_j],
+                            custom_values={
+                                feature_i: np.linspace(X_model[feature_i].min(), X_model[feature_i].max(), grid_point_number),
+                                feature_j: np.linspace(X_model[feature_j].min(), X_model[feature_j].max(), grid_point_number)
+                            }
+                        )
+
+                        xi = part_dep['grid_values'][0]
+                        yi = part_dep['grid_values'][1]
+                        zi = part_dep['average'][0].T
+
+                        original_feature_i = feature_i[5:]
+                        original_feature_j = feature_j[5:]
+
+                        original_idx_i = numeric_features.index(original_feature_i)
+                        original_idx_j = numeric_features.index(original_feature_j)
+
+                        dummy_array = np.zeros((grid_point_number, len(numeric_features)))
+                        dummy_array[:, original_idx_i] = xi
+                        dummy_array[:, original_idx_j] = yi
+
+                        transformed_array = scaler.inverse_transform(dummy_array)
+                        xi = transformed_array[:, original_idx_i]
+                        yi = transformed_array[:, original_idx_j]
+
+                        ax.pcolormesh(xi, yi, zi, cmap='coolwarm')
+                        ax.scatter(opt_params[original_feature_i], opt_params[original_feature_j], color='black', alpha=0.5)
+                        ax.set_xlabel(original_feature_i)
+                        ax.set_ylabel(original_feature_j)
+                    else:
+                        # Upper triangular part: hide axes
+                        ax.axis('off')
+            fig.tight_layout()
+            plt.show()
+
+        # Partial dependence for categorical features: bar charts per category
+        if categorical_features:
+            categorical_model_features = [f for f in model_features if f.startswith('cat__')]
+
+            n_plots = len(categorical_features)
+            fig, axes = plt.subplots(n_plots, 1, figsize=(6, 5*n_plots))
+
+            for i, feature in enumerate(categorical_features):
+                ax = axes[i] if n_plots > 1 else axes
+
+                # Get all one-hot columns for this original feature
+                ohe_features = [f for f in categorical_model_features if f.startswith(f'cat__{feature}')]
+
+                x_labels = []
+                y_values = []
+
+                for ohe_feature in ohe_features:
+                    part_dep = partial_dependence(model, X=X_model, features=[ohe_feature])
+                    yi = part_dep['average'][0]
+                    category = ohe_feature[len(f'cat__{feature}_'):]
+                    y_values.append(yi[-1])  # partial dependence value for this category
+                    x_labels.append(category)
+
+                ax.bar(x_labels, y_values)
+                ax.set_xlabel(feature)
+                ax.set_ylabel(output)
+                ax.tick_params(axis='x', labelrotation=45)
+            fig.tight_layout()
+            plt.show()
+
+    # Predict objective at the optimal input
+    opt_params_df = pd.DataFrame([opt_params])
+    opt_params_input = preprocessor.transform(opt_params_df)
+    best_output = model.predict(pd.DataFrame(opt_params_input, columns=model.feature_names_in_))[0]
+
+    print("\n--- Optimization results ---")
+    print(f"Model score (R²): {model.score(pd.DataFrame(X, columns=model.feature_names_in_), y):.4f}")
+    print("Best input parameters:")
+    for feature, value in opt_params.items():
+        print(f"  {feature}: {value}")
+    print(f"Best predicted {output}: {best_output:.4f}")
+
+    # ----- Return all important objects -----
+    return {
+        'best_params': opt_params,
+        'best_value': best_output,
+        'model': model,
+        'preprocessor': preprocessor,
+        'X': X,
+        'y': y
+    }

chembayes-0.1.0/src/chembayes/sampler.py

@@ -0,0 +1,106 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.stats import qmc
+
+def qmc_sampling(parameters, n_points, force_edges=True):
+    """
+    Generate a Quasi-Monte Carlo (QMC) sample using the Halton sequence.
+
+    This function creates a multidimensional sample based on the provided parameter
+    definitions, scaling each dimension to its specified bounds and types.
+
+    Parameters
+    ----------
+    parameters : dict
+        A dictionary defining the search space. Each key is a parameter name, 
+        and the value is another dict containing:
+        - 'type': str ('float', 'int', or 'categoric')
+        - 'l_bound': float/int (required for numeric types)
+        - 'u_bound': float/int (required for numeric types)
+        - 'categories': list (required for 'categoric' type)
+    n_points : int
+        The number of samples to generate.
+    force_edges : bool, default=True
+        If True, the samples are rescaled so that the minimum and maximum 
+        generated values exactly match the specified bounds. 
+        If False, values are kept in the [0, 1] probability space before scaling.
+
+    Returns
+    -------
+    pd.DataFrame
+        A DataFrame where each column corresponds to a parameter and each 
+        row is a generated sample point.
+    """
+    sampler = qmc.Halton(d=len(parameters), seed=42)
+    sample = sampler.random(n=n_points)
+
+    sample_dict = {}
+    for index, p in enumerate(parameters.keys()):
+
+        values = sample[:, index]
+
+        if force_edges:
+            v_min, v_max = values.min(), values.max()
+        elif force_edges==False:
+            v_min, v_max = 0.0, 1.0
+        else:
+            return print('forced_edges must be True or False')
+
+        p_type = parameters[p]['type']
+
+        if p_type == 'float':
+            l_bound = parameters[p]['l_bound']
+            u_bound = parameters[p]['u_bound']
+            scaled = l_bound + (values - v_min) * (u_bound - l_bound) / (v_max - v_min)
+            sample_dict[p] = scaled
+
+        elif p_type == 'int':
+            l_bound = parameters[p]['l_bound']
+            u_bound = parameters[p]['u_bound']
+            scaled = l_bound + (values - v_min) * (u_bound - l_bound) / (v_max - v_min)
+            scaled = np.round(scaled).astype(int)
+            sample_dict[p] = scaled
+
+        elif p_type == 'categoric':
+            v_min, v_max = values.min(), values.max()
+            categories = parameters[p]['categories']
+            l_bound = 0
+            u_bound = len(categories)-1
+            scaled = l_bound + (values - v_min) * (u_bound - l_bound) / (v_max - v_min)
+            scaled = np.round(scaled).astype(int).tolist()
+            scaled = [categories[v] for v in scaled]
+            sample_dict[p] = scaled
+        else:
+            return print(f'{p}: type must be float, int or categoric')
+    df = pd.DataFrame(sample_dict)
+    return df
+
+def plot_qmc_sampling(df):
+    """
+    Create a scatter plot matrix of the numerical variables in the sample.
+
+    This visualizes the space-filling properties of the QMC sampling by 
+    plotting each numeric parameter against every other numeric parameter 
+    in a grid of subplots.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The DataFrame generated by `qmc_sampling`.
+    """
+    num_df = df.select_dtypes(include='number')
+    n_vars = len(num_df.columns)
+
+    plt.figure(figsize=(3*n_vars, 3*n_vars))
+    plot = 1
+    for i, var_1 in enumerate(num_df.columns):
+        for j, var_2 in enumerate(num_df.columns):
+            if i >= j:
+                plt.subplot(n_vars, n_vars, plot)
+                plt.scatter(num_df[var_1], num_df[var_2])
+                plt.xlabel(var_1)
+                plt.ylabel(var_2)
+            plot +=1
+    plt.tight_layout()
+    plt.show()

chembayes-0.1.0/src/chembayes.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: chembayes
+Version: 0.1.0
+Summary: Experimental design and Bayesian optimization with Gaussian Processes and QMC sampling
+Author-email: Jesus Alberto Martin del Campo <j.a.martin-campo@hotmail.com>
+Project-URL: Homepage, https://github.com/jesusalmartin/chembayes
+Project-URL: Bug Tracker, https://github.com/jesusalmartin/chembayes/issues
+Keywords: bayesian-optimization,gaussian-processes,experimental-design,qmc,sampling,chemistry
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: pandas>=1.3
+Requires-Dist: scikit-learn>=1.0
+Requires-Dist: optuna>=3.0
+Requires-Dist: matplotlib>=3.4
+Requires-Dist: scipy>=1.7
+Dynamic: license-file
+
+# ChemBayes
+
+**ChemBayes** is a Python library designed to streamline **experimental design (DoE)** and **Bayesian optimization** for scientific and chemical research. It leverages Gaussian Processes to model complex response surfaces and efficiently identify optimal conditions.
+
+## 🚀 Key Features
+
+* **Intelligent Sampling (QMC):** Generate initial experimental designs using Halton sequences (Quasi-Monte Carlo) for optimal space-filling coverage.
+* **Automatic Preprocessing:** Integrated handling of numeric variables (scaling) and categorical variables (one-hot encoding).
+* **Hyperparameter Tuning:** Automated Gaussian Process parameter adjustment (Matern + WhiteKernel) using Leave-One-Out (LOO) cross-validation and NLPD loss.
+* **Bayesian Optimization:** Global maximum search using the Expected Improvement (EI) acquisition function.
+* **Visual Diagnostics:** Automated generation of feature importance, partial dependence plots (1D and 2D), and model validation charts.
+
+## 📦 Installation
+
+From the project root (where `pyproject.toml` is located):
+
+```bash
+pip install .
+```
+
+Or for development mode:
+
+```bash
+pip install -e .
+```
+
+## 🛠️ Quick Start
+
+### 1. Generating an Experimental Design (Sampling)
+
+Define your search space with numeric and categorical parameters:
+
+```python
+import chembayes as cb
+
+parameters = {
+    'temperature': {'type': 'float', 'l_bound': 20.0, 'u_bound': 100.0},
+    'time': {'type': 'int', 'l_bound': 5, 'u_bound': 60},
+    'catalyst': {'type': 'categoric', 'categories': ['Pd', 'Ni', 'Cu']}
+}
+
+# Generate 20 optimal experimental points
+df_experiments = cb.qmc_sampling(parameters, n_points=20)
+
+# Visualize the distribution
+cb.plot_qmc_sampling(df_experiments)
+```
+
+### 2. Bayesian Optimization
+
+Once you have experimental data, find the optimal conditions:
+
+```python
+# Define input features and the target column
+inputs = ['temperature', 'time', 'catalyst']
+output = 'yield'
+
+# Run the complete optimization pipeline
+results = cb.optimize_experiment(
+    df=df_data, 
+    inputs=inputs, 
+    output=output,
+    n_tuning_trials=50,
+    n_opt_trials=100
+)
+
+# Access the best found parameters
+print(f"Best configuration: {results['best_params']}")
+```
+
+## 📂 Project Structure
+
+* `src/chembayes/sampler.py`: Tools for QMC sample generation.
+* `src/chembayes/optimizer.py`: Bayesian optimization engine and Gaussian Processes.
+* `src/chembayes/__init__.py`: Public API exposure.
+* `pyproject.toml`: Modern package configuration and dependencies.
+
+## ✉️ Contact & Contribution
+
+**Author:** Jesus Alberto Martin del Campo  
+**Email:** j.a.martin-campo@hotmail.com  
+**GitHub:** [jesusalmartin/chembayes](https://github.com/jesusalmartin/chembayes)

chembayes-0.1.0/src/chembayes.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/chembayes/__init__.py
+src/chembayes/optimizer.py
+src/chembayes/sampler.py
+src/chembayes.egg-info/PKG-INFO
+src/chembayes.egg-info/SOURCES.txt
+src/chembayes.egg-info/dependency_links.txt
+src/chembayes.egg-info/requires.txt
+src/chembayes.egg-info/top_level.txt

chembayes-0.1.0/src/chembayes.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chembayes-0.1.0/src/chembayes.egg-info/requires.txt

@@ -0,0 +1,6 @@
+numpy>=1.21
+pandas>=1.3
+scikit-learn>=1.0
+optuna>=3.0
+matplotlib>=3.4
+scipy>=1.7

chembayes-0.1.0/src/chembayes.egg-info/top_level.txt

@@ -0,0 +1 @@
+chembayes