Upload 6 files

src/01.install_packages.py

@@ -0,0 +1,51 @@
+#-----Install packages to pull data from ORD-----
+#User should check which of these packages are already installed and run pip install for the missing ones.
+
+#pip install protobuf
+#git clone https://github.com/Open-Reaction-Database/ord-schema.git
+#cd ord-schema
+# Install the ord_schema package (ensure setuptools is upgraded)
+#pip install --upgrade setuptools
+#pip install .
+
+# Install protocol buffers compiler (for compiling .proto files if needed)
+#apt-get install -y protobuf-compiler
+
+#Install other packages if needed
+#pip install wget
+#pip install rdkit
+#pip install scikit-learn
+#pip install molvs
+#pip install tensorflow
+#pip install shap
+
+#-----Install packages for H2O AutoML-----
+#pip install xgboost
+#pip install -f http://h2o-release.s3.amazonaws.com/h2o/latest_stable_Py.html h2o
+
+import os
+import sys
+
+# Determine the path to ord_schema package
+package_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'ord-schema'))
+# Add the package directory to sys.path
+if package_path not in sys.path:
+    sys.path.insert(0, package_path)
+
+import ord_schema
+from ord_schema import message_helpers, validations
+from ord_schema.proto import dataset_pb2
+
+import math
+import pandas as pd
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import os
+import wget
+
+from rdkit.Chem import AllChem
+from sklearn import model_selection, metrics
+from glob import glob
+from rdkit import Chem
+from molvs import Standardizer

src/02.download_dataset.py

@@ -0,0 +1,36 @@
+#Download dataset from ORD GitHub. Need to specify ORD dataset ID and file path.
+
+import ord_schema
+from ord_schema import message_helpers, validations
+from ord_schema.proto import dataset_pb2
+
+import math
+import pandas as pd
+import numpy as np
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import os
+import wget
+
+from rdkit.Chem import AllChem
+from sklearn import model_selection, metrics
+from glob import glob
+from rdkit import Chem
+from molvs import Standardizer
+
+# Download dataset from ord-data
+url = "https://github.com/open-reaction-database/ord-data/blob/main/data/46/ord_dataset-46ff9a32d9e04016b9380b1b1ef949c3.pb.gz?raw=true"
+pb = wget.download(url)
+
+# Load Dataset message
+data = message_helpers.load_message(pb, dataset_pb2.Dataset)
+
+# Ensure dataset validates
+valid_output = validations.validate_message(data)
+
+# Convert dataset to pandas dataframe
+df = message_helpers.messages_to_dataframe(data.reactions, drop_constant_columns=True)
+
+# View dataframe
+#df
+df.to_csv('data/Ahneman_ORD_Data.csv', index=False)

src/03.sanitize_data.py

@@ -0,0 +1,46 @@
+#To sanitize the SMILES in the ORD dataset
+
+import pandas as pd
+from rdkit import Chem
+from molvs import Standardizer
+
+# Read the CSV file
+file_path = 'data/Ahneman_ORD_Data.csv'  # replace with your file path
+df = pd.read_csv(file_path)
+
+# Initialize the Standardizer from MolVS
+standardizer = Standardizer()
+
+# List the columns that contain SMILES strings
+smiles_columns = ['inputs["catalyst"].components[0].identifiers[1].value',
+                  'inputs["aryl halide"].components[0].identifiers[0].value', 
+                  'inputs["base"].components[0].identifiers[1].value', 
+                  'inputs["additive"].components[0].identifiers[0].value',
+                  'inputs["additive"].components[0].identifiers[1].value', 
+                  'outcomes[0].products[0].identifiers[0].value'
+                  ]  
+
+def sanitize_smiles(smiles):
+    try:
+        if pd.isna(smiles):
+            return smiles  # Return NA or None if the original data is NA
+
+        mol = Chem.MolFromSmiles(smiles)
+        if mol:
+            standardized_mol = standardizer.standardize(mol)
+            sanitized_smiles = Chem.MolToSmiles(standardized_mol)
+            print(f"SMILES successfully sanitized: {sanitized_smiles}")
+            return sanitized_smiles
+        else:
+            return None
+    except Exception as e:
+        print(f"Error standardizing SMILES: {smiles} -> {e}")
+        return None
+
+# Apply sanitization to each SMILES column
+for col in smiles_columns:
+    df[col] = df[col].apply(sanitize_smiles)
+
+sanitized_df = df
+# Save the sanitized SMILES back to a new CSV file
+sanitized_df.to_csv('data/Sanitized_Ahneman_ORD_Data.csv', index=False)

