initial commit

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+scheme2.png filter=lfs diff=lfs merge=lfs -text

.streamlit/config.toml

@@ -0,0 +1,2 @@
+[theme]
+base="light"

app.py

@@ -0,0 +1,662 @@
+# Uncomment if run locally
+import os
+#import sys
+#sys.path.append(os.path.abspath("../../../molvault"))
+#sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from requests import head
+from concrete.ml.deployment import FHEModelClient
+import numpy
+import os
+from pathlib import Path
+import requests
+import json
+import base64
+import subprocess
+import shutil
+import time
+from chemdata import get_ECFP_AND_FEATURES
+import streamlit as st
+import subprocess
+import cairosvg
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from rdkit.Chem.Draw import rdMolDraw2D
+import pandas as pd
+from st_keyup import st_keyup
+
+st.set_page_config(layout="centered", page_title="VaultChem")
+
+
+def local_css(file_name):
+    with open(file_name) as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+
+local_css("style.css")
+
+
+def img_to_bytes(img_path):
+    img_bytes = Path(img_path).read_bytes()
+    encoded = base64.b64encode(img_bytes).decode()
+    return encoded
+
+
+def img_to_html(img_path, width=None):
+    img_bytes = img_to_bytes(img_path)
+    if width:
+        img_html = "<img src='data:image/png;base64,{}' class='img-fluid' style='width:{};'>".format(
+            img_bytes, width
+        )
+    else:
+        img_html = "<img src='data:image/png;base64,{}' class='img-fluid'>".format(
+            img_bytes
+        )
+    return img_html
+
+
+# Start timing
+formatted_text = (
+    "<h1 style='text-align: center;'>"
+    "<span style='color: red;'>Pharmacokinetics</span>"
+    "<span style='color: black;'> of </span>"
+    "<span style='color: blue;'>🤫confidential🤫</span>"
+    "<span style='color: black;'> molecules</span>"
+    "</h1>"
+)
+
+st.markdown(formatted_text, unsafe_allow_html=True)
+
+interesting_text = """
+Machine learning (**ML**) has become a cornerstone of modern drug discovery. However, the data used to evaluate the ML models is often **confidential**.
+This is especially true for the pharmaceutical industry where new drug candidates are considered as the most valuable asset.
+Therefore chemical companies are reluctant to share their data with third parties, for instance to use ML services provided by other companies.
+We developed an application that allows predicting properties of molecules **without sharing them**.
+That means an organization "A" can use any server - even an untrusted environment - outside of their infrastructure to perform the prediction.
+This way organization "A" can benefit from ML services provided by organization "B" without sharing their confidential data.
+
+🪄 **The magic?** 🪄
+
+The server on which the prediction is computed will never see the molecule in clear text, but will still compute an encrypted prediction.
+Why is this **magic**? Because this is equivalent to computing the prediction on the molecule in clear text, but without sharing the molecule with the server.
+Even if organization "B" - or in fact any other party - would try to steal the data, they would only see the encrypted molecular data.
+Only the party that has the private key (organization "A") can decrypt the prediction. This is possible using a method called "Fully homomorphic encryption" (FHE). 
+This special encryption scheme allows to perform computations on encrypted data.
+The code used for the FHE prediction is available in the open-source library <a href="https://docs.zama.ai/concrete-ml" target="_blank">Concrete ML</a>.
+\n
+**What are the steps involved?**
+\n
+Find out below! 👇 
+You can try it out yourself by entering a molecule and clicking on the buttons.
+"""
+
+st.markdown(
+    f"{interesting_text}",
+    unsafe_allow_html=True,
+)
+
+st.divider()
+
+st.markdown(
+    "<p style='text-align: center; color: grey;'>"
+    + img_to_html("scheme2.png", width="80%")
+    + "</p>",
+    unsafe_allow_html=True,
+)
+
+# Define your data
+st.divider()
+
+
+# This repository's directory
+REPO_DIR = Path(__file__).parent
+subprocess.Popen(["uvicorn", "server:app"], cwd=REPO_DIR)
+
+# if not exists, create a directory for the FHE keys called .fhe_keys
+if not os.path.exists(".fhe_keys"):
+    os.mkdir(".fhe_keys")
+# if not exists, create a directory for the tmp files called tmp
+if not os.path.exists("tmp"):
+    os.mkdir("tmp")
+
+
+# Wait 4 sec for the server to start
+time.sleep(4)
+
+# Encrypted data limit for the browser to display
+# (encrypted data is too large to display in the browser)
+ENCRYPTED_DATA_BROWSER_LIMIT = 500
+N_USER_KEY_STORED = 20
+
+
+def clean_tmp_directory():
+    # Allow 20 user keys to be stored.
+    # Once that limitation is reached, deleted the oldest.
+    path_sub_directories = sorted(
+        [f for f in Path(".fhe_keys/").iterdir() if f.is_dir()], key=os.path.getmtime
+    )
+
+    user_ids = []
+    if len(path_sub_directories) > N_USER_KEY_STORED:
+        n_files_to_delete = len(path_sub_directories) - N_USER_KEY_STORED
+        for p in path_sub_directories[:n_files_to_delete]:
+            user_ids.append(p.name)
+            shutil.rmtree(p)
+
+    list_files_tmp = Path("tmp/").iterdir()
+    # Delete all files related to user_id
+    for file in list_files_tmp:
+        for user_id in user_ids:
+            if file.name.endswith(f"{user_id}.npy"):
+                file.unlink()
+
+
+def keygen():
+    # Clean tmp directory if needed
+    clean_tmp_directory()
+
+    print("Initializing FHEModelClient...")
+    task = st.session_state["task"]
+    # Let's create a user_id
+    user_id = numpy.random.randint(0, 2**32)
+    fhe_api = FHEModelClient(f"deployment/deployment_{task}", f".fhe_keys/{user_id}")
+    fhe_api.load()
+
+    # Generate a fresh key
+    fhe_api.generate_private_and_evaluation_keys(force=True)
+    evaluation_key = fhe_api.get_serialized_evaluation_keys()
+
+    numpy.save(f"tmp/tmp_evaluation_key_{user_id}.npy", evaluation_key)
+
+    return [list(evaluation_key)[:ENCRYPTED_DATA_BROWSER_LIMIT], user_id]
+
+
+@st.cache_data
+def encode_quantize_encrypt(text, user_id):
+    task = st.session_state["task"]
+    fhe_api = FHEModelClient(f"deployment/deployment_{task}", f".fhe_keys/{user_id}")
+    fhe_api.load()
+
+    encodings = get_ECFP_AND_FEATURES(text, radius=2, bits=1024).reshape(1, -1)
+
+    quantized_encodings = fhe_api.model.quantize_input(encodings).astype(numpy.uint8)
+    encrypted_quantized_encoding = fhe_api.quantize_encrypt_serialize(encodings)
+
+    # Save encrypted_quantized_encoding in a file, since too large to pass through regular Gradio
+    # buttons, https://github.com/gradio-app/gradio/issues/1877
+    numpy.save(
+        f"tmp/tmp_encrypted_quantized_encoding_{user_id}.npy",
+        encrypted_quantized_encoding,
+    )
+
+    # Compute size
+    encrypted_quantized_encoding_shorten = list(encrypted_quantized_encoding)[
+        :ENCRYPTED_DATA_BROWSER_LIMIT
+    ]
+    encrypted_quantized_encoding_shorten_hex = "".join(
+        f"{i:02x}" for i in encrypted_quantized_encoding_shorten
+    )
+    return (
+        encodings[0],
+        quantized_encodings[0],
+        encrypted_quantized_encoding_shorten_hex,
+    )
+
+
+def run_fhe(user_id):
+    encoded_data_path = Path(f"tmp/tmp_encrypted_quantized_encoding_{user_id}.npy")
+    # if not user_id:
+    #     print("You need to generate FHE keys first.")
+    # if not encoded_data_path.is_file():
+    #     print("No encrypted data was found. Encrypt the data before trying to predict.")
+
+    # Read encrypted_quantized_encoding from the file
+
+    task = st.session_state["task"]
+    if st.session_state["fhe_prediction"] == "":
+        encrypted_quantized_encoding = numpy.load(encoded_data_path)
+
+        # Read evaluation_key from the file
+        evaluation_key = numpy.load(f"tmp/tmp_evaluation_key_{user_id}.npy")
+
+        # Use base64 to encode the encodings and evaluation key
+        encrypted_quantized_encoding = base64.b64encode(
+            encrypted_quantized_encoding
+        ).decode()
+        encoded_evaluation_key = base64.b64encode(evaluation_key).decode()
+
+        query = {}
+        query["evaluation_key"] = encoded_evaluation_key
+        query["encrypted_encoding"] = encrypted_quantized_encoding
+        headers = {"Content-type": "application/json"}
+        # pdb.set_trace()
+        if task == "0":
+            response = requests.post(
+                "http://localhost:8000/predict_HLM",
+                data=json.dumps(query),
+                headers=headers,
+            )
+        elif task == "1":
+            response = requests.post(
+                "http://localhost:8000/predict_MDR1MDCK",
+                data=json.dumps(query),
+                headers=headers,
+            )
+        elif task == "2":
+            response = requests.post(
+                "http://localhost:8000/predict_SOLUBILITY",
+                data=json.dumps(query),
+                headers=headers,
+            )
+        elif task == "3":
+            response = requests.post(
+                "http://localhost:8000/predict_PROTEIN_BINDING_HUMAN",
+                data=json.dumps(query),
+                headers=headers,
+            )
+        elif task == "4":
+            response = requests.post(
+                "http://localhost:8000/predict_PROTEIN_BINDING_RAT",
+                data=json.dumps(query),
+                headers=headers,
+            )
+        elif task == "5":
+            response = requests.post(
+                "http://localhost:8000/predict_RLM_CLint",
+                data=json.dumps(query),
+                headers=headers,
+            )
+        else:
+            print("Invalid task number")
+        # pdb.set_trace()
+        encrypted_prediction = base64.b64decode(response.json()["encrypted_prediction"])
+
+        # Save encrypted_prediction in a file, since too large to pass through regular Gradio
+        # buttons, https://github.com/gradio-app/gradio/issues/1877
+        numpy.save(f"tmp/tmp_encrypted_prediction_{user_id}.npy", encrypted_prediction)
+        encrypted_prediction_shorten = list(encrypted_prediction)[
+            :ENCRYPTED_DATA_BROWSER_LIMIT
+        ]
+        encrypted_prediction_shorten_hex = "".join(
+            f"{i:02x}" for i in encrypted_prediction_shorten
+        )
+        st.session_state["fhe_prediction"] = encrypted_prediction_shorten_hex
+
+        st.session_state["fhe_done"] = True
+
+
+def decrypt_prediction(user_id):
+    encoded_data_path = Path(f"tmp/tmp_encrypted_prediction_{user_id}.npy")
+
+    # Read encrypted_prediction from the file
+    task = st.session_state["task"]
+    if st.session_state["decryption_done"] == False:
+        encrypted_prediction = numpy.load(encoded_data_path).tobytes()
+
+        fhe_api = FHEModelClient(
+            f"deployment/deployment_{task}", f".fhe_keys/{user_id}"
+        )
+        fhe_api.load()
+
+        # We need to retrieve the private key that matches the client specs (see issue #18)
+        fhe_api.generate_private_and_evaluation_keys(force=False)
+
+        predictions = fhe_api.deserialize_decrypt_dequantize(encrypted_prediction)
+        st.session_state["decryption_done"] = True
+        st.session_state["decrypted_prediction"] = predictions
+
+
+def init_session_state():
+    if "molecule_submitted" not in st.session_state:
+        st.session_state["molecule_submitted"] = False
+
+    if "input_molecule" not in st.session_state:
+        st.session_state["input_molecule"] = ""
+
+    if "key_generated" not in st.session_state:
+        st.session_state["key_generated"] = False
+
+    if "evaluation_key" not in st.session_state:
+        st.session_state["evaluation_key"] = []
+
+    if "user_id" not in st.session_state:
+        st.session_state["user_id"] = -100
+
+    if "encrypt" not in st.session_state:
+        st.session_state["encrypt"] = False
+
+    if "molecule_info_list" not in st.session_state:
+        st.session_state["molecule_info_list"] = []
+
+    if "encrypt_tuple" not in st.session_state:
+        st.session_state["encrypt_tuple"] = ()
+
+    if "fhe_prediction" not in st.session_state:
+        st.session_state["fhe_prediction"] = ""
+
+    if "fhe_done" not in st.session_state:
+        st.session_state["fhe_done"] = False
+
+    if "decryption_done" not in st.session_state:
+        st.session_state["decryption_done"] = False
+    if "decrypted_prediction" not in st.session_state:
+        st.session_state[
+            "decrypted_prediction"
+        ] = ""  # actually a list of list. But python takes care as it is dynamically typed.
+
+
+def molecule_submitted(text: str = st.session_state.get("molecule_to_test", "")):
+    msg_to_user = ""
+    if len(text) == 0:
+        msg_to_user = "Enter a non-empty molecule formula."
+        molecule_present = False
+
+    elif Chem.MolFromSmiles(text) == None:
+        msg_to_user = "Invalid Molecule. Please enter a valid molecule. How about trying Aspirin or Ibuprofen?"
+        molecule_present = False
+
+    else:
+        st.session_state["molecule_submitted"] = True
+        st.session_state["input_molecule"] = text
+        molecule_present = True
+        msg_to_user = "Molecule Submitted for Prediction"
+
+    st.session_state["molecule_info_list"].clear()
+    st.session_state["molecule_info_list"].append(molecule_present)
+    st.session_state["molecule_info_list"].append(msg_to_user)
+
+
+def keygen_util():
+    if st.session_state["molecule_submitted"] == False:
+        pass
+    else:
+        if st.session_state["user_id"] == -100:
+            (st.session_state["evaluation_key"], st.session_state["user_id"]) = keygen()
+        st.session_state["key_generated"] = True
+
+
+def encrpyt_data_util():
+    if st.session_state["key_generated"] == False:
+        pass
+    else:
+        if len(st.session_state["encrypt_tuple"]) == 0:
+            st.session_state["encrypt_tuple"] = encode_quantize_encrypt(
+                st.session_state["input_molecule"], st.session_state["user_id"]
+            )
+        st.session_state["encrypt"] = True
+
+
+@st.cache_data
+def mol_to_img(mol):
+    mol = Chem.MolFromSmiles(mol)
+    mol = AllChem.RemoveHs(mol)
+    AllChem.Compute2DCoords(mol)
+    drawer = rdMolDraw2D.MolDraw2DSVG(300, 300)
+    drawer.DrawMolecule(mol)
+    drawer.FinishDrawing()
+    svg = drawer.GetDrawingText()
+    return cairosvg.svg2png(bytestring=svg.encode("utf-8"))
+
+
+def FHE_util():
+    run_fhe(st.session_state["user_id"])
+
+
+def decrypt_util():
+    decrypt_prediction(st.session_state["user_id"])
+
+
+def clear_session_state():
+    st.session_state.clear()
+
+
+# Define global variables outside main function scope.
+
+task_options = ["0", "1", "2", "3", "4", "5"]
+task_mapping = {
+    "0": "HLM",
+    "1": "MDR-1-MDCK-ER",
+    "2": "Solubility",
+    "3": "Protein bind. human",
+    "4": "Protein bind. rat",
+    "5": "RLM",
+}
+unit_mapping = {
+    "0": "(mL/min/kg)",
+    "1": " ",
+    "2": "(ug/mL)",
+    "3": " (%)",
+    "4": " (%)",
+    "5": "(mL/min/kg)",
+}
+task_options = list(task_mapping.values())
+
+# Create the dropdown menu
+data_dict = {
+    "HLM": "Human Liver Microsomes: drug is metabolized by the liver",
+    "MDR-1-MDCK-ER": "MDR-1-MDCK-ER: drug is transported by the P-glycoprotein",
+    "Solubility": "How soluble a drug is in water",
+    "Protein bind. human": "Drug binding to human plasma proteins",
+    "Protein bind. rat": "Drug binding to rat plasma proteins",
+    "RLM": "Rat Liver Microsomes: Drug metabolism by a rat liver",
+}
+
+# Convert the dictionary to a DataFrame
+data = pd.DataFrame(list(data_dict.items()), columns=["Property", "Explanation"])
+
+user_id = 0
+
+css_styling = """<style>
+.table {
+    width: 100%;
+    margin: 10px 0 20px 0;
+}
+.table-striped tbody tr:nth-of-type(odd) {
+    background-color: rgba(0,0,0,.05);
+}
+.table-hover tbody tr:hover {
+    color: #563d7c;
+    background-color: rgba(0,0,0,.075);
+}
+.table thead th, .table tbody td {
+    text-align: center;
+    max-width: 150px;  # Adjust this value as needed
+    word-wrap: break-word;
+}
+</style>"""
+
+
+if __name__ == "__main__":
+    # Set up the Streamlit interface
+    init_session_state()
+
+    with st.container():
+        st.header(":green[Start]")
+        st.text(
+            "Run all the steps in order to predict the molecule's property. Why not all steps at once? Because we want to show you the steps involved in the process."
+        )
+        st.subheader("Step 0: Which property do you want to predict?")
+        st.text(
+            "This app can predict the following properties of confidential molecules:"
+        )
+
+        # Check if 'task' is not already in session_state
+        if "task" not in st.session_state:
+            # Initialize it with the first value of your options
+            st.session_state["task"] = "0"
+
+        # Custom HTML and CSS styling
+        html = data.to_html(index=False, classes="table table-striped table-hover")
+
+        # Custom styling
+        st.markdown(css_styling, unsafe_allow_html=True)
+
+        # Display the HTML table
+        st.write(html, unsafe_allow_html=True)
+        st.text("Which to predict?")
+        selected_label = st.selectbox(
+            "Choose a property",
+            task_options,
+            index=task_options.index(task_mapping[st.session_state["task"]]),
+        )
+        st.session_state["task"] = list(task_mapping.keys())[
+            task_options.index(selected_label)
+        ]
+
+        st.subheader("Step 1: Submit a molecule")
+
+        x, y, z = st.columns(3)
+
+        with x:
+            st.text("")
+
+        with y:
+            submit_molecule = st.button(
+                "Try Aspirin",
+                on_click=molecule_submitted,
+                args=("CC(=O)OC1=CC=CC=C1C(=O)O",),
+            )
+
+        with z:
+            submit_molecule = st.button(
+                "Try Ibuprofen",
+                on_click=molecule_submitted,
+                args=("CC(Cc1ccc(cc1)C(C(=O)O)C)C",),
+            )
+
+        # Use the custom keyup component for text input
+        molecule_to_test = st_keyup(
+            label="Enter a molecular SMILES string or click on one of the buttons above",
+            value=st.session_state.get("molecule_to_test", ""),
+        )
+        submit_molecule = st.button(
+            "Submit",
+            on_click=molecule_submitted,
+            args=(molecule_to_test,),
+        )
+
+        if len(st.session_state["molecule_info_list"]) != 0:
+            if st.session_state["molecule_info_list"][0] == True:
+                st.success(st.session_state["molecule_info_list"][1])
+                mol_image = mol_to_img(st.session_state["input_molecule"])
+                # center the image
+                col1, col2, col3 = st.columns([1, 2, 1])
+                with col2:
+                    st.image(mol_image)
+                    st.caption(f"Input molecule {st.session_state['input_molecule']}")
+
+            else:
+                st.warning(st.session_state["molecule_info_list"][1], icon="⚠️")
+
+    with st.container():
+        st.subheader(
+            f"Step 2 : Generate encryption key (private to you) and an evaluation key (public)."
+        )
+        bullet_points = """
+        - Evaluation key is public and accessible by server.
+        - Private Keys are solely accessible by client for encrypting the information 
+        before sending to the server. The same key is used for decryption after FHE inference.
+        """
+        st.markdown(bullet_points, unsafe_allow_html=True)
+        button_gen_key = st.button(
+            "Click Here to generate Keys for this session", on_click=keygen_util
+        )
+        if st.session_state["key_generated"] == True:
+            st.success("Keys generated successfully", icon="🙌")
+            st.code(f'The user id for this session is {st.session_state["user_id"]} ')
+        else:
+            task = st.session_state["task"]
+            task_label = task_mapping[task]
+            st.warning(
+                f"Please submit the molecule first to test its {task_label} value",
+                icon="⚠️",
+            )
+
+    with st.container():
+        st.subheader(
+            f"Step 3 : Encrypt molecule using private key and send it to server."
+        )
+        encrypt_button = st.button("Click to Encrypt", on_click=encrpyt_data_util)
+        if st.session_state["encrypt"] == True:
+            st.success("Successfully Encrypted Data", icon="🙌")
+            st.text("The server can only see the encrypted data:")
+            st.code(
+                f"The encrypted quantized encoding is \n {st.session_state['encrypt_tuple'][2]}..."
+            )
+        else:
+            st.warning(
+                "Keys Not Yet Generated. Encryption can be done only after you generate keys."
+            )
+
+    with st.container():
+        st.subheader(f"Step 4 : Run encrypted prediction on server side.")
+        fhe_button = st.button("Click to Predict in FHE domain", on_click=FHE_util)
+        if st.session_state["fhe_done"]:
+            st.success("Prediction Done Successfuly in FHE domain", icon="🙌")
+            st.code(
+                f"The encrypted prediction is {st.session_state['fhe_prediction']}..."
+            )
+        else:
+            st.warning("Check if you have generated keys correctly.")
+
+    with st.container():
+        st.subheader(f"Step 5 : Decrypt the predictions with your private key.")
+        decrypt_button = st.button(
+            "Perform Decryption on FHE inferred prediction", on_click=decrypt_util
+        )
+        if st.session_state["decryption_done"]:
+            st.success("Decryption Done successfully!", icon="🙌")
+            value = st.session_state["decrypted_prediction"][0][0]
+            # 2 digit precision
+            value = round(value, 2)
+            unit = unit_mapping[st.session_state["task"]]
+            task_label = task_mapping[st.session_state["task"]]
+            st.code(
+                f"The Molecule {st.session_state['input_molecule']} has a {task_label} value of {value} {unit}"
+            )
+            st.toast("Session successfully completed!!!")
+        else:
+            st.warning("Check if FHE computation has been done.")
+
+    with st.container():
+        st.subheader(f"Step 6 : Reset to predict a new molecule")
+        reset_button = st.button("Click Here to Reset", on_click=clear_session_state)
+        x, y, z = st.columns(3)
+        with x:
+            st.write("")
+        with y:
+            st.markdown(
+                "<p style='text-align: center; color: grey;'>"
+                + img_to_html("VaultChem.png", width="50%")
+                + "</p>",
+                unsafe_allow_html=True,
+            )
+            st.markdown(
+                "<h6 style='text-align: center; color: grey;'>Visit our website : <a href='https://vaultchem.com/'>VaultChem</a></h6>",
+                unsafe_allow_html=True,
+            )
+            st.markdown(
+                "<h6 style='text-align: center; color: grey;'>Visit our Github Repo : <a href='https://github.com/vaultchem'>Github</a></h6>",
+                unsafe_allow_html=True,
+            )
+            st.markdown(
+                "<h6 style='text-align: center; color: grey;'>Built with <a href='https://streamlit.io/'>Streamlit</a>🎈</h6>",
+                unsafe_allow_html=True,
+            )
+        with z:
+            st.write("")
+
+
+st.markdown(
+    """
+    <div style="width: 100%; text-align: center; padding: 10px;">
+        The app was built with <a href="https://docs.zama.ai/concrete-ml" target="_blank">Concrete ML</a>,
+        an open-source library by <a href="https://www.zama.ai/" target="_blank">Zama</a>.
+    </div>
+    """,
+    unsafe_allow_html=True,
+)
+
+st.write(
+    ":red[Please Note]: The content of your app is purely for educational and illustrative purposes and is not intended for the management of sensitive information. We disclaim any liability for potential financial or other damages. This platform is not a substitute for professional health advice, diagnosis, or treatment. Health-related inquiries should be directed to qualified medical professionals. Use of this app implies acknowledgment of these terms and understanding of its intended educational use."
+)

