Upload 6 files

Scripts/Buchwald_model.py

@@ -0,0 +1,116 @@
+import matplotlib
+matplotlib.use('TkAgg')
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem import AllChem
+import h2o
+from h2o.estimators import H2OGradientBoostingEstimator
+from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
+
+# Initialize H2O
+h2o.init()
+
+def featurize_smiles(smiles):
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        fingerprint = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024)
+        features = np.array(fingerprint)
+        return features
+    except Exception as e:
+        print(f"Error featurizing SMILES: {smiles} -> {e}")
+        return np.zeros(1024)  # Return a zero vector if there's an issue
+
+# Specify the input and output column indices
+input_column_index1 = 5  # Replace with index for the first reactant SMILES
+input_column_index2 = 6  # Replace with index for the second reactant SMILES
+output_column_index = 3  # Replace with your output (product) column index
+
+# Prepare a H2OFrame for the first train-test split
+file_path = '/Users/colestephens/Desktop/CodeFolders/ML_Dataset_Curation_Project/Split_data/buchwald.xlsx'
+splits = pd.ExcelFile(file_path)
+
+# Let's use the first split as an example
+train_key = 'train_split_0'
+test_key = 'test_split_0'
+
+# Read the train and test sets
+train_df = pd.read_excel(splits, sheet_name=train_key)
+test_df = pd.read_excel(splits, sheet_name=test_key)
+
+# Determine the column names using indices
+input_column_name1 = train_df.columns[input_column_index1]
+input_column_name2 = train_df.columns[input_column_index2]
+output_column_name = train_df.columns[output_column_index]
+
+# Featurize the SMILES columns for both reactants and concatenate the features
+train_features1 = np.array([featurize_smiles(smiles) for smiles in train_df[input_column_name1]])
+train_features2 = np.array([featurize_smiles(smiles) for smiles in train_df[input_column_name2]])
+train_features = np.hstack((train_features1, train_features2))
+
+test_features1 = np.array([featurize_smiles(smiles) for smiles in test_df[input_column_name1]])
+test_features2 = np.array([featurize_smiles(smiles) for smiles in test_df[input_column_name2]])
+test_features = np.hstack((test_features1, test_features2))
+
+# Print message after successful featurization
+print("Successfully converted SMILES to Morgan fingerprints for train and test sets.")
+
+# Convert to H2OFrames
+train_X = pd.DataFrame(train_features)
+test_X = pd.DataFrame(test_features)
+
+# Combine features with the target column
+train_h2o = h2o.H2OFrame(pd.concat([train_X, train_df[[output_column_name]]], axis=1))
+test_h2o = h2o.H2OFrame(pd.concat([test_X, test_df[[output_column_name]]], axis=1))
+
+# Set the target and features
+y = output_column_name
+X = train_h2o.columns[:-1]  # All columns except the last one
+
+# Initialize and train a Gradient Boosting model
+gbm_model = H2OGradientBoostingEstimator(
+    ntrees=50,
+    max_depth=6,
+    learn_rate=0.1,
+    seed=1
+)
+
+gbm_model.train(x=X, y=y, training_frame=train_h2o)
+
+# Evaluate model performance
+performance = gbm_model.model_performance(test_data=test_h2o)
+print(performance)
+
+# Visualization: Variable Importance
+gbm_model.varimp_plot()
+plt.show()
+
+# Obtain predictions and visualize the confusion matrix
+predictions = gbm_model.predict(test_h2o).as_data_frame()
+conf_matrix = confusion_matrix(test_df[output_column_name], predictions['predict'])
+
+# Display confusion matrix
+disp = ConfusionMatrixDisplay(confusion_matrix=conf_matrix)
+disp.plot(cmap=plt.cm.Blues)
+plt.title('Confusion Matrix')
+plt.show()
+
+# Function to predict the product from two input SMILES
+def predict_product_from_smiles(smiles_str1, smiles_str2):
+    features1 = featurize_smiles(smiles_str1)
+    features2 = featurize_smiles(smiles_str2)
+    features = np.hstack((features1, features2))
+    feature_df = pd.DataFrame([features])
+    feature_h2o = h2o.H2OFrame(feature_df)
+    prediction = gbm_model.predict(feature_h2o)
+    predicted_value = prediction.as_data_frame()['predict'][0]
+    print(f"Predicted output for input SMILES '{smiles_str1}' + '{smiles_str2}': {predicted_value}")
+
+# Example usage
+#example_smiles1 = 'CCO'  # Replace with a first reactant SMILES string
+#example_smiles2 = 'O=O'  # Replace with a second reactant SMILES string
+#predict_product_from_smiles(example_smiles1, example_smiles2)
+
+# Shutdown H2O
+h2o.shutdown(prompt=False)

Scripts/Buchwald_prediction.py