src/04.prepare_data_for_ML.py

@@ -0,0 +1,55 @@
+#Prepare ORD data for training a machine learning model
+
+import math
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from rdkit.Chem import AllChem
+from sklearn import model_selection, metrics
+from glob import glob
+from rdkit import Chem
+from molvs import Standardizer
+
+# Create new dataframe containing only columns to be used in modeling
+model_cols = ['inputs["catalyst"].components[0].identifiers[1].value', #Pd catalyst
+              'inputs["aryl halide"].components[0].identifiers[0].value', #Aryl Halide
+              'inputs["base"].components[0].identifiers[1].value', #Base
+              'inputs["additive"].components[0].identifiers[0].value', #Amine or solvent (in controls)
+              'outcomes[0].products[0].measurements[0].percentage.value' #% yield
+]
+
+#Read data from sanitized data .csv file
+file_path = 'data/Sanitized_Ahneman_ORD_Data.csv'  #Sanitized data
+sanitized_df = pd.read_csv(file_path)
+df = sanitized_df[model_cols] #Use sanitized data in the model with correct columns to use in the ML model
+
+# Check for NaN values
+print(f"number of NaN values: {df.isnull().sum().sum()}")
+
+# Show column counts
+print("Column Info")
+df.info()
+
+# Show dataset statistics for numerical fields
+print("Dataset Statistics for Numerical Fields:")
+df.describe()
+
+#One-Hot Encoding (OHE)
+# Convert reaction input labels to one-hot encoding
+input_cols = model_cols[:-1]
+
+# Assign names for each input
+prefix = ["Catalyst", "Aryl Halide", "Base", "Additives"]
+
+# Create one-hot encoded input dataset
+ohe_df = pd.get_dummies(df[input_cols], prefix=prefix)
+
+# Add yield column to ohe dataset
+ohe_df["yield"] = df[model_cols[-1]] / 100 #yield is the target variable the ML model will learn to optimize
+
+# View dataset
+print(ohe_df.shape)
+
+ohe_df.to_csv('data/Prepared_Data.csv', index=False)
+
+

src/05.run_autoML_updated.py

