Predicted Toxicity: Curcumin vs Methylene Blue (MB)

CODE:

#CURCUMIN TOXICITY DATA

toxicity_predictions = {

    'Hepatotoxicity': 0.69,

    'Neurotoxicity': 0.87,

    'Nephrotoxicity': 0.90,

    'Respiratory toxicity': 0.98,

    'Cardiotoxicity': 0.77,

    'Immunotoxicity': 0.96,

    'Ecotoxicity': 0.73

}

toxicity_types = list(toxicity_predictions.keys())

toxicity_probabilities = list(toxicity_predictions.values())

mb_toxicity_predictions = {

    'Hepatotoxicity': 0.875, # Human Hepatotoxicity from ADMET

    'Neurotoxicity': 0.911, # Drug-induced

    'Nephrotoxicity': 0.878, # Drug-induced Nephrotoxicity from ADMET

    'Respiratory toxicity': 0.436, # Respiratory from ADMET

    'Cardiotoxicity': 0.77, # Assumed same as Curcumin

    'Immunotoxicity': 0.098, # R

'Ecotoxicity': 0.0 # Adding Ecotoxicity for Methylene Blue, assuming 0 if no data

}

# Ensure the keys are identical to the Curcumin toxicity data

toxicity_types_mb = list(mb_toxicity_predictions.keys())

toxicity_probabilities_mb = list(mb_toxicity_predictions.values())

# Set the width of the bars

bar_width = 0.35

# Set the positions of the bars on the x-axis

r1 = np.arange(len(toxicity_types))

r2 = [x + bar_width for x in r1]

# Plotting the Toxicity Prediction

plt.figure(figsize=(12, 8))

# Make the plot for the toxicity prediction

plt.bar(r1, toxicity_probabilities, color='blue', width=bar_width, edgecolor='grey',

label='Curcumin')

plt.bar(r2, toxicity_probabilities_mb, color='green', width=bar_width, edgecolor='grey', label='Methylene Blue (MB)')

# General layout

plt.xlabel('Toxicity Type', fontsize=12)

plt.ylabel('Probability', fontsize=12)

plt.title('Predicted Toxicity: Curcumin vs Methylene Blue (MB)', fontsize=14)

plt.xticks([r + bar_width/2 for r in range(len(toxicity_types))], toxicity_types, rotation=45, ha='right', fontsize=10)

plt.ylim(0, 1.1) # Set y-axis limit from 0 to 1

plt.legend()

plt.tight_layout()

plt.savefig('toxicity_comparison_plot.png') # Save the plot as a file

plt.show()

Predicted Toxicity: Curcumin vs Methylene Blue (MB) © 2025 by DEVISE FOUNDATION is licensed under CC BY-NC-ND 4.0 

Actual vs Predicted Binding Affinity for Curcumin and Methylene Blue with TP53

CODE:

import pandas as pd

import json

from sklearn.model_selection import train_test_split

from sklearn.ensemble import RandomForestRegressor

from sklearn.metrics import mean_squared_error, r2_score

import matplotlib.pyplot as plt

import optuna

import numpy as np  # Import numpy

# Debugging: Start script execution

print("Starting script execution...")

# 1. Data Loading and Preparation

print("Loading data...")

curcumin_data = {

    'Model': list(range(1, 20)),  # Model number (1 to 19)

    'Calculated_affinity': [-7.204, -6.922, -6.488, -6.332, -6.236, -6.235, -6.234, -6.216, -6.159, -6.151,

                            -6.111, -6.052, -6.004, -5.777, -5.773, -5.663, -5.662, -5.622, -5.526]

}

curcumin_df = pd.DataFrame(curcumin_data)

curcumin_df['Molecule'] = 'Curcumin'

# Methylene Blue Binding Affinity Data (Revised)

binding_affinity_json = """

[

    {"Model": 1, "Calculated affinity (kcal/mol)": -5.074},

    {"Model": 2, "Calculated affinity (kcal/mol)": -5.073},

    {"Model": 3, "Calculated affinity (kcal/mol)": -5.031},

    {"Model": 4, "Calculated affinity (kcal/mol)": -4.927},

    {"Model": 5, "Calculated affinity (kcal/mol)": -4.807},

    {"Model": 6, "Calculated affinity (kcal/mol)": -4.766},

    {"Model": 7, "Calculated affinity (kcal/mol)": -4.753},

    {"Model": 8, "Calculated affinity (kcal/mol)": -4.751},

    {"Model": 9, "Calculated affinity (kcal/mol)": -4.735},

    {"Model": 10, "Calculated affinity (kcal/mol)": -4.666},

    {"Model": 11, "Calculated affinity (kcal/mol)": -4.656},

    {"Model": 12, "Calculated affinity (kcal/mol)": -4.621},

    {"Model": 13, "Calculated affinity (kcal/mol)": -4.472},

    {"Model": 14, "Calculated affinity (kcal/mol)": -4.436},

    {"Model": 15, "Calculated affinity (kcal/mol)": -4.399},

    {"Model": 16, "Calculated affinity (kcal/mol)": -4.390},

    {"Model": 17, "Calculated affinity (kcal/mol)": -4.351},

    {"Model": 18, "Calculated affinity (kcal/mol)": -4.266},

    {"Model": 19, "Calculated affinity (kcal/mol)": -4.245},

    {"Model": 20, "Calculated affinity (kcal/mol)": -4.127}

]

"""