@@ -0,0 +1,114 @@
+import matplotlib
+
+matplotlib.use('TkAgg')
+import pandas as pd
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem import AllChem
+import h2o
+from h2o.estimators import H2OGradientBoostingEstimator
+
+# Initialize H2O
+h2o.init()
+
+
+def featurize_smiles(smiles):
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        fingerprint = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024)
+        features = np.array(fingerprint)
+        return features
+    except Exception as e:
+        print(f"Error featurizing SMILES: {smiles} -> {e}")
+        return np.zeros(1024)  # Return a zero vector if there's an issue
+
+
+# Specify the input and output column indices
+input_column_index1 = 5  # Replace with index for the first reactant SMILES
+input_column_index2 = 6  # Replace with index for the second reactant SMILES
+output_column_index = 3  # Replace with your output (product) column index
+
+# Prepare a H2OFrame for the first train-test split
+file_path = '/Users/colestephens/Desktop/CodeFolders/ML_Dataset_Curation_Project/Split_data/buchwald.xlsx'
+splits = pd.ExcelFile(file_path)
+
+# Let's use the first split as an example
+train_key = 'train_split_0'
+test_key = 'test_split_0'
+
+# Read the train and test sets
+train_df = pd.read_excel(splits, sheet_name=train_key)
+test_df = pd.read_excel(splits, sheet_name=test_key)
+
+# Determine the column names using indices
+input_column_name1 = train_df.columns[input_column_index1]
+input_column_name2 = train_df.columns[input_column_index2]
+output_column_name = train_df.columns[output_column_index]
+
+# Featurize the SMILES columns for both reactants and concatenate the features
+train_features1 = np.array([featurize_smiles(smiles) for smiles in train_df[input_column_name1]])
+train_features2 = np.array([featurize_smiles(smiles) for smiles in train_df[input_column_name2]])
+train_features = np.hstack((train_features1, train_features2))
+
+test_features1 = np.array([featurize_smiles(smiles) for smiles in test_df[input_column_name1]])
+test_features2 = np.array([featurize_smiles(smiles) for smiles in test_df[input_column_name2]])
+test_features = np.hstack((test_features1, test_features2))
+
+# Print message after successful featurization
+print("Successfully converted SMILES to Morgan fingerprints for train and test sets.")
+
+# Convert to H2OFrames
+train_X = pd.DataFrame(train_features)
+test_X = pd.DataFrame(test_features)
+
+# Combine features with the target column
+train_h2o = h2o.H2OFrame(pd.concat([train_X, train_df[[output_column_name]]], axis=1))
+test_h2o = h2o.H2OFrame(pd.concat([test_X, test_df[[output_column_name]]], axis=1))
+
+# Set the target and features
+y = output_column_name
+X = train_h2o.columns[:-1]  # All columns except the last one
+
+# Initialize and train a Gradient Boosting model
+gbm_model = H2OGradientBoostingEstimator(
+    ntrees=50,
+    max_depth=6,
+    learn_rate=0.1,
+    seed=1
+)
+
+gbm_model.train(x=X, y=y, training_frame=train_h2o)
+
+
+# Function to predict the product from two input SMILES
+def predict_product_from_smiles(smiles_str1, smiles_str2):
+    # Featurize both input SMILES strings
+    features1 = featurize_smiles(smiles_str1)
+    features2 = featurize_smiles(smiles_str2)
+
+    # Concatenate the features
+    features = np.hstack((features1, features2))
+
+    # Convert to a DataFrame
+    feature_df = pd.DataFrame([features])
+
+    # Create H2OFrame from the feature DataFrame
+    feature_h2o = h2o.H2OFrame(feature_df)
+
+    # Predict using the trained model
+    prediction = gbm_model.predict(feature_h2o)
+
+    # Retrieve the first element from the prediction column
+    predicted_value = prediction.as_data_frame()['predict'][0]
+
+    # Print the prediction result
+    print(f"Predicted output for input SMILES '{smiles_str1}' + '{smiles_str2}': {predicted_value}")
+
+
+# Example usage
+example_smiles1 = 'BrC1=CC=CC=C1'  # Replace with a first reactant SMILES string
+example_smiles2 = 'NC(C1=CC=CC=C1)=O'  # Replace with a second reactant SMILES string
+predict_product_from_smiles(example_smiles1, example_smiles2)
+
+# Shutdown H2O
+h2o.shutdown(prompt=False)

Scripts/Homohydrogenation_predition.py