chemdata.py

@@ -0,0 +1,340 @@
+import gzip
+import numpy as np
+import pandas as pd
+import requests
+from io import BytesIO
+from concrete.ml.deployment import FHEModelClient, FHEModelDev, FHEModelServer
+from concrete.ml.sklearn.svm import LinearSVR as LinearSVRZAMA
+from concrete.ml.sklearn import XGBClassifier as XGBClassifierZAMA
+from concrete.ml.sklearn import XGBRegressor as XGBRegressorZAMA
+from concrete.ml.sklearn import LogisticRegression as LogisticRegressionZAMA
+
+from sklearn.svm import LinearSVR as LinearSVR
+import time
+from shutil import copyfile
+from tempfile import TemporaryDirectory
+import pickle
+import os
+import time
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from rdkit.Chem import Lipinski
+import numpy as np
+from rdkit.Chem import rdMolDescriptors
+from sklearn.model_selection import train_test_split
+
+
+def convert_numpy(obj):
+    if isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    else:
+        return obj
+
+
+class OnDiskNetwork:
+    """Simulate a network on disk."""
+
+    def __init__(self):
+        # Create 3 temporary folder for server, client and dev with tempfile
+        self.server_dir = TemporaryDirectory()
+        self.client_dir = TemporaryDirectory()
+        self.dev_dir = TemporaryDirectory()
+
+    def client_send_evaluation_key_to_server(self, serialized_evaluation_keys):
+        """Send the public key to the server."""
+        with open(self.server_dir.name + "/serialized_evaluation_keys.ekl", "wb") as f:
+            f.write(serialized_evaluation_keys)
+
+    def client_send_input_to_server_for_prediction(self, encrypted_input):
+        """Send the input to the server and execute on the server in FHE."""
+        with open(self.server_dir.name + "/serialized_evaluation_keys.ekl", "rb") as f:
+            serialized_evaluation_keys = f.read()
+        time_begin = time.time()
+        encrypted_prediction = FHEModelServer(self.server_dir.name).run(
+            encrypted_input, serialized_evaluation_keys
+        )
+        time_end = time.time()
+        with open(self.server_dir.name + "/encrypted_prediction.enc", "wb") as f:
+            f.write(encrypted_prediction)
+        return time_end - time_begin
+
+    def dev_send_model_to_server(self):
+        """Send the model to the server."""
+        copyfile(
+            self.dev_dir.name + "/server.zip", self.server_dir.name + "/server.zip"
+        )
+
+    def server_send_encrypted_prediction_to_client(self):
+        """Send the encrypted prediction to the client."""
+        with open(self.server_dir.name + "/encrypted_prediction.enc", "rb") as f:
+            encrypted_prediction = f.read()
+        return encrypted_prediction
+
+    def dev_send_clientspecs_and_modelspecs_to_client(self):
+        """Send the clientspecs and evaluation key to the client."""
+        copyfile(
+            self.dev_dir.name + "/client.zip", self.client_dir.name + "/client.zip"
+        )
+
+    def cleanup(self):
+        """Clean up the temporary folders."""
+        self.server_dir.cleanup()
+        self.client_dir.cleanup()
+        self.dev_dir.cleanup()
+
+
+def generate_fingerprint(smiles, radius=2, bits=512):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return np.nan
+
+    fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=radius, nBits=bits)
+
+    return np.array(fp)
+
+
+def compute_descriptors_from_smiles(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+    MDlist = []
+
+    MDlist.append(rdMolDescriptors.CalcTPSA(mol))
+    MDlist.append(rdMolDescriptors.CalcFractionCSP3(mol))
+    MDlist.append(rdMolDescriptors.CalcNumAliphaticCarbocycles(mol))
+    MDlist.append(rdMolDescriptors.CalcNumAliphaticHeterocycles(mol))
+    MDlist.append(rdMolDescriptors.CalcNumAliphaticRings(mol))
+    MDlist.append(rdMolDescriptors.CalcNumAmideBonds(mol))
+    MDlist.append(rdMolDescriptors.CalcNumAromaticCarbocycles(mol))
+    MDlist.append(rdMolDescriptors.CalcNumAromaticHeterocycles(mol))
+    MDlist.append(rdMolDescriptors.CalcNumAromaticRings(mol))
+    MDlist.append(rdMolDescriptors.CalcNumLipinskiHBA(mol))
+    MDlist.append(rdMolDescriptors.CalcNumLipinskiHBD(mol))
+    MDlist.append(rdMolDescriptors.CalcNumHeteroatoms(mol))
+    MDlist.append(rdMolDescriptors.CalcNumHeterocycles(mol))
+    MDlist.append(rdMolDescriptors.CalcNumRings(mol))
+    MDlist.append(rdMolDescriptors.CalcNumRotatableBonds(mol))
+    MDlist.append(rdMolDescriptors.CalcNumSaturatedCarbocycles(mol))
+    MDlist.append(rdMolDescriptors.CalcNumSaturatedHeterocycles(mol))
+    MDlist.append(rdMolDescriptors.CalcNumSaturatedRings(mol))
+    MDlist.append(rdMolDescriptors.CalcHallKierAlpha(mol))
+    MDlist.append(rdMolDescriptors.CalcKappa1(mol))
+    MDlist.append(rdMolDescriptors.CalcKappa2(mol))
+    MDlist.append(rdMolDescriptors.CalcKappa3(mol))
+    MDlist.append(rdMolDescriptors.CalcChi0n(mol))
+    MDlist.append(rdMolDescriptors.CalcChi0v(mol))
+    MDlist.append(rdMolDescriptors.CalcChi1n(mol))
+    MDlist.append(rdMolDescriptors.CalcChi1v(mol))
+    MDlist.append(rdMolDescriptors.CalcChi2n(mol))
+    MDlist.append(rdMolDescriptors.CalcChi2v(mol))
+    MDlist.append(rdMolDescriptors.CalcChi3n(mol))
+    MDlist.append(rdMolDescriptors.CalcChi3v(mol))
+    MDlist.append(rdMolDescriptors.CalcChi4n(mol))
+    MDlist.append(rdMolDescriptors.CalcChi4v(mol))
+    MDlist.append(rdMolDescriptors.CalcExactMolWt(mol) / 100)
+    MDlist.append(Lipinski.HeavyAtomCount(mol))
+    MDlist.append(Lipinski.NumHAcceptors(mol))
+    MDlist.append(Lipinski.NumHDonors(mol))
+    MDlist.append(Lipinski.NOCount(mol))
+
+    return MDlist
+
+
+def get_ECFP_AND_FEATURES(smiles, radius=2, bits=512):
+    fp = generate_fingerprint(smiles, radius=radius, bits=bits)
+    MDlist = np.array(compute_descriptors_from_smiles(smiles))
+    return np.hstack([MDlist, fp])
+
+
+def compute_descriptors_from_smiles_list(SMILES):
+    X = [compute_descriptors_from_smiles(smi) for smi in SMILES]
+    return np.array(X)
+
+
+class ProcessToxChemData:
+    def __init__(self, bits=256):
+        self.bits = int(bits)
+        if not os.path.exists("data"):
+            os.makedirs("data")
+        self.save_file = "data/" + "save_file_Tox" + str(self.bits) + ".pkl"
+
+        if os.path.exists(self.save_file):
+            with open(self.save_file, "rb") as file:
+                self.adjusted_valid_entries_per_task = pickle.load(file)
+        else:
+            url = "https://github.com/deepchem/deepchem/blob/master/datasets/tox21.csv.gz?raw=true"
+            response = requests.get(url)
+            content = gzip.decompress(response.content)
+            self.df = pd.read_csv(BytesIO(content))
+            self.process()
+            self.save_adjusted_data()
+
+    def process(self):
+        self.adjusted_valid_entries_per_task = {}
+
+        # Iterating through each task column and extracting valid entries
+        for task in self.df.columns[
+            :-2
+        ]:  # Excluding mol_id and smiles from the iteration
+            valid_entries = self.df.dropna(subset=[task])[["mol_id", "smiles", task]]
+
+            valid_entries["fps"] = valid_entries["smiles"].apply(
+                lambda x: generate_fingerprint(x, radius=2, bits=self.bits)
+            )
+            valid_entries = valid_entries.dropna(subset=["fps"])
+            valid_entries["descriptors"] = valid_entries["smiles"].apply(
+                lambda x: compute_descriptors_from_smiles_list([x])[0]
+            )
+            valid_entries = valid_entries.dropna(subset=["descriptors"])
+            # Shuffle the rows
+            valid_entries = valid_entries.sample(frac=1, random_state=42).reset_index(
+                drop=True
+            )
+            self.adjusted_valid_entries_per_task[task] = valid_entries
+            self.adjusted_valid_entries_per_task[
+                task
+            ] = self.adjusted_valid_entries_per_task[task].rename(columns={task: "y"})
+
+    def save_adjusted_data(self):
+        with open(self.save_file, "wb") as file:
+            pickle.dump(self.adjusted_valid_entries_per_task, file)
+
+    def get_X_y(self, task):
+        X = np.float_(np.stack(self.adjusted_valid_entries_per_task[task].fps.values))
+        y = self.adjusted_valid_entries_per_task[task].y.values.astype(int)
+        return X, y
+
+
+class ProcessADMEChemData:
+    def __init__(self, bits=512, radius=2):
+        self.bits = int(bits)
+        self.radius = int(radius)
+        if not os.path.exists("data"):
+            os.makedirs("data")
+        self.save_file = "data/" + "save_file_ADME_{}_{}.pkl".format(
+            self.bits, self.radius
+        )
+
+        if os.path.exists(self.save_file):
+            with open(self.save_file, "rb") as file:
+                self.adjusted_valid_entries_per_task = pickle.load(file)
+        else:
+            url = "https://raw.githubusercontent.com/molecularinformatics/Computational-ADME/main/ADME_public_set_3521.csv"
+            self.df = pd.read_csv(url)
+            self.all_tasks = self.df.columns[4:].values
+            self.process()
+            self.save_adjusted_data()
+
+    def process(self):
+        SMILES = self.df["SMILES"].values
+        MOLS = [Chem.MolFromSmiles(smi) for smi in SMILES]
+        self.df["MOL"] = MOLS
+        self.df["smiles"] = [Chem.MolToSmiles(mol) for mol in MOLS]
+        self.adjusted_valid_entries_per_task = {}
+
+        # Iterating through each task column and extracting valid entries
+        for task in self.all_tasks:  # Excluding mol_id and smiles from the iteration
+            valid_entries = self.df.dropna(subset=[task])[["Vendor ID", "smiles", task]]
+
+            valid_entries["fps"] = valid_entries["smiles"].apply(
+                lambda x: generate_fingerprint(x, radius=self.radius, bits=self.bits)
+            )
+            valid_entries = valid_entries.dropna(subset=["fps"])
+
+            valid_entries["descriptors"] = valid_entries["smiles"].apply(
+                lambda x: compute_descriptors_from_smiles_list([x])[0]
+            )
+
+            valid_entries = valid_entries.dropna(subset=["descriptors"])
+
+            ## now stack the fps and descriptors
+            valid_entries["combined"] = valid_entries.apply(
+                lambda row: np.hstack([row["descriptors"], row["fps"]]), axis=1
+            )
+            valid_entries = valid_entries.sample(frac=1, random_state=42).reset_index(
+                drop=True
+            )
+            self.adjusted_valid_entries_per_task[task] = valid_entries
+            self.adjusted_valid_entries_per_task[
+                task
+            ] = self.adjusted_valid_entries_per_task[task].rename(columns={task: "y"})
+
+    def save_adjusted_data(self):
+        with open(self.save_file, "wb") as file:
+            pickle.dump(self.adjusted_valid_entries_per_task, file)
+
+    def get_X_y(self, task):
+        X = np.float_(
+            np.stack(self.adjusted_valid_entries_per_task[task].combined.values)
+        )
+        y = self.adjusted_valid_entries_per_task[task].y.values.astype(float)
+        return X, y
+
+
+def load_ADME_data(task, bits=256, radius=2):
+    """
+    Load and split data for a specified task in cheminformatics.
+
+    This function processes chemical data for a given task using specified parameters for bits and radius.
+    It then splits the data into training and test sets.
+
+    Parameters:
+    task (str): The specific ADME task for which data needs to be processed.
+    bits (int, optional): The number of bits to be used in the fingerprint representation. Default is 256.
+    radius (int, optional): The radius parameter for the fingerprint calculation. Default is 2.
+
+    Returns:
+    tuple: A tuple containing the split data in the form (X_train, X_test, y_train, y_test),
+           where X_train and X_test are the features and y_train and y_test are the labels.
+    """
+    data = ProcessADMEChemData(bits=bits, radius=radius)
+    X, y = data.get_X_y(task)
+    return train_test_split(X, y, test_size=0.2, random_state=42)
+
+
+class ProcessGenericChemData:
+    def __init__(self, source_file, target="y", bits=512, radius=2):
+        self.source_file = source_file
+        self.target = target
+
+        self.bits = int(bits)
+        self.radius = int(radius)
+
+        self.df = pd.read_csv(self.source_file)
+        # check if a column called y exists in the csv file
+        if self.target not in self.df.columns:
+            raise ValueError(
+                "The target column {} does not exist in the source file {}".format(
+                    self.target, self.source_file
+                )
+            )
+        
+        self.process()
+
+    def process(self):
+        self.df = self.df.dropna()
+        SMILES = self.df["SMILES"].values
+        MOLS = [Chem.MolFromSmiles(smi) for smi in SMILES]
+        self.df["MOL"] = MOLS
+        self.df["smiles"] = [Chem.MolToSmiles(mol) for mol in MOLS]
+        self.df["fps"] = self.df["SMILES"].apply(
+            lambda x: generate_fingerprint(x, radius=self.radius, bits=self.bits)
+        )
+
+    def get_X_y(self):
+        X = np.float_(np.stack(self.df.fps.values))
+        y = self.df[self.target].values.astype(float)
+
+        return X, y
+
+    def get_split(self):
+        X, y = self.get_X_y()
+        return train_test_split(X, y, test_size=0.2, random_state=42)
+
+
+# main function
+if __name__ == "__main__":
+    data = ProcessGenericChemData(source_file="output.csv")
+    X_train, X_test, y_train, y_test = data.get_split()

deployment.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f4e7563dfeeacbbef70dc9424940dd30c443bd1d893bbc2007bc8e39f6034de
+size 253119

deployment/FHE_timings.json

@@ -0,0 +1 @@
+{"XGB": [[[105, 6, 37.20693778991699], [105, 6, 35.34428858757019], [105, 6, 37.2830650806427], [85, 4, 13.173798084259033], [105, 2, 8.542397499084473], [105, 4, 17.998249530792236]], [[0.1559704232119744, 0.897851328230143], [0.10341718047857285, 0.9527195157697248], [0.11609367605659277, 0.8871980130370078], [0.10565379210897993, 0.9779407437173467], [0.07268084826007966, 0.9827499128733256], [0.12880629277037042, 0.9271080623278181]]], "SVR": [[[0.01, 0.1, 0.06072878837585449], [0.01, 0.0001, 0.054338932037353516], [0.01, 0.0001, 0.05757784843444824], [0.01, 0.1, 0.05663704872131348], [0.1, 0.001, 0.05373835563659668], [0.01, 0.001, 0.0582423210144043]], [[0.007699720908722056, 0.9999179907416972], [0.007754743773992465, 0.9999489939862338], [0.00954305425996474, 0.99978037179889], [0.010820483885872187, 0.9999680481558468], [0.01654155882523093, 0.9998339795155747], [0.01875583579391918, 0.9997520156670396]]]}

deployment/deployment_0/best_params_demo_0.json

@@ -0,0 +1 @@
+{"C": 0.01, "dual": true, "epsilon": 0.1, "loss": "squared_epsilon_insensitive", "max_iter": 40000, "tol": 0.001}

deployment/deployment_0/client.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58f74c6723ec14f0fd154aa2b5397ef0127e06a0a117dab7db05b380ec8a8f6d
+size 28720

deployment/deployment_0/server.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9938bd8f6443d8c3973297f890e6991e905bf36a622ed37991713b4e3bea0730
+size 7025

deployment/deployment_0/task_name.txt

@@ -0,0 +1 @@
+LOG HLM_CLint (mL/min/kg)

deployment/deployment_0/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5.0rc1", "concrete-ml": "1.3.0", "python": "3.10.13"}

deployment/deployment_1/best_params_demo_1.json

@@ -0,0 +1 @@
+{"C": 0.01, "dual": true, "epsilon": 0.0001, "loss": "squared_epsilon_insensitive", "max_iter": 40000, "tol": 0.001}

deployment/deployment_1/client.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97aadb6ede59e5f091d6d03c212440fbaebde15c3f374874e4e983a78407f4aa
+size 27721

deployment/deployment_1/server.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0c48867580228e736cfab70e3e5625342327f2b4e5ec4b90d816ee003aeeff3
+size 6774

deployment/deployment_1/task_name.txt

@@ -0,0 +1 @@
+LOG MDR1-MDCK ER (B-A/A-B)

deployment/deployment_1/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5.0rc1", "concrete-ml": "1.3.0", "python": "3.10.13"}

deployment/deployment_2/best_params_demo_2.json

@@ -0,0 +1 @@
+{"C": 0.01, "dual": true, "epsilon": 0.0001, "loss": "squared_epsilon_insensitive", "max_iter": 40000, "tol": 0.001}

deployment/deployment_2/client.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6373f54dd345625c75f944504ce57eaa8b0e37ef961ddda84b0e0b2718b23d45
+size 25495

deployment/deployment_2/server.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7cb19bb334f6cc51c3d53218dd87568b05c7d8020dcb71d032321ef63104fb3
+size 6905

deployment/deployment_2/task_name.txt

@@ -0,0 +1 @@
+LOG SOLUBILITY PH 6.8 (ug/mL)

deployment/deployment_2/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5.0rc1", "concrete-ml": "1.3.0", "python": "3.10.13"}

deployment/deployment_3/best_params_demo_3.json

@@ -0,0 +1 @@
+{"C": 0.01, "dual": true, "epsilon": 0.1, "loss": "epsilon_insensitive", "max_iter": 40000, "tol": 5e-05}

deployment/deployment_3/client.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ff25ea5a4058f9c9618371d442bc308ef7c34b2f7fbf6a19fc1c0a53e9d8af3
+size 11838

deployment/deployment_3/server.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1b3b1c9fd778e1cada09edd9fef7d5c31b7204cf4479f36590705c2362db9ee
+size 6651

deployment/deployment_3/task_name.txt

@@ -0,0 +1 @@
+LOG PLASMA PROTEIN BINDING (HUMAN) (% unbound)

deployment/deployment_3/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5.0rc1", "concrete-ml": "1.3.0", "python": "3.10.13"}

deployment/deployment_4/best_params_demo_4.json

@@ -0,0 +1 @@
+{"C": 0.1, "dual": true, "epsilon": 0.001, "loss": "squared_epsilon_insensitive", "max_iter": 40000, "tol": 0.001}

deployment/deployment_4/client.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64ab22745e787c42a0f384e9ebf5630b37587682f140d46b2f6dfcf7d4b65f3e
+size 11193

deployment/deployment_4/server.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a3f7e5ab94371bdbf80f1bafe407dd5bc379d05e794b5ba32acded405fbdd29
+size 6816

deployment/deployment_4/task_name.txt

@@ -0,0 +1 @@
+LOG PLASMA PROTEIN BINDING (RAT) (% unbound)

deployment/deployment_4/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5.0rc1", "concrete-ml": "1.3.0", "python": "3.10.13"}

deployment/deployment_5/best_params_demo_5.json

@@ -0,0 +1 @@
+{"C": 0.01, "dual": true, "epsilon": 0.001, "loss": "squared_epsilon_insensitive", "max_iter": 40000, "tol": 1e-05}

deployment/deployment_5/client.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60e08a87fb72835e8312ff4bd8122b3efb60bcd497481a08155fecc4b6ea0faa
+size 28427

deployment/deployment_5/server.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13634a17a986453da8459c352581c79a5f3bc431a418494266be464c680aeff3
+size 7025

deployment/deployment_5/task_name.txt

@@ -0,0 +1 @@
+LOG RLM_CLint (mL/min/kg)

deployment/deployment_5/versions.json

@@ -0,0 +1 @@
+{"concrete-python": "2.5.0rc1", "concrete-ml": "1.3.0", "python": "3.10.13"}

regress_utils.py

@@ -0,0 +1,342 @@
+import sys
+import os
+
+import numpy as np
+import random
+import json
+import shutil
+import time
+from scipy.stats import pearsonr
+from sklearn.model_selection import GridSearchCV
+from sklearn.svm import LinearSVR as LinearSVR
+from sklearn.model_selection import KFold
+from chemdata import (
+    convert_numpy,
+    LinearSVRZAMA,
+    XGBRegressorZAMA,
+    OnDiskNetwork,
+    FHEModelDev,
+    FHEModelClient,
+    get_ECFP_AND_FEATURES,
+)
+import matplotlib.pyplot as plt
+import xgboost as xgb
+
+random.seed(42)
+
+
+def hyper_opt(X_train, y_train, param_grid, regressor, verbose=10):
+    if regressor == "SVR":
+        if param_grid is None:
+            param_grid = {
+                "epsilon": [1e-2, 1e-1, 0.5],
+                "C": [1e-4,1e-3, 1e-2, 1e-1],
+                "loss": ["squared_epsilon_insensitive"],
+                "tol": [0.0001],
+                "max_iter": [50000],
+                "dual": [True],
+            }
+        regressor_fct = LinearSVR()
+    elif regressor == "XGB":
+        if param_grid is None:
+            param_grid = {
+                "max_depth": [3, 6, 10],
+                "learning_rate": [0.01, 0.1, 0.2],
+                "n_estimators": [10, 20, 50, 100],
+                "colsample_bytree": [0.3, 0.7],
+            }
+        regressor_fct = xgb.XGBRegressor(objective="reg:squarederror")
+    else:
+        raise ValueError("Unknown regressor type")
+
+    kfold = KFold(n_splits=5, shuffle=True, random_state=42)
+    grid_search = GridSearchCV(
+        estimator=regressor_fct,
+        param_grid=param_grid,
+        cv=kfold,
+        verbose=verbose,
+        n_jobs=-1,
+    )
+    grid_search.fit(X_train, y_train)
+    return (
+        grid_search.best_params_,
+        grid_search.best_score_,
+        grid_search.best_estimator_,
+    )
+
+
+def train_xgb_regressor(X_train, y_train, param_grid=None, verbose=10):
+    if param_grid is None:
+        param_grid = {
+            "max_depth": [3, 6],
+            "learning_rate": [0.01, 0.1, 0.2],
+            "n_estimators": [20],
+            "colsample_bytree": [0.3, 0.7],
+        }
+
+    xgb_regressor = xgb.XGBRegressor(objective="reg:squarederror")
+
+    kfold = KFold(n_splits=5, shuffle=True, random_state=42)
+    grid_search = GridSearchCV(
+        estimator=xgb_regressor,
+        param_grid=param_grid,
+        cv=kfold,
+        verbose=verbose,
+        n_jobs=-1,
+    )
+
+    grid_search.fit(X_train, y_train)
+    return (
+        grid_search.best_params_,
+        grid_search.best_score_,
+        grid_search.best_estimator_,
+    )
+
+
+def evaluate_model(model, X_test, y_test):
+    y_pred = model.predict(X_test)
+    pearsonr_score = pearsonr(y_test, y_pred).statistic
+    return pearsonr_score
+
+
+def performance_bits():
+    """
+    Test the model performance for different number of bits = feature vector length
+    """
+    bits = np.array([2**i for i in range(4, 12)])
+    plt.close("all")
+    fig, ax = plt.subplots()
+
+    for r in [2, 3, 4]:
+        performance = []
+        for bit in bits:
+            X_train, X_test, y_train, y_test = load_data(
+                "LOG HLM_CLint (mL/min/kg)", bits=bit, radius=r
+            )
+            param_grid = {
+                "epsilon": [0.0, 0.1, 0.2, 0.5, 1.0],
+                "C": [0.1, 1, 10, 100],
+                "loss": ["epsilon_insensitive", "squared_epsilon_insensitive"],
+                "tol": [1e-4, 1e-3, 1e-2],
+                "max_iter": [1000, 5000, 10000],
+            }
+            best_params, best_score, best_model = hyper_opt(
+                X_train, y_train, param_grid, regressor="SVR", verbose=10
+            )
+            if not os.path.exists("data"):
+                os.makedirs("data")
+
+            with open("data/best_params_{}.json".format(bit), "w") as fp:
+                json.dump(best_params, fp, default=convert_numpy)
+
+            pearsonr_score = evaluate_model(best_model, X_test, y_test)
+            performance.append(pearsonr_score)
+
+        performance = np.array(performance)
+        ax.plot(bits, performance, marker="o", label=f"radius={r}")
+
+    ax.set_xlabel("Number of Bits")
+    ax.set_ylabel("Pearson's r Correlation Coefficient")
+    ax.legend()
+    plt.grid(True)
+    if not os.path.exists("figures"):
+        os.makedirs("figures")
+    plt.savefig("figures/performance_bits.png")
+
+    return bits, performance
+
+
+def predict_fhe(model, X_test):
+    y_pred_fhe = model.predict(X_test, fhe="execute")
+    return y_pred_fhe
+
+
+def setup_network(model_dev):
+    network = OnDiskNetwork()
+    fhemodel_dev = FHEModelDev(network.dev_dir.name, model_dev)
+    fhemodel_dev.save()
+    return network, fhemodel_dev
+
+
+def copy_directory(source, destination="deployment"):
+    try:
+        # Check if the source directory exists
+        if not os.path.exists(source):
+            return False, "Source directory does not exist."
+
+        # Check if the destination directory exists
+        if not os.path.exists(destination):
+            os.makedirs(destination)
+
+        # Copy each item in the source directory
+        for item in os.listdir(source):
+            s = os.path.join(source, item)
+            d = os.path.join(destination, item)
+            if os.path.isdir(s):
+                shutil.copytree(
+                    s, d, dirs_exist_ok=True
+                )  # dirs_exist_ok is available from Python 3.8
+            else:
+                shutil.copy2(s, d)
+
+        return True, None
+
+    except Exception as e:
+        return False, str(e)
+
+
+def client_server_interaction(network, fhemodel_client, X_client):
+    decrypted_predictions = []
+    execution_time = []
+    for i in range(X_client.shape[0]):
+        clear_input = X_client[[i], :]
+        encrypted_input = fhemodel_client.quantize_encrypt_serialize(clear_input)
+        execution_time.append(
+            network.client_send_input_to_server_for_prediction(encrypted_input)
+        )
+        encrypted_prediction = network.server_send_encrypted_prediction_to_client()
+        decrypted_prediction = fhemodel_client.deserialize_decrypt_dequantize(
+            encrypted_prediction
+        )[0]
+        decrypted_predictions.append(decrypted_prediction)
+    return decrypted_predictions, execution_time
+
+
+def train_zama(X_train, y_train, best_params, regressor="SVR"):
+    if regressor == "SVR":
+        best_params["n_bits"] = 12
+        model_dev = LinearSVRZAMA(**best_params)
+    elif regressor == "XGB":
+        best_params["n_bits"] = 6
+        model_dev = XGBRegressorZAMA(**best_params)
+
+    print("Training Zama model...")
+    model_dev.fit(X_train, y_train)
+    print("compiling model...")
+    model_dev.compile(X_train)
+    print("done")
+
+    return model_dev
+
+
+def time_prediction(model, X_sample):
+    time_begin = time.time()
+    y_pred_fhe = model.predict(X_sample, fhe="execute")
+    time_end = time.time()
+    return time_end - time_begin
+
+
+def setup_client(network, key_dir):
+    fhemodel_client = FHEModelClient(network.client_dir.name, key_dir=key_dir)
+    fhemodel_client.generate_private_and_evaluation_keys()
+    serialized_evaluation_keys = fhemodel_client.get_serialized_evaluation_keys()
+    return fhemodel_client, serialized_evaluation_keys
+
+
+def compare_predictions(network, fhemodel_client, sklearn_model, X_client):
+    fhe_predictions_decrypted, _ = client_server_interaction(
+        network, fhemodel_client, X_client
+    )
+    fhe_predictions_decrypted = [
+        item for sublist in fhe_predictions_decrypted for item in sublist
+    ]
+    fhe_predictions_decrypted = np.array(fhe_predictions_decrypted)
+
+    sklearn_predictions = sklearn_model.predict(X_client)
+
+    # try:
+    mae = np.mean(
+        np.abs(sklearn_predictions.flatten() - fhe_predictions_decrypted.flatten())
+    )
+    # and pearson correlation
+    pearsonr_score = pearsonr(
+        sklearn_predictions.flatten(), fhe_predictions_decrypted.flatten()
+    ).statistic
+    # pearsons r
+    print("sklearn_predictions")
+    print(sklearn_predictions)
+    print("fhe_predictions_decrypted:")
+    print(fhe_predictions_decrypted)
+
+    print("Pearson's r between sklearn and fhe predictions: " f"{pearsonr_score:.2f}")
+
+    return mae, pearsonr_score
+
+
+def predict_ADME(network, fhemodel_client, molecule, bits=256, radius=2):
+    encodings = get_ECFP_AND_FEATURES(molecule, bits=bits, radius=radius).reshape(1, -1)
+    # generate_fingerprint(molecule, radius=radius, bits=bits).reshape(1, -1)
+    enc_inp = fhemodel_client.quantize_encrypt_serialize(encodings)
+    network.client_send_input_to_server_for_prediction(enc_inp)
+    encrypted_prediction = network.server_send_encrypted_prediction_to_client()
+    decrypted_prediction = fhemodel_client.deserialize_decrypt_dequantize(
+        encrypted_prediction
+    )
+    return np.array([decrypted_prediction])
+
+
+def fit_final_model(HYPER=True):
+    task = "LOG HLM_CLint (mL/min/kg)"
+    bits, radius = 1024, 2
+    X_train, X_test, y_train, y_test = load_data(task, bits=bits, radius=radius)
+
+    if HYPER:
+        param_grid = {
+            "epsilon": [0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.5, 0.75, 1.0],
+            "C": [0.1, 0.5, 1, 5, 10, 50, 100],
+            "loss": ["epsilon_insensitive", "squared_epsilon_insensitive"],
+            "tol": [1e-5, 5e-5, 1e-4, 5e-4, 1e-3, 5e-3, 1e-2],
+            "max_iter": [5000, 1e4, 2e4],
+        }
+        best_params, best_score, best_model = hyper_opt(
+            X_train, y_train, param_grid, regressor="SVR", verbose=10
+        )
+        with open("best_params.json", "w") as fp:
+            json.dump(best_params, fp, default=convert_numpy)
+            print(best_params)
+        pearsonr_score = evaluate_model(best_model, X_test, y_test)
+        print(pearsonr_score)
+
+    try:
+        with open("best_params.json", "r") as fp:
+            best_params = json.load(fp)
+            print(best_params)
+    except:
+        print(
+            "No hyperparameter file found. Please run function with HYPER=True first."
+        )
+        exit()
+
+    model_dev = train_zama(X_train, y_train, best_params)
+
+    prediction_time = time_prediction(model_dev, X_test[0])
+    print(f"Time to predict one sample: {prediction_time:.2f} seconds")
+
+    network, fhemodel_dev = setup_network(model_dev)
+    copied, error_message = copy_directory(network.dev_dir.name)
+    if not copied:
+        print(f"Error copying directory: {error_message}")
+
+    network.dev_send_model_to_server()
+    network.dev_send_clientspecs_and_modelspecs_to_client()
+
+    fhemodel_client, serialized_evaluation_keys = setup_client(
+        network, network.client_dir.name
+    )
+    print(f"Evaluation keys size: {len(serialized_evaluation_keys) / (10**6):.2f} MB")
+
+    network.client_send_evaluation_key_to_server(serialized_evaluation_keys)
+
+    mae_fhe, pearsonr_score_fhe = compare_predictions(
+        network, fhemodel_client, best_model, X_test[-10:]
+    )
+
+    pred = predict_with_fingerprint(
+        network, fhemodel_client, "CC(=O)OC1=CC=CC=C1C(=O)O", bits=1024, radius=2
+    )
+    print(f"Prediction: {pred}")
+
+
+if __name__ == "__main__":
+    fit_final_model(HYPER=True)
+    bits, performance = performance_bits()

requirements.txt

@@ -0,0 +1,18 @@
+concrete-ml==1.3.0
+pandas==1.4.3
+streamlit==1.29.0
+streamlit-camera-input-live==0.2.0
+streamlit-card==1.0.0
+streamlit-embedcode==0.1.2
+streamlit-extras==0.3.6
+streamlit-faker==0.0.3
+streamlit-image-coordinates==0.1.6
+streamlit-keyup==0.2.2
+streamlit-scrollable-textbox==0.0.3
+streamlit-toggle-switch==1.0.2
+streamlit-vertical-slider==1.0.2
+st-annotated-text==4.0.1
+CairoSVG==2.7.1
+rdkit-pypi==2022.9.5
+uvicorn==0.21.1
+streamlit-keyup==0.2.2

run_app.sh

@@ -0,0 +1 @@
+streamlit run app.py --server.headless=False