binding_affinity_data = json.loads(binding_affinity_json)

mb_df = pd.DataFrame(binding_affinity_data)

mb_df['Molecule'] = 'Methylene Blue'

mb_df.rename(columns={'Calculated affinity (kcal/mol)': 'Calculated_affinity'}, inplace=True)

combined_df = pd.concat([curcumin_df, mb_df], ignore_index=True)

# Debugging: Check combined dataset

print("Combined dataset:")

print(combined_df.head())

X = combined_df[['Model']]

y = combined_df['Calculated_affinity']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Debugging: Data split check

print(f"Training set size: {len(X_train)}, Test set size: {len(X_test)}")

# Define the objective function for Optuna

def objective(trial):

    n_estimators = trial.suggest_int('n_estimators', 50, 200)

    max_depth = trial.suggest_int('max_depth', 3, 15)

    min_samples_split = trial.suggest_int('min_samples_split', 2, 10)

    model = RandomForestRegressor(n_estimators=n_estimators,

                                  max_depth=max_depth,

                                  min_samples_split=min_samples_split,

                                  random_state=42)

    model.fit(X_train, y_train)

    y_pred = model.predict(X_test)

    mse = mean_squared_error(y_test, y_pred)

    return mse

# Run Optuna optimization

study = optuna.create_study(direction='minimize')

study.optimize(objective, n_trials=50)

best_params = study.best_params

print(f"Best hyperparameters: {best_params}")

final_rf_model = RandomForestRegressor(**best_params)

final_rf_model.fit(X_train, y_train)

# Calculate performance metrics on the test set

y_pred_test = final_rf_model.predict(X_test)

mse_test = mean_squared_error(y_test, y_pred_test)

r2_test = r2_score(y_test, y_pred_test)

# Print performance metrics for the test set

print(f"Test Set Mean Squared Error (MSE): {mse_test:.4f}")

print(f"Test Set R² Score: {r2_test:.4f}")

# Make predictions on the entire dataset for plotting

combined_df['Predicted_affinity'] = final_rf_model.predict(combined_df[['Model']])

plt.figure(figsize=(12, 8))

plt.scatter(combined_df[combined_df['Molecule'] == 'Curcumin']['Calculated_affinity'],

            combined_df[combined_df['Molecule'] == 'Curcumin']['Predicted_affinity'],

            color='blue', label='Curcumin')

plt.scatter(combined_df[combined_df['Molecule'] == 'Methylene Blue']['Calculated_affinity'],

            combined_df[combined_df['Molecule'] == 'Methylene Blue']['Predicted_affinity'],

            color='green', label='Methylene Blue')

plt.plot([combined_df['Calculated_affinity'].min(), combined_df['Calculated_affinity'].max()],

           [combined_df['Calculated_affinity'].min(), combined_df['Calculated_affinity'].max()],

           linestyle='--', color='red', label='Ideal Prediction')

plt.xlabel('Actual Calculated Affinity')

plt.ylabel('Predicted Calculated Affinity')

plt.title('Actual vs Predicted Binding Affinities')

plt.legend()

plt.grid(True)

plt.tight_layout()

# Save and display plot

output_file = 'actual_vs_predicted_affinity_combined.png'

plt.savefig(output_file)

print(f"Plot saved as: {output_file}")

# Show the plot if running interactively

plt.show()

OUTPUT:

Best hyperparameters: {'n_estimators': 104, 'max_depth': 3, 'min_samples_split': 9}

Test Set Mean Squared Error (MSE): 0.6499

Test Set R² Score: -0.1061

Actual vs Predicted Binding Affinity for Curcumin and Methylene Blue with TP53 © 2025 by DEVISE FOUNDATION is licensed under CC BY-NC-ND 4.0 

Introductory video

 

DRUG EFFICACY, DOSE RESPONSE

CODE:

# Example extension to predict drug efficacy

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.ensemble import RandomForestRegressor

from sklearn.metrics import mean_squared_error

from sklearn.preprocessing import StandardScaler

from sklearn.model_selection import GridSearchCV

# Define df_original: Replace this with your actual data

data_original = {

    'Name': ['Drug_A', 'Drug_B', 'Drug_C', 'Drug_D', 'Drug_E'],  # Example drug names

    'Efficacy': [0.8, 0.6, 0.9, 0.7, 0.5],  # Example efficacy values

    'Volume ų': [1964.45, 1780.27, 488.96, 375.4, 285.7],  # Example volume values

    'Surface Ų': [2366.68, 2400.5, 833.79, 736.43, 409.39],  # Example surface area values

    'Binding Affinity': [5.2, 4.8, 6.1, 5.5, 7.2],  # Example binding affinity values

    'ADMET_Absorption': [0.8, 0.7, 0.9, 0.6, 0.5],  # Example absorption values

    'ADMET_Distribution': [0.9, 0.8, 0.7, 0.9, 0.6],  # Example distribution values

    'Toxicity': [0.1, 0.2, 0.1, 0.3, 0.2],  # Example toxicity values

}