@@ -0,0 +1,100 @@
+import pandas as pd
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem import AllChem
+import h2o
+from h2o.estimators import H2OGradientBoostingEstimator
+
+# Initialize H2O
+h2o.init()
+
+
+def featurize_smiles(smiles):
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        # Generate a binary Morgan fingerprint with a radius of 2 and 1024 bits
+        fingerprint = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024)
+        features = np.array(fingerprint)
+        return features
+    except Exception as e:
+        print(f"Error featurizing SMILES: {smiles} -> {e}")
+        return np.zeros(1024)  # Return a zero vector if there's an issue
+
+
+# Specify the input and output column indices
+input_column_index = 5  # Replace with your SMILES input column index
+output_column_index = 3  # Replace with your output column index
+
+# Prepare a H2OFrame for the first train-test split
+file_path = '/Users/colestephens/Desktop/CodeFolders/ML_Dataset_Curation_Project/Split_data/homo_hydrogenation.xlsx'
+splits = pd.ExcelFile(file_path)
+
+# Let's use the first split as an example
+train_key = 'train_split_0'
+test_key = 'test_split_0'
+
+# Read the train and test sets
+train_df = pd.read_excel(splits, sheet_name=train_key)
+test_df = pd.read_excel(splits, sheet_name=test_key)
+
+# Determine the column names using indices
+input_column_name = train_df.columns[input_column_index]
+output_column_name = train_df.columns[output_column_index]
+
+# Featurize the SMILES columns
+train_features = np.array([featurize_smiles(smiles) for smiles in train_df[input_column_name]])
+test_features = np.array([featurize_smiles(smiles) for smiles in test_df[input_column_name]])
+
+# Print message after successful featurization
+print("Successfully converted SMILES to Morgan fingerprints for train and test sets.")
+
+# Convert to H2OFrames
+train_X = pd.DataFrame(train_features)
+test_X = pd.DataFrame(test_features)
+
+# Combine features with the target column
+train_h2o = h2o.H2OFrame(pd.concat([train_X, train_df[[output_column_name]]], axis=1))
+test_h2o = h2o.H2OFrame(pd.concat([test_X, test_df[[output_column_name]]], axis=1))
+
+# Set the target and features
+y = output_column_name
+X = train_h2o.columns[:-1]  # All columns except the last one
+
+# Initialize and train a Gradient Boosting model
+gbm_model = H2OGradientBoostingEstimator(
+    ntrees=50,  # Number of trees
+    max_depth=6,  # Maximum depth
+    learn_rate=0.1,  # Learning rate
+    seed=1  # For reproducibility
+)
+
+gbm_model.train(x=X, y=y, training_frame=train_h2o)
+
+
+# Function to predict the output from SMILES
+def predict_product_from_smiles(smiles_str):
+    # Featurize the input SMILES string
+    features = featurize_smiles(smiles_str)
+
+    # Convert to a DataFrame
+    feature_df = pd.DataFrame([features])
+
+    # Create H2OFrame from the feature DataFrame
+    feature_h2o = h2o.H2OFrame(feature_df)
+
+    # Predict using the trained model
+    prediction = gbm_model.predict(feature_h2o)
+
+    # Retrieve the first element from the prediction column
+    predicted_value = prediction.as_data_frame()['predict'][0]
+
+    # Print the prediction result
+    print(f"Predicted output for input SMILES '{smiles_str}': {predicted_value}")
+
+
+# Example usage
+example_smiles = 'C=C(CN1)C2=CC(C)=C(C)C=C2C1=O'  # Replace with a SMILES string of your choice
+predict_product_from_smiles(example_smiles)
+
+# Shutdown H2O
+h2o.shutdown(prompt=False)

Scripts/Sanitize.py

@@ -0,0 +1,43 @@
+import pandas as pd
+from rdkit import Chem
+from molvs import Standardizer
+
+# Read the CSV file
+file_path = '/Users/colestephens/Desktop/CodeFolders/ML_Dataset_Curation_Project/Final_Project_Dataset_curration/HiTEA-master/data/cleaned_datasets/ullmann.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 = ['PRODUCT_STRUCTURE', 'catalyst_1_ID_1_SMILES', 'Reactant_1_SMILES', 'reactant_2_SMILES', 'reactant_3_SMILES']  # replace with your SMILES columns
+
+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)
+
+# List the columns you want to keep in the output CSV
+columns_to_keep = ['ID', 'Product_Yield_PCT_Area_UV', 'Solvent_1_Name', 'PRODUCT_STRUCTURE', 'catalyst_1_ID_1_SMILES', 'Reactant_1_SMILES', 'reactant_2_SMILES', 'reactant_3_SMILES']  # Replace with the columns you want
+
+# Filter the DataFrame to keep only the specified columns
+filtered_df = df[columns_to_keep]
+
+# Save the sanitized SMILES back to a new CSV file
+filtered_df.to_csv('/Users/colestephens/Desktop/CodeFolders/ML_Dataset_Curation_Project/Sanitized_data/ullmann.csv', index=False)

Scripts/Test_train_split.py