@@ -0,0 +1,199 @@
+#Split prepared data into training, validation, and test sets. Then train, run, and analyze AutoML model.
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from rdkit.Chem import AllChem
+from sklearn import model_selection, metrics
+import pyarrow as pa
+import shap
+
+import h2o
+from h2o.automl import H2OAutoML
+
+#Read data from one-hot encoded data .csv file
+file_path = 'data/Prepared_Data.csv'  #Sanitized data
+ohe_df = pd.read_csv(file_path)
+print("OHE DF Shape: ", ohe_df.shape)
+
+# Create numpy arrays for inputs and outputs.
+X = ohe_df.drop(columns=["yield"]).values
+y = ohe_df["yield"].values
+
+# Verify array shapes
+print("Shapes of input and output arrays:")
+print("X size: ", X.shape, ", Y size: ", y.shape)
+
+#Split data into training, validation, and tests sets. 70% training/30% test split.
+#Set training, validation, and test sets with random_state for reproducibility
+
+_X_train, X_test, _y_train, y_test = model_selection.train_test_split(X, y, test_size=0.3, random_state=0)
+X_train, X_valid, y_train, y_valid = model_selection.train_test_split(
+    _X_train, _y_train, test_size=(0.1 / 0.7), shuffle=False
+)
+
+# Check lengths
+print("X_train size: ", X_train.shape, ", y_train size: ", y_train.shape)
+print("X_valid size: ", X_valid.shape, ", y_valid size: ", y_valid.shape)
+print("X_test size: ", X_test.shape, ", y_test size: ", y_test.shape)
+print("Is length of data frame equal to sum of split data set lengths?",
+      len(ohe_df) == X_train.shape[0] + X_valid.shape[0] + X_test.shape[0])
+
+print("X_train_Dataset", X_train[0:20])
+print("Y_train_Dataset", y_train[0:20])
+# Start the H2O cluster (locally)
+h2o.init(nthreads=-1)
+
+# Convert the TensorFlow dataset to a pandas DataFrame
+data_train_df = pd.DataFrame(X_train) 
+data_train_df['yield'] = y_train 
+
+print("Length Data Train", data_train_df.shape)
+
+#Shorten data frames for faster training/validation
+data_train_df  = data_train_df[0:250]
+
+#Read pandas dataframe into H2O Frame
+h2o_data_train = h2o.H2OFrame(data_train_df)
+
+#Specify target columns & features
+target = "yield" #Main objective is to predict yields based on reaction conditions. Yield is therefore the target variable.
+features = [col for col in h2o_data_train.columns if col != target]
+
+
+#Initialize AutoML and train models
+aml = H2OAutoML(max_models=8, exclude_algos=['StackedEnsemble']) #Exclude stacked ensemble models
+aml.train(x= features, y= target, training_frame= h2o_data_train)
+
+#Display leaderbord for all models
+lb = aml.leaderboard
+print(lb.head(rows=lb.nrows))
+
+#Store model leaderboard/peformance data for SHAP Analysis
+best_model = aml.leader  # Retrieve best-performing model
+
+# Create a background frame from the training data
+background_frame = h2o_data_train[0:100]  # Use the first 100 rows of training data as background frame
+
+# Use a smaller sample for SHAP analysis reduce computation time
+#sample_data_train = h2o_data_train[:500]
+sample_data_train = h2o_data_train
+
+# Compute SHAP values using best model found by H2O AutoML
+shap_values = best_model.predict_contributions(sample_data_train, background_frame=background_frame)
+
+# Convert SHAP values to Pandas DataFrame for plotting using multi-threading
+shap_df = shap_values.as_data_frame(use_pandas=True, use_multi_thread=True)
+print("shap_df", shap_df[0:3])
+
+# Drop BiasTerm if present
+if 'BiasTerm' in shap_df.columns:
+    shap_df = shap_df.drop('BiasTerm', axis=1)
+
+print("Original SHAP DataFrame columns:", shap_df.columns)
+
+# Function to clean and consolidate column names in shap_df
+def consolidate_shap_columns(shap_df):
+    # Clean column names by removing specific state suffixes ('.True', '.False', '.Missing')
+    shap_df.columns = shap_df.columns.str.replace(r'\.(True|False|Missing <math><mrow><mi>N</mi><mi>A</mi></mrow></math>)$', '', regex=True)
+    # Remove duplicated columns after consolidation
+    shap_df = shap_df.loc[:, ~shap_df.columns.duplicated()]
+    return shap_df
+
+# Convert SHAP values dataframe columns to get rid of extensions
+shap_df = consolidate_shap_columns(shap_df)
+print("Cleaned SHAP Columns", shap_df.columns)
+
+# Convert H2OFrame with original data to Pandas DataFrame
+df_train_pandas = h2o_data_train.as_data_frame(use_pandas=True, use_multi_thread=True)
+
+# List of feature names from training data
+feature_columns = [col for col in df_train_pandas.columns if col != 'yield']
+print("Feature columns", feature_columns)
+
+# Ensure alignment between SHAP DataFrame and original training features
+shap_df = shap_df[feature_columns]
+
+print("Original data columns:")
+print(df_train_pandas.columns)
+print("SHAP data columns:")
+print(shap_df.columns)
+
+#Remove "yield" column from data_train_pandas df to ensure consistency with shap_df columns. 
+df_train_pandas = df_train_pandas.drop(columns=["yield"])
+
+# Verifying column alignment between training data columns and shap columns 
+assert list(shap_df.columns) == list(df_train_pandas.columns), "Feature columns do not match between SHAP values and data"
+
+# -----Visualize using SHAP summary plot-----
+
+# Use SHAP summary plot
+shap.summary_plot(shap_df.values, df_train_pandas, plot_type="bar")
+
+# For detailed SHAP plots:
+shap.summary_plot(shap_df.values, df_train_pandas)
+
+# Show and save the plots
+plt.tight_layout()
+plt.show()
+plt.savefig("SHAP_Analysis_Summary.png")
+
+#------------Analyze Model Performance------------
+# Convert datasets to H2OFrame
+h2o_test = h2o.H2OFrame(pd.DataFrame(X_test, columns=ohe_df.drop(columns=["yield"]).columns))
+
+#Set up loss curves for best model identified by AutoML
+model_with_history = None
+for model_id in aml.leaderboard.as_data_frame()['model_id']:
+    model = h2o.get_model(model_id)
+    if hasattr(model, 'scoring_history'):
+        model_with_history = model
+        break
+
+# Check if model has available scoring history
+if model_with_history and hasattr(model_with_history, 'scoring_history'):
+    scoring_history = model_with_history.scoring_history()
+else:
+    print("No suitable model with scoring history found.")
+    scoring_history = pd.DataFrame()  # Avoid further errors
+
+# Extract metrics
+preds_h2o = aml.leader.predict(h2o.H2OFrame(pd.DataFrame(X_test))).as_data_frame().values.flatten()
+
+# Calculate RMSE and R^2
+r2 = metrics.r2_score(y_test, preds_h2o)
+rmse = np.sqrt(metrics.mean_squared_error(y_test, preds_h2o))
+print(f"Test RMSE: {rmse}")
+print(fr"Test $R^2$: {r2}")
+
+# Plot model performance
+fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(6, 12))
+fig.suptitle("Buchwald-Hartwig AutoML Model Performance")
+
+if not scoring_history.empty:
+    if 'training_rmse' in scoring_history.columns:
+        ax1.plot(scoring_history['training_rmse'], 'b', label='Training RMSE')
+    if 'validation_rmse' in scoring_history.columns:
+        ax1.plot(scoring_history['validation_rmse'], 'g', label='Validation RMSE')
+else:
+    ax1.text(0.5, 0.5, 'Scoring history unavailable', horizontalalignment='center', verticalalignment='center')
+
+ax1.legend()
+ax1.set_ylabel("RMSE")
+ax1.set_xlabel("Epoch/Tree Index")
+ax1.set_title(f"Loss Curves for {best_model.model_id}")
+
+# Plot predictions vs. ground truth
+ax2.scatter(y_test, preds_h2o, c='b', marker='o', label='Predictions')
+ax2.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], "r-", lw=2)  # Line y=x
+ax2.set_ylabel("Predicted Yield")
+ax2.set_xlabel("Ground Truth Yield")
+ax2.set_title("Predictions vs Ground Truth")
+ax2.text(0.15, 0.9 * max(y_test), fr"Test RMSE: {round(rmse, 3)}", fontsize=12)
+ax2.text(0.15, 0.8 * max(y_test), fr"Test $R^2$: {round(r2, 3)}", fontsize=12)
+
+# View performance plots
+plt.show()
+plt.tight_layout()
+plt.savefig("B-H AutoML Model Performance.png")
+