df_original = pd.DataFrame(data_original)

# Calculate volume to surface ratio

df_original['Volume_to_Surface_Ratio'] = df_original['Volume ų'] / df_original['Surface Ų']

# Define features (X) and target (y) for efficacy prediction

X_efficacy = df_original[['Volume ų', 'Surface Ų', 'Volume_to_Surface_Ratio', 'Binding Affinity', 'ADMET_Absorption', 'ADMET_Distribution', 'Toxicity']]

y_efficacy = df_original['Efficacy']

# Split data into training and testing sets for efficacy prediction

# Since we have only 5 samples, we cannot split into train and test sets effectively.

# For demonstration purposes, we'll use all data for training.

X_train_efficacy_scaled = StandardScaler().fit_transform(X_efficacy)

y_train_efficacy = y_efficacy

# Perform hyperparameter tuning for efficacy model

# Reduced cv to 3, which is less than the number of samples (5) in X_train_efficacy

param_grid_efficacy = {

    'n_estimators': [10, 50, 100],

    'max_depth': [None, 5, 10],

    'min_samples_split': [2, 5],

    'min_samples_leaf': [1, 5]

}

grid_search_efficacy = GridSearchCV(RandomForestRegressor(), param_grid_efficacy, cv=3, scoring='neg_mean_squared_error')

grid_search_efficacy.fit(X_train_efficacy_scaled, y_train_efficacy)

# Evaluate the best efficacy model

best_model_efficacy = grid_search_efficacy.best_estimator_

print(f"Best Parameters for Efficacy Model: {grid_search_efficacy.best_params_}")

print(f"Best Score for Efficacy Model: {-grid_search_efficacy.best_score_}")

# Example prediction for drug efficacy

example_input_efficacy = pd.DataFrame({

    'Volume ų': [1000],

    'Surface Ų': [1500],

    'Volume_to_Surface_Ratio': [1000/1500],

    'Binding Affinity': [5.5],

    'ADMET_Absorption': [0.8],

    'ADMET_Distribution': [0.9],

    'Toxicity': [0.2]

})

example_input_efficacy_scaled = StandardScaler().fit_transform(example_input_efficacy)

example_prediction_efficacy = best_model_efficacy.predict(example_input_efficacy_scaled)

print(f"Example Prediction for Drug Efficacy: {example_prediction_efficacy[0]}")

OUTPUT:

Best Parameters for Efficacy Model: {'max_depth': 5, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50} Best Score for Efficacy Model: 0.025899333333333333 Example Prediction for Drug Efficacy: 0.6400000000000002

DOSE RESPONSE CURVE:

CODE:

import numpy as np

import matplotlib.pyplot as plt

# Example data for Methyle Blue and another drug

methyle_blue_concentrations = np.logspace(-6, -3, 10)  # Log concentrations

methyle_blue_responses = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90, 95])  # Example responses

other_drug_concentrations = np.logspace(-6, -3, 10)

other_drug_responses = np.array([5, 15, 25, 35, 45, 55, 65, 75, 85, 90])

# Plotting

plt.figure(figsize=(8, 6))

plt.plot(methyle_blue_concentrations, methyle_blue_responses, label='Methyle Blue')

plt.plot(other_drug_concentrations, other_drug_responses, label='Other Drug')

plt.xscale('log')  # Logarithmic scale for x-axis

plt.xlabel('Drug Concentration (M)')

plt.ylabel('Response (%)')

plt.title('Dose-Response Curve')

plt.legend()

plt.show()

DRUG EFFICACY, DOSE RESPONSE © 2025 by DEVISE FOUNDATION is licensed under CC BY-NC-ND 4.0 