@@ -0,0 +1,27 @@
+import pandas as pd
+import xlsxwriter
+from sklearn.model_selection import train_test_split
+
+# Load your prepared dataset
+file_path = '/Users/colestephens/Desktop/CodeFolders/ML_Dataset_Curation_Project/Sanitized_data/homo_hydrogenation.csv'  # Path to your sanitized CSV
+df = pd.read_csv(file_path)
+
+# Number of splits you want to create
+n_splits = 5
+
+# Initialize a writer to write multiple sheets
+output_file = '/Users/colestephens/Desktop/CodeFolders/ML_Dataset_Curation_Project/Split_data/homo_hydrogenation.xlsx'
+
+with pd.ExcelWriter(output_file, engine='xlsxwriter') as writer:
+    for split_index in range(n_splits):
+        # Perform the train-test split
+        train_df, test_df = train_test_split(df, test_size=0.2, random_state=split_index)
+
+        # Write each train and test split to separate sheets
+        train_sheet_name = f'train_split_{split_index}'
+        test_sheet_name = f'test_split_{split_index}'
+
+        train_df.to_excel(writer, sheet_name=train_sheet_name, index=False)
+        test_df.to_excel(writer, sheet_name=test_sheet_name, index=False)
+
+print(f'Train-test splits saved to {output_file}')

Scripts/homo_hydrogenation_model.py

@@ -0,0 +1,94 @@
+import matplotlib
+matplotlib.use('TkAgg')
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+from rdkit import Chem
+from rdkit.Chem import AllChem
+import h2o
+from h2o.estimators import H2OGradientBoostingEstimator
+from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
+
+# Initialize H2O
+h2o.init()
+
+def featurize_smiles(smiles):
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        # Generate a binary Morgan fingerprint with a radius of 2 and 1024 bits
+        fingerprint = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=1024)
+        features = np.array(fingerprint)
+        return features
+    except Exception as e:
+        print(f"Error featurizing SMILES: {smiles} -> {e}")
+        return np.zeros(1024)  # Return a zero vector if there's an issue
+
+# Specify the input and output column indices
+input_column_index = 5  # Replace with your SMILES input column index
+output_column_index = 3  # Replace with your output column index
+
+# Prepare a H2OFrame for the first train-test split
+file_path = '/Users/colestephens/Desktop/CodeFolders/ML_Dataset_Curation_Project/Split_data/homo_hydrogenation.xlsx'
+splits = pd.ExcelFile(file_path)
+
+# Let's use the first split as an example
+train_key = 'train_split_0'
+test_key = 'test_split_0'
+
+# Read the train and test sets
+train_df = pd.read_excel(splits, sheet_name=train_key)
+test_df = pd.read_excel(splits, sheet_name=test_key)
+
+# Determine the column names using indices
+input_column_name = train_df.columns[input_column_index]
+output_column_name = train_df.columns[output_column_index]
+
+# Featurize the SMILES columns
+train_features = np.array([featurize_smiles(smiles) for smiles in train_df[input_column_name]])
+test_features = np.array([featurize_smiles(smiles) for smiles in test_df[input_column_name]])
+
+# Print message after successful featurization
+print("Successfully converted SMILES to Morgan fingerprints for train and test sets.")
+
+# Convert to H2OFrames
+train_X = pd.DataFrame(train_features)
+test_X = pd.DataFrame(test_features)
+
+# Combine features with the target column
+train_h2o = h2o.H2OFrame(pd.concat([train_X, train_df[[output_column_name]]], axis=1))
+test_h2o = h2o.H2OFrame(pd.concat([test_X, test_df[[output_column_name]]], axis=1))
+
+# Set the target and features
+y = output_column_name
+X = train_h2o.columns[:-1]  # All columns except the last one
+
+# Initialize and train a Gradient Boosting model
+gbm_model = H2OGradientBoostingEstimator(
+    ntrees=50,  # Number of trees
+    max_depth=6,  # Maximum depth
+    learn_rate=0.1,  # Learning rate
+    seed=1  # For reproducibility
+)
+
+gbm_model.train(x=X, y=y, training_frame=train_h2o)
+
+# Evaluate model performance
+performance = gbm_model.model_performance(test_data=test_h2o)
+print(performance)
+
+# Visualization: Feature Importance
+gbm_model.varimp_plot()
+plt.show()
+
+# Visualization: Confusion Matrix
+predictions = gbm_model.predict(test_h2o).as_data_frame()
+conf_matrix = confusion_matrix(test_df[output_column_name], predictions['predict'])
+
+# Display confusion matrix
+disp = ConfusionMatrixDisplay(confusion_matrix=conf_matrix)
+disp.plot(cmap=plt.cm.Blues)
+plt.title('Confusion Matrix')
+plt.show()
+
+# H2O Shutdown (optional)
+h2o.shutdown(prompt=False)