src/06.upload_to_huggingface.py

@@ -0,0 +1,36 @@
+import datasets
+#Each dataset/.csv file is separately pushed to Huggingface under a different directory. 
+
+original_dataset = datasets.load_dataset(
+    "csv",
+    data_files = f'data/Ahneman_ORD_Data.csv',
+    keep_in_memory = True,
+    sep = ",")
+
+sanitized_dataset = datasets.load_dataset(
+    "csv",
+    data_files = f'data/Sanitized_Ahneman_ORD_Data.csv',
+    keep_in_memory = True,
+    sep = ",")
+
+prepared_dataset = datasets.load_dataset(
+    "csv",
+    data_files = f'data/Prepared_Data.csv',
+    keep_in_memory = True,
+    sep = ",")
+
+
+print("Pushing to cmmauro/ORD_Ahneman_2018")
+sanitized_dataset.push_to_hub(
+    repo_id = "cmmauro/ORD_Ahneman_2018",
+    data_dir="Sanitized Dataset")
+
+print("Pushing to cmmauro/ORD_Ahneman_2018")
+original_dataset.push_to_hub(
+    repo_id = "cmmauro/ORD_Ahneman_2018",
+    data_dir = "Original Dataset")
+
+print("Pushing to cmmauro/ORD_Ahneman_2018")
+prepared_dataset.push_to_hub(
+    repo_id = "cmmauro/ORD_Ahneman_2018",
+    data_dir = "Prepared Dataset for ML")