Drug prediction score, drug distribution plot, drug dosages plot-curve plot (drug compound: C26H19N2O4-

 WORKFLOW:

1.

CODE:

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.ensemble import RandomForestRegressor

from sklearn.metrics import mean_squared_error

from sklearn.preprocessing import StandardScaler

# Original dataset

data_original = {

    'Name': ['P_0', 'P_1', 'P_10', 'P_11', 'P_12', 'P_13', 'P_14', 'P_15', 'P_16', 'P_17', 'P_18', 'P_19', 'P_2', 'P_20', 'P_21', 'P_22', 'P_23', 'P_24', 'P_25', 'P_26', 'P_27', 'P_28', 'P_29', 'P_3', 'P_30', 'P_31', 'P_32', 'P_33', 'P_34', 'P_35'],

    'Volume ų': [1964.45, 1780.27, 488.96, 375.4, 285.7, 249.36, 227.1, 223.24, 209.39, 206.21, 199.17, 181.23, 1230.68, 170.1, 150.57, 145.35, 136.72, 129.0, 120.37, 117.64, 117.19, 112.19, 109.24, 1155.51, 107.19, 105.38, 103.56, 101.52, 101.52, 100.15],

    'Surface Ų': [2366.68, 2400.5, 833.79, 736.43, 409.39, 377.28, 556.29, 503.26, 376.45, 429.0, 309.26, 404.76, 1564.31, 474.34, 343.34, 347.46, 294.9, 277.52, 232.13, 254.77, 184.68, 194.29, 163.88, 1702.57, 305.14, 258.94, 193.35, 152.28, 242.22, 197.91],

    'Drug Score': [0.8, 0.81, 0.8, 0.63, 0.42, 0.49, 0.39, 0.37, 0.43, 0.35, 0.52, 0.32, 0.81, 0.33, 0.29, 0.25, 0.22, 0.2, 0.19, 0.22, 0.19, 0.16, 0.2, 0.8, 0.17, 0.15, 0.18, 0.17, 0.2, 0.22],

    'Binding Affinity': [5.2, 4.8, 6.1, 5.5, 7.2, 6.5, 5.8, 6.0, 5.9, 6.2, 5.1, 6.8, 4.9, 6.4, 6.6, 6.3, 5.7, 6.9, 5.4, 6.1, 5.6, 6.7, 5.3, 4.7, 6.5, 5.9, 6.0, 5.8, 5.2, 6.4],

    'ADMET_Absorption': [0.8, 0.7, 0.9, 0.6, 0.5, 0.8, 0.7, 0.6, 0.9, 0.8, 0.7, 0.5, 0.9, 0.6, 0.8, 0.7, 0.6, 0.5, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.6],

    'ADMET_Distribution': [0.9, 0.8, 0.7, 0.9, 0.6, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.8, 0.9, 0.8, 0.9, 0.7, 0.8, 0.9, 0.8, 0.7],

    'Toxicity': [0.1, 0.2, 0.1, 0.3, 0.2, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.1, 0.3, 0.2, 0.1, 0.2, 0.3, 0.1, 0.2, 0.1, 0.3, 0.2],

}

df_original = pd.DataFrame(data_original)

df_original['Volume_to_Surface_Ratio'] = df_original['Volume ų'] / df_original['Surface Ų']

# Add new features

df_original['Molweight'] = [371.52] * len(df_original)

df_original['Number of hydrogen bond acceptors'] = [2] * len(df_original)

df_original['Number of hydrogen bond donors'] = [0] * len(df_original)

df_original['Number of atoms'] = [28] * len(df_original)

df_original['Number of bonds'] = [30] * len(df_original)

df_original['Number of rotable bonds'] = [8] * len(df_original)

df_original['Molecular refractivity'] = [119.72] * len(df_original)

df_original['Topological Polar Surface Area'] = [12.47] * len(df_original)

df_original['octanol/water partition coefficient(logP)'] = [6] * len(df_original)

df_original['Predicted LD50'] = [1190] * len(df_original)

df_original['Predicted Toxicity Class'] = [4] * len(df_original)

# Define features (X) and target (y)

X = df_original[['Volume ų', 'Surface Ų', 'Volume_to_Surface_Ratio', 'Binding Affinity', 'ADMET_Absorption', 'ADMET_Distribution', 'Toxicity', 'Molweight', 'Number of hydrogen bond acceptors', 'Number of hydrogen bond donors', 'Number of atoms', 'Number of bonds', 'Number of rotable bonds', 'Molecular refractivity', 'Topological Polar Surface Area', 'octanol/water partition coefficient(logP)', 'Predicted LD50', 'Predicted Toxicity Class']]

y = df_original['Drug Score']

# Split data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Scale features

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Hyperparameter tuning

param_grid = {

    'n_estimators': [10, 50, 100, 200],

    'max_depth': [None, 5, 10],

    'min_samples_split': [2, 5, 10],

    'min_samples_leaf': [1, 5, 10]

}

grid_search = GridSearchCV(RandomForestRegressor(), param_grid, cv=5, scoring='neg_mean_squared_error')

grid_search.fit(X_train_scaled, y_train)

print(f"Best Parameters: {grid_search.best_params_}")

print(f"Best Score: {-grid_search.best_score_}")

# Evaluate the best model

best_model = grid_search.best_estimator_

y_pred = best_model.predict(X_test_scaled)

mse = mean_squared_error(y_test, y_pred)

print(f"Mean Squared Error (MSE): {mse}")

# Example prediction

example_input = pd.DataFrame({

    'Volume ų': [1000],

    'Surface Ų': [1500],

    'Volume_to_Surface_Ratio': [1000/1500],

    'Binding Affinity': [5.5],

    'ADMET_Absorption': [0.8],

    'ADMET_Distribution': [0.9],

    'Toxicity': [0.2],

    'Molweight': [371.52],

    'Number of hydrogen bond acceptors': [2],

    'Number of hydrogen bond donors': [0],

    'Number of atoms': [28],

    'Number of bonds': [30],

    'Number of rotable bonds': [8],

    'Molecular refractivity': [119.72],

    'Topological Polar Surface Area': [12.47],

    'octanol/water partition coefficient(logP)': [6],

    'Predicted LD50': [1190],

    'Predicted Toxicity Class': [4]

})

example_input_scaled = scaler.transform(example_input)

example_prediction = best_model.predict(example_input_scaled)

print(f"Example Prediction for Drug Score: {example_prediction[0]}")

OUTPUT:

Best Parameters: {'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 200} Best Score: 0.01233636934999999 Mean Squared Error (MSE): 0.0011783112499999852 Example Prediction for Drug Score: 0.761600000000001

2.

CODE:

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.ensemble import RandomForestRegressor

from sklearn.metrics import mean_squared_error

from sklearn.preprocessing import StandardScaler

# Original dataset

data_original = {

    'Name': ['P_0', 'P_1', 'P_10', 'P_11', 'P_12', 'P_13', 'P_14', 'P_15', 'P_16', 'P_17', 'P_18', 'P_19', 'P_2', 'P_20', 'P_21', 'P_22', 'P_23', 'P_24', 'P_25', 'P_26', 'P_27', 'P_28', 'P_29', 'P_3', 'P_30', 'P_31', 'P_32', 'P_33', 'P_34', 'P_35'],

    'Volume ų': [1964.45, 1780.27, 488.96, 375.4, 285.7, 249.36, 227.1, 223.24, 209.39, 206.21, 199.17, 181.23, 1230.68, 170.1, 150.57, 145.35, 136.72, 129.0, 120.37, 117.64, 117.19, 112.19, 109.24, 1155.51, 107.19, 105.38, 103.56, 101.52, 101.52, 100.15],

    'Surface Ų': [2366.68, 2400.5, 833.79, 736.43, 409.39, 377.28, 556.29, 503.26, 376.45, 429.0, 309.26, 404.76, 1564.31, 474.34, 343.34, 347.46, 294.9, 277.52, 232.13, 254.77, 184.68, 194.29, 163.88, 1702.57, 305.14, 258.94, 193.35, 152.28, 242.22, 197.91],

    'Drug Score': [0.8, 0.81, 0.8, 0.63, 0.42, 0.49, 0.39, 0.37, 0.43, 0.35, 0.52, 0.32, 0.81, 0.33, 0.29, 0.25, 0.22, 0.2, 0.19, 0.22, 0.19, 0.16, 0.2, 0.8, 0.17, 0.15, 0.18, 0.17, 0.2, 0.22],

    'Binding Affinity': [5.2, 4.8, 6.1, 5.5, 7.2, 6.5, 5.8, 6.0, 5.9, 6.2, 5.1, 6.8, 4.9, 6.4, 6.6, 6.3, 5.7, 6.9, 5.4, 6.1, 5.6, 6.7, 5.3, 4.7, 6.5, 5.9, 6.0, 5.8, 5.2, 6.4],

    'ADMET_Absorption': [0.8, 0.7, 0.9, 0.6, 0.5, 0.8, 0.7, 0.6, 0.9, 0.8, 0.7, 0.5, 0.9, 0.6, 0.8, 0.7, 0.6, 0.5, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.6],

    'ADMET_Distribution': [0.9, 0.8, 0.7, 0.9, 0.6, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.8, 0.9, 0.8, 0.9, 0.7, 0.8, 0.9, 0.8, 0.7],

    'Toxicity': [0.1, 0.2, 0.1, 0.3, 0.2, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.1, 0.3, 0.2, 0.1, 0.2, 0.3, 0.1, 0.2, 0.1, 0.3, 0.2],

}

df_original = pd.DataFrame(data_original)

df_original['Volume_to_Surface_Ratio'] = df_original['Volume ų'] / df_original['Surface Ų']

# Define features (X) and target (y)

X_original = df_original[['Volume ų', 'Surface Ų', 'Volume_to_Surface_Ratio', 'Binding Affinity', 'ADMET_Absorption', 'ADMET_Distribution', 'Toxicity']]

y_original = df_original['Drug Score']

# Split data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X_original, y_original, test_size=0.2, random_state=42)

# Scale features

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Hyperparameter tuning

param_grid = {

    'n_estimators': [10, 50, 100, 200],

    'max_depth': [None, 5, 10],

    'min_samples_split': [2, 5, 10],

    'min_samples_leaf': [1, 5, 10]

}

grid_search = GridSearchCV(RandomForestRegressor(), param_grid, cv=5, scoring='neg_mean_squared_error')

grid_search.fit(X_train_scaled, y_train)

print(f"Best Parameters: {grid_search.best_params_}")

print(f"Best Score: {-grid_search.best_score_}")

# Evaluate the best model

best_model = grid_search.best_estimator_

y_pred = best_model.predict(X_test_scaled)

mse = mean_squared_error(y_test, y_pred)

print(f"Mean Squared Error (MSE): {mse}")

# Example prediction

example_input = pd.DataFrame({

    'Volume ų': [1000],

    'Surface Ų': [1500],

    'Volume_to_Surface_Ratio': [1000/1500],

    'Binding Affinity': [5.5],

    'ADMET_Absorption': [0.8],

    'ADMET_Distribution': [0.9],

    'Toxicity': [0.2]

})

example_input_scaled = scaler.transform(example_input)

example_prediction = best_model.predict(example_input_scaled)

print(f"Example Prediction for Drug Score: {example_prediction[0]}")

OUTPUT:

Best Parameters: {'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 10} Best Score: 0.00985881 Mean Squared Error (MSE): 0.0011596666666666671 Example Prediction for Drug Score: 0.804

3.

CODE:

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.ensemble import RandomForestRegressor

from sklearn.metrics import mean_squared_error

from sklearn.preprocessing import StandardScaler

# Define the dataset

data = {

    'Name': ['P_0', 'P_1', 'P_10', 'P_11', 'P_12', 'P_13', 'P_14', 'P_15', 'P_16', 'P_17', 'P_18', 'P_19', 'P_2', 'P_20', 'P_21', 'P_22', 'P_23', 'P_24', 'P_25', 'P_26', 'P_27', 'P_28', 'P_29', 'P_3', 'P_30', 'P_31', 'P_32', 'P_33', 'P_34', 'P_35'],

    'Volume ų': [1964.45, 1780.27, 488.96, 375.4, 285.7, 249.36, 227.1, 223.24, 209.39, 206.21, 199.17, 181.23, 1230.68, 170.1, 150.57, 145.35, 136.72, 129.0, 120.37, 117.64, 117.19, 112.19, 109.24, 1155.51, 107.19, 105.38, 103.56, 101.52, 101.52, 100.15],

    'Surface Ų': [2366.68, 2400.5, 833.79, 736.43, 409.39, 377.28, 556.29, 503.26, 376.45, 429.0, 309.26, 404.76, 1564.31, 474.34, 343.34, 347.46, 294.9, 277.52, 232.13, 254.77, 184.68, 194.29, 163.88, 1702.57, 305.14, 258.94, 193.35, 152.28, 242.22, 197.91],

    'Drug Score': [0.8, 0.81, 0.8, 0.63, 0.42, 0.49, 0.39, 0.37, 0.43, 0.35, 0.52, 0.32, 0.81, 0.33, 0.29, 0.25, 0.22, 0.2, 0.19, 0.22, 0.19, 0.16, 0.2, 0.8, 0.17, 0.15, 0.18, 0.17, 0.2, 0.22],

    'Binding Affinity': [5.2, 4.8, 6.1, 5.5, 7.2, 6.5, 5.8, 6.0, 5.9, 6.2, 5.1, 6.8, 4.9, 6.4, 6.6, 6.3, 5.7, 6.9, 5.4, 6.1, 5.6, 6.7, 5.3, 4.7, 6.5, 5.9, 6.0, 5.8, 5.2, 6.4],

    'ADMET_Absorption': [0.8, 0.7, 0.9, 0.6, 0.5, 0.8, 0.7, 0.6, 0.9, 0.8, 0.7, 0.5, 0.9, 0.6, 0.8, 0.7, 0.6, 0.5, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.6],

    'ADMET_Distribution': [0.9, 0.8, 0.7, 0.9, 0.6, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.8, 0.9, 0.8, 0.9, 0.7, 0.8, 0.9, 0.8, 0.7],

    'Toxicity': [0.1, 0.2, 0.1, 0.3, 0.2, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.1, 0.3, 0.2, 0.1, 0.2, 0.3, 0.1, 0.2, 0.1, 0.3, 0.2],

}

df = pd.DataFrame(data)

df['Volume_to_Surface_Ratio'] = df['Volume ų'] / df['Surface Ų']

# Split data into training and testing sets

X = df[['Volume ų', 'Surface Ų', 'Volume_to_Surface_Ratio', 'Binding Affinity', 'ADMET_Absorption', 'ADMET_Distribution', 'Toxicity']]

y = df['Drug Score']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Scale features

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Hyperparameter tuning

param_grid = {

    'n_estimators': [10, 50, 100, 200],

    'max_depth': [None, 5, 10],

    'min_samples_split': [2, 5, 10],

    'min_samples_leaf': [1, 5, 10]

}

grid_search = GridSearchCV(RandomForestRegressor(), param_grid, cv=5, scoring='neg_mean_squared_error')

grid_search.fit(X_train_scaled, y_train)

print(f"Best Parameters: {grid_search.best_params_}")

print(f"Best Score: {-grid_search.best_score_}")

# Evaluate the best model

best_model = grid_search.best_estimator_

y_pred = best_model.predict(X_test_scaled)

mse = mean_squared_error(y_test, y_pred)

print(f"Mean Squared Error (MSE): {mse}")

# Example prediction

example_input = pd.DataFrame({

    'Volume ų': [1000],

    'Surface Ų': [1500],

    'Volume_to_Surface_Ratio': [1000/1500],

    'Binding Affinity': [5.5],

    'ADMET_Absorption': [0.8],

    'ADMET_Distribution': [0.9],

    'Toxicity': [0.2]

})

example_input_scaled = scaler.transform(example_input)

example_prediction = best_model.predict(example_input_scaled)

print(f"Example Prediction for Drug Score: {example_prediction[0]}")

OUTPUT:

Best Parameters: {'max_depth': 5, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 10} Best Score: 0.010258961977777776 Mean Squared Error (MSE): 0.00190032407407407 Example Prediction for Drug Score: 0.772

4.

CODE:

import pandas as pd

import numpy as np

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.ensemble import RandomForestRegressor

from sklearn.metrics import mean_squared_error

from sklearn.preprocessing import StandardScaler

# Original dataset

data_original = {

    'Name': ['P_0', 'P_1', 'P_10', 'P_11', 'P_12', 'P_13', 'P_14', 'P_15', 'P_16', 'P_17', 'P_18', 'P_19', 'P_2', 'P_20', 'P_21', 'P_22', 'P_23', 'P_24', 'P_25', 'P_26', 'P_27', 'P_28', 'P_29', 'P_3', 'P_30', 'P_31', 'P_32', 'P_33', 'P_34', 'P_35'],

    'Volume ų': [1964.45, 1780.27, 488.96, 375.4, 285.7, 249.36, 227.1, 223.24, 209.39, 206.21, 199.17, 181.23, 1230.68, 170.1, 150.57, 145.35, 136.72, 129.0, 120.37, 117.64, 117.19, 112.19, 109.24, 1155.51, 107.19, 105.38, 103.56, 101.52, 101.52, 100.15],

    'Surface Ų': [2366.68, 2400.5, 833.79, 736.43, 409.39, 377.28, 556.29, 503.26, 376.45, 429.0, 309.26, 404.76, 1564.31, 474.34, 343.34, 347.46, 294.9, 277.52, 232.13, 254.77, 184.68, 194.29, 163.88, 1702.57, 305.14, 258.94, 193.35, 152.28, 242.22, 197.91],

    'Drug Score': [0.8, 0.81, 0.8, 0.63, 0.42, 0.49, 0.39, 0.37, 0.43, 0.35, 0.52, 0.32, 0.81, 0.33, 0.29, 0.25, 0.22, 0.2, 0.19, 0.22, 0.19, 0.16, 0.2, 0.8, 0.17, 0.15, 0.18, 0.17, 0.2, 0.22],

    'Binding Affinity': [5.2, 4.8, 6.1, 5.5, 7.2, 6.5, 5.8, 6.0, 5.9, 6.2, 5.1, 6.8, 4.9, 6.4, 6.6, 6.3, 5.7, 6.9, 5.4, 6.1, 5.6, 6.7, 5.3, 4.7, 6.5, 5.9, 6.0, 5.8, 5.2, 6.4],

    'ADMET_Absorption': [0.8, 0.7, 0.9, 0.6, 0.5, 0.8, 0.7, 0.6, 0.9, 0.8, 0.7, 0.5, 0.9, 0.6, 0.8, 0.7, 0.6, 0.5, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.6],

    'ADMET_Distribution': [0.9, 0.8, 0.7, 0.9, 0.6, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.6, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.8, 0.9, 0.7, 0.8, 0.9, 0.8, 0.9, 0.7, 0.8, 0.9, 0.8, 0.7],

    'Toxicity': [0.1, 0.2, 0.1, 0.3, 0.2, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2, 0.1, 0.3, 0.2, 0.1, 0.2, 0.3, 0.1, 0.2, 0.1, 0.3, 0.2],

}

df_original = pd.DataFrame(data_original)

df_original['Volume_to_Surface_Ratio'] = df_original['Volume ų'] / df_original['Surface Ų']

# Add new features

df_original['Molweight'] = [371.52] * len(df_original)

df_original['Number of hydrogen bond acceptors'] = [2] * len(df_original)

df_original['Number of hydrogen bond donors'] = [0] * len(df_original)

df_original['Number of atoms'] = [28] * len(df_original)

df_original['Number of bonds'] = [30] * len(df_original)

df_original['Number of rotable bonds'] = [8] * len(df_original)

df_original['Molecular refractivity'] = [119.72] * len(df_original)

df_original['Topological Polar Surface Area'] = [12.47] * len(df_original)

df_original['octanol/water partition coefficient(logP)'] = [6] * len(df_original)

df_original['Predicted LD50'] = [1190] * len(df_original)

df_original['Predicted Toxicity Class'] = [4] * len(df_original)

# Define features (X) and target (y)

X = df_original[['Volume ų', 'Surface Ų', 'Volume_to_Surface_Ratio', 'Binding Affinity', 'ADMET_Absorption', 'ADMET_Distribution', 'Toxicity', 'Molweight', 'Number of hydrogen bond acceptors', 'Number of hydrogen bond donors', 'Number of atoms', 'Number of bonds', 'Number of rotable bonds', 'Molecular refractivity', 'Topological Polar Surface Area', 'octanol/water partition coefficient(logP)', 'Predicted LD50', 'Predicted Toxicity Class']]

y = df_original['Drug Score']

# Split data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Scale features

scaler = StandardScaler()

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

# Hyperparameter tuning

param_grid = {

    'n_estimators': [10, 50, 100, 200],

    'max_depth': [None, 5, 10],

    'min_samples_split': [2, 5, 10],

    'min_samples_leaf': [1, 5, 10]

}

grid_search = GridSearchCV(RandomForestRegressor(), param_grid, cv=5, scoring='neg_mean_squared_error')

grid_search.fit(X_train_scaled, y_train)

print(f"Best Parameters: {grid_search.best_params_}")

print(f"Best Score: {-grid_search.best_score_}")

# Evaluate the best model

best_model = grid_search.best_estimator_

y_pred = best_model.predict(X_test_scaled)

mse = mean_squared_error(y_test, y_pred)

print(f"Mean Squared Error (MSE): {mse}")

# Example prediction

example_input = pd.DataFrame({

    'Volume ų': [1000],

    'Surface Ų': [1500],

    'Volume_to_Surface_Ratio': [1000/1500],

    'Binding Affinity': [5.5],

    'ADMET_Absorption': [0.8],

    'ADMET_Distribution': [0.9],

    'Toxicity': [0.2],

    'Molweight': [371.52],

    'Number of hydrogen bond acceptors': [2],

    'Number of hydrogen bond donors': [0],

    'Number of atoms': [28],

    'Number of bonds': [30],

    'Number of rotable bonds': [8],

    'Molecular refractivity': [119.72],

    'Topological Polar Surface Area': [12.47],

    'octanol/water partition coefficient(logP)': [6],

    'Predicted LD50': [1190],

    'Predicted Toxicity Class': [4]

})

example_input_scaled = scaler.transform(example_input)

example_prediction = best_model.predict(example_input_scaled)

print(f"Example Prediction for Drug Score: {example_prediction[0]}")

OUTPUT:

Best Parameters: {'max_depth': 5, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50} Best Score: 0.012031582081752841 Mean Squared Error (MSE): 0.0009695555129629595 Example Prediction for Drug Score: 0.7772000000000001

5.

CODE:

import matplotlib.pyplot as plt

import numpy as np

# Example data for drug distribution

drug_concentrations = {

    'Plasma': 10,

    'Liver': 50,

    'Kidney': 20,

    'Muscle': 5,

    'Fat': 15

}

# Example data for drug dosage

dosages = np.linspace(0, 100, 10)  # mg

drug_concentration_over_time = np.array([20, 40, 60, 80, 100, 80, 60, 40, 20, 10])  # mg/L

# Plot drug distribution

plt.figure(figsize=(8, 6))

plt.bar(drug_concentrations.keys(), drug_concentrations.values())

plt.xlabel('Tissue')

plt.ylabel('Drug Concentration (mg/L)')

plt.title('Drug Distribution Across Tissues')

plt.show()

# Plot drug dosage over time

plt.figure(figsize=(8, 6))

plt.plot(dosages, drug_concentration_over_time)

plt.xlabel('Dosage (mg)')

plt.ylabel('Drug Concentration Over Time (mg/L)')

plt.title('Drug Concentration Over Time at Different Dosages')

plt.show()

# 2D diagram of drug distribution

# Note: This is more conceptual and can be represented as a simple diagram

#       showing how drugs move from plasma to tissues.

# Conceptual 2D representation

plt.figure(figsize=(8, 6))

plt.scatter([1], [1], label='Plasma', marker='o', s=200)

plt.scatter([2], [1], label='Liver', marker='o', s=200)

plt.scatter([3], [1], label='Kidney', marker='o', s=200)

plt.scatter([4], [1], label='Muscle', marker='o', s=200)

plt.scatter([5], [1], label='Fat', marker='o', s=200)

plt.plot([1, 2], [1, 1], 'k-')

plt.plot([1, 3], [1, 1], 'k-')

plt.plot([1, 4], [1, 1], 'k-')

plt.plot([1, 5], [1, 1], 'k-')

plt.axis('off')

plt.legend(loc='upper right', bbox_to_anchor=(1.1, 1))

plt.title('Conceptual Drug Distribution')

plt.show()

OUTPUT:

6.

CODE:

import matplotlib.pyplot as plt

import numpy as np

# Example data for dose-response curve

doses = np.logspace(-3, 3, 100)  # Logarithmic scale for doses

responses = 1 / (1 + (10**-3 / doses)**2)  # Sigmoidal response

# Plot dose-response curve

plt.figure(figsize=(8, 6))

plt.plot(doses, responses)

plt.xscale('log')  # Logarithmic scale for x-axis

plt.xlabel('Drug Dose (log scale)')

plt.ylabel('Response')

plt.title('Dose-Response Curve')

plt.show()

# Example of plotting multiple curves for comparison

doses = np.logspace(-3, 3, 100)

responses_drug_a = 1 / (1 + (10**-2 / doses)**2)  # More potent drug

responses_drug_b = 1 / (1 + (10**-4 / doses)**2)  # Less potent drug

plt.figure(figsize=(8, 6))

plt.plot(doses, responses_drug_a, label='Drug A')

plt.plot(doses, responses_drug_b, label='Drug B')

plt.xscale('log')

plt.xlabel('Drug Dose (log scale)')

plt.ylabel('Response')

plt.title('Comparison of Dose-Response Curves')

plt.legend()

plt.show()

OUTPUT:

Drug prediction score, drug distribution plot, drug dosages plot-curve plot (drug compound: C26H19N2O4- © 2025 by DEVISE FOUNDATION is licensed under CC BY-NC-ND 4.0 

---