v2 init

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9.7
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+# preload models
+RUN python -c '\
+from transformers import BartForConditionalGeneration, AutoTokenizer;\
+AutoTokenizer.from_pretrained("ibm/materials.selfies-ted");\
+BartForConditionalGeneration.from_pretrained("ibm/materials.selfies-ted")'
+COPY . .
+
+CMD ["python", "app.py"]

Dockerfile-conda

@@ -0,0 +1,13 @@
+FROM condaforge/miniforge3
+
+WORKDIR /app
+SHELL ["/bin/bash", "-i", "-c"]
+RUN apt-get update && \
+	apt-get install -y build-essential libxrender1 libxext-dev
+RUN conda create --name fm4m python=3.9.7
+RUN conda activate fm4m
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+COPY . .
+
+CMD ["python", "app.py"]

README.md

@@ -1,8 +1,8 @@
 ---
-title: Fm4m
-emoji: 👁
-colorFrom: pink
-colorTo: purple
+title: Fix Fm4m Kit
+emoji: 🐢
+colorFrom: indigo
+colorTo: blue
 sdk: gradio
 sdk_version: 5.4.0
 app_file: app.py

app.py

@@ -1,142 +1,103 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
 import matplotlib.pyplot as plt
-from PIL import Image
-from rdkit.Chem import Descriptors, QED, Draw
-from rdkit.Chem.Crippen import MolLogP
+import numpy as np
+import os
 import pandas as pd
-from rdkit.Contrib.SA_Score import sascorer
-from rdkit.Chem import DataStructs, AllChem
-from transformers import BartForConditionalGeneration, AutoTokenizer, AutoModel
-from transformers.modeling_outputs import BaseModelOutput
+import re
 import selfies as sf
-from rdkit import Chem
 import torch
-import numpy as np
-import umap
-import pickle
 import xgboost as xgb
-from sklearn.svm import SVR
-from sklearn.linear_model import LinearRegression
+from PIL import Image
+from rdkit import Chem, RDLogger
+from rdkit.Chem import DataStructs, AllChem, Descriptors, QED, Draw
+from rdkit.Chem.Crippen import MolLogP
+from rdkit.Contrib.SA_Score import sascorer
 from sklearn.kernel_ridge import KernelRidge
-import json
-
-import os
+from sklearn.linear_model import LinearRegression
+from sklearn.svm import SVR
+from transformers import BartForConditionalGeneration, AutoTokenizer
+from transformers.modeling_outputs import BaseModelOutput
 
 os.environ["OMP_MAX_ACTIVE_LEVELS"] = "1"
 
-# my_theme = gr.Theme.from_hub("ysharma/steampunk")
-# my_theme = gr.themes.Glass()
-
-"""
-# カスタムテーマ設定
-theme = gr.themes.Default().set(
-    body_background_fill="#000000",  # 背景色を黒に設定
-    text_color="#FFFFFF",            # テキスト色を白に設定
-)
-"""
-"""
-import sys
-sys.path.append("models")
-sys.path.append("../models")
-sys.path.append("../")"""
-
-
-# Get the current file's directory
-base_dir = os.path.dirname(__file__)
-print("Base Dir : ", base_dir)
-
 import models.fm4m as fm4m
 
+RDLogger.logger().setLevel(RDLogger.ERROR)
+
 
 # Function to display molecule image from SMILES
 def smiles_to_image(smiles):
     mol = Chem.MolFromSmiles(smiles)
-    if mol:
-        img = Draw.MolToImage(mol)
-        return img
-    return None
-
-
-# Function to get canonical SMILES
-def get_canonical_smiles(smiles):
-    mol = Chem.MolFromSmiles(smiles)
-    if mol:
-        return Chem.MolToSmiles(mol, canonical=True)
-    return None
+    return Draw.MolToImage(mol) if mol else None
 
 
 # Dictionary for SMILES strings and corresponding images (you can replace with your actual image paths)
 smiles_image_mapping = {
-    "Mol 1": {"smiles": "C=C(C)CC(=O)NC[C@H](CO)NC(=O)C=Cc1ccc(C)c(Cl)c1", "image": "img/img1.png"},
+    "Mol 1": {
+        "smiles": "C=C(C)CC(=O)NC[C@H](CO)NC(=O)C=Cc1ccc(C)c(Cl)c1",
+        "image": "img/img1.png",
+    },
     # Example SMILES for ethanol
-    "Mol 2": {"smiles": "C=CC1(CC(=O)NC[C@@H](CCCC)NC(=O)c2cc(Cl)cc(Br)c2)CC1", "image": "img/img2.png"},
+    "Mol 2": {
+        "smiles": "C=CC1(CC(=O)NC[C@@H](CCCC)NC(=O)c2cc(Cl)cc(Br)c2)CC1",
+        "image": "img/img2.png",
+    },
     # Example SMILES for butane
-    "Mol 3": {"smiles": "C=C(C)C[C@H](NC(C)=O)C(=O)N1CC[C@H](NC(=O)[C@H]2C[C@@]2(C)Br)C(C)(C)C1",
-              "image": "img/img3.png"},  # Example SMILES for ethylamine
-    "Mol 4": {"smiles": "C=C1CC(CC(=O)N[C@H]2CCN(C(=O)c3ncccc3SC)C23CC3)C1", "image": "img/img4.png"},
+    "Mol 3": {
+        "smiles": "C=C(C)C[C@H](NC(C)=O)C(=O)N1CC[C@H](NC(=O)[C@H]2C[C@@]2(C)Br)C(C)(C)C1",
+        "image": "img/img3.png",
+    },  # Example SMILES for ethylamine
+    "Mol 4": {
+        "smiles": "C=C1CC(CC(=O)N[C@H]2CCN(C(=O)c3ncccc3SC)C23CC3)C1",
+        "image": "img/img4.png",
+    },
     # Example SMILES for diethyl ether
-    "Mol 5": {"smiles": "C=CCS[C@@H](C)CC(=O)OCC", "image": "img/img5.png"}  # Example SMILES for chloroethane
+    "Mol 5": {
+        "smiles": "C=CCS[C@@H](C)CC(=O)OCC",
+        "image": "img/img5.png",
+    },  # Example SMILES for chloroethane
 }
 
 datasets = [" ", "BACE", "ESOL", "Load Custom Dataset"]
 
-models_enabled = ["SELFIES-TED", "MHG-GED", "MolFormer", "SMI-TED"]
+models_enabled = [
+    "SELFIES-TED",
+    "MHG-GED",
+    "MolFormer",
+    "SMI-TED",
+    "Mordred",
+    "MorganFingerprint",
+]
 
 fusion_available = ["Concat"]
 
-global log_df
-log_df = pd.DataFrame(columns=["Selected Models", "Dataset", "Task", "Result"])
-
-
-def log_selection(models, dataset, task_type, result, log_df):
-    # Append the new entry to the DataFrame
-    new_entry = {"Selected Models": str(models), "Dataset": dataset, "Task": task_type, "Result": result}
-    updated_log_df = log_df.append(new_entry, ignore_index=True)
-    return updated_log_df
-
 
 # Function to handle evaluation and logging
-def save_rep(models, dataset, task_type, eval_output):
-    return
-def evaluate_and_log(models, dataset, task_type, eval_output):
+def evaluate_and_log(models, dataset, task_type, eval_output, state):
     task_dic = {'Classification': 'CLS', 'Regression': 'RGR'}
-    result = f"{eval_output}"#display_eval(models, dataset, task_type, fusion_type=None)
+    result = f"{eval_output}"
     result = result.replace(" Score", "")
 
-    new_entry = {"Selected Models": str(models), "Dataset": dataset, "Task": task_dic[task_type], "Result": result}
+    new_entry = {
+        "Selected Models": str(models),
+        "Dataset": dataset,
+        "Task": task_dic[task_type],
+        "Result": result,
+    }
     new_entry_df = pd.DataFrame([new_entry])
 
-    log_df = pd.read_csv('log.csv', index_col=0)
-    log_df = pd.concat([new_entry_df, log_df])
-
-    log_df.to_csv('log.csv')
-
-    return log_df
-
-
-try:
-    log_df = pd.read_csv('log.csv', index_col=0)
-except:
-    log_df = pd.DataFrame({"":[],
-    'Selected Models': [],
-    'Dataset': [],
-    'Task': [],
-    'Result': []
-        })
-    csv_file_path = 'log.csv'
-    log_df.to_csv(csv_file_path, index=False)
+    state["log_df"] = pd.concat([new_entry_df, state["log_df"]])
+    return state["log_df"]
 
 
 # Load images for selection
 def load_image(path):
     try:
-        return Image.open(smiles_image_mapping[path]["image"])# Image.1open(path)
+        return Image.open(smiles_image_mapping[path]["image"])
     except:
         pass
 
 
-
 # Function to handle image selection
 def handle_image_selection(image_key):
     smiles = smiles_image_mapping[image_key]["smiles"]
@@ -160,59 +121,55 @@ def calculate_tanimoto(smiles1, smiles2):
     mol1 = Chem.MolFromSmiles(smiles1)
     mol2 = Chem.MolFromSmiles(smiles2)
     if mol1 and mol2:
-        # fp1 = FingerprintMols.FingerprintMol(mol1)
-        # fp2 = FingerprintMols.FingerprintMol(mol2)
         fp1 = AllChem.GetMorganFingerprintAsBitVect(mol1, 2)
         fp2 = AllChem.GetMorganFingerprintAsBitVect(mol2, 2)
         return round(DataStructs.FingerprintSimilarity(fp1, fp2), 2)
     return None
 
 
-#with open("models/selfies_model/bart-2908.pickle", "rb") as input_file:
-#    gen_model, gen_tokenizer = pickle.load(input_file)
-
 gen_tokenizer = AutoTokenizer.from_pretrained("ibm/materials.selfies-ted")
 gen_model = BartForConditionalGeneration.from_pretrained("ibm/materials.selfies-ted")
 
 
 def generate(latent_vector, mask):
     encoder_outputs = BaseModelOutput(latent_vector)
-    decoder_output = gen_model.generate(encoder_outputs=encoder_outputs, attention_mask=mask,
-                                        max_new_tokens=64, do_sample=True, top_k=5, top_p=0.95, num_return_sequences=1)
+    decoder_output = gen_model.generate(
+        encoder_outputs=encoder_outputs,
+        attention_mask=mask,
+        max_new_tokens=64,
+        do_sample=True,
+        top_k=5,
+        top_p=0.95,
+        num_return_sequences=1,
+    )
     selfies = gen_tokenizer.batch_decode(decoder_output, skip_special_tokens=True)
-    outs = []
-    for i in selfies:
-        try:
-            print("Generated SELFIES : ", i)
-            decoded = sf.decoder(i.replace("] [", "]["))
-            print("Generated SMILES : ", decoded)
-            outs.append(decoded)
-        #except selfies.exceptions.DecoderError:
-        #    print(f"Error decoding SELFIES string: {i}")
-        except:
-            pass
-
-        #outs.append(sf.decoder(i.replace("] [", "][")))
-    return outs
+    return [sf.decoder(re.sub(r'\]\s*(.*?)\s*\[', r']\1[', i)) for i in selfies]
 
 
 def perturb_latent(latent_vecs, noise_scale=0.5):
-    modified_vec = torch.tensor(np.random.uniform(0, 1, latent_vecs.shape) * noise_scale,
-                                dtype=torch.float32) + latent_vecs
-    return modified_vec
+    return (
+        torch.tensor(
+            np.random.uniform(0, 1, latent_vecs.shape) * noise_scale,
+            dtype=torch.float32,
+        )
+        + latent_vecs
+    )
 
 
 def encode(selfies):
-    encoding = gen_tokenizer(selfies, return_tensors='pt', max_length=128, truncation=True, padding='max_length')
+    encoding = gen_tokenizer(
+        selfies,
+        return_tensors='pt',
+        max_length=128,
+        truncation=True,
+        padding='max_length',
+    )
     input_ids = encoding['input_ids']
     attention_mask = encoding['attention_mask']
-    outputs = gen_model.model.encoder(input_ids=input_ids, attention_mask=attention_mask)
+    outputs = gen_model.model.encoder(
+        input_ids=input_ids, attention_mask=attention_mask
+    )
     model_output = outputs.last_hidden_state
-
-    """input_mask_expanded = attention_mask.unsqueeze(-1).expand(model_output.size()).float()
-    sum_embeddings = torch.sum(model_output * input_mask_expanded, 1)
-    sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)
-    model_output = sum_embeddings / sum_mask"""
     return model_output, attention_mask
 
 
@@ -227,8 +184,13 @@ def generate_canonical(smiles):
         noise = i / 10
         perturbed_latent = perturb_latent(latent_vec, noise_scale=noise)
         gen = generate(perturbed_latent, mask)
-        gen_mol = Chem.MolToSmiles(Chem.MolFromSmiles(gen[0]))
-        if gen_mol != Chem.MolToSmiles(Chem.MolFromSmiles(smiles)): break
+        mol = Chem.MolFromSmiles(gen[0])
+        if mol:
+            gen_mol = Chem.MolToSmiles(mol)
+            if gen_mol != Chem.MolToSmiles(Chem.MolFromSmiles(smiles)):
+                break
+        else:
+            print('Abnormal molecule:', gen[0])
 
     if gen_mol:
         # Calculate properties for ref and gen molecules
@@ -240,9 +202,20 @@ def generate_canonical(smiles):
         # Prepare the table with ref mol and gen mol
         data = {
             "Property": ["QED", "SA", "LogP", "Mol Wt", "Tanimoto Similarity"],
-            "Reference Mol": [ref_properties[0], ref_properties[1], ref_properties[2], ref_properties[3],
-                              tanimoto_similarity],
-            "Generated Mol": [gen_properties[0], gen_properties[1], gen_properties[2], gen_properties[3], ""]
+            "Reference Mol": [
+                ref_properties[0],
+                ref_properties[1],
+                ref_properties[2],
+                ref_properties[3],
+                tanimoto_similarity,
+            ],
+            "Generated Mol": [
+                gen_properties[0],
+                gen_properties[1],
+                gen_properties[2],
+                gen_properties[3],
+                "",
+            ],
         }
         df = pd.DataFrame(data)
 
@@ -255,7 +228,7 @@ def generate_canonical(smiles):
 
 
 # Function to display evaluation score
-def display_eval(selected_models, dataset, task_type, downstream, fusion_type):
+def display_eval(selected_models, dataset, task_type, downstream, fusion_type, state):
     result = None
 
     try:
@@ -270,72 +243,87 @@ def display_eval(selected_models, dataset, task_type, downstream, fusion_type):
         downstream_model = downstream_model.rstrip()
         params = None
 
-
-
-
     try:
         if not selected_models:
             return "Please select at least one enabled model."
 
-        if task_type == "Classification":
-            global roc_auc, fpr, tpr, x_batch, y_batch
-        elif task_type == "Regression":
-            global RMSE, y_batch_test, y_prob
-
         if len(selected_models) > 1:
             if task_type == "Classification":
-                #result, roc_auc, fpr, tpr, x_batch, y_batch = fm4m.multi_modal(model_list=selected_models,
-                #                                                               downstream_model="XGBClassifier",
-                #                                                               dataset=dataset.lower())
                 if downstream_model == "Default Settings":
                     downstream_model = "DefaultClassifier"
                     params = None
-                result, roc_auc, fpr, tpr, x_batch, y_batch = fm4m.multi_modal(model_list=selected_models,
-                                                                                               downstream_model=downstream_model,
-                                                                                               params = params,
-                                                                                               dataset=dataset)
 
-            elif task_type == "Regression":
-                #result, RMSE, y_batch_test, y_prob = fm4m.multi_modal(model_list=selected_models,
-                #                                                      downstream_model="XGBRegressor",
-                #                                                      dataset=dataset.lower())
+                (
+                    result,
+                    state["roc_auc"],
+                    state["fpr"],
+                    state["tpr"],
+                    state["x_batch"],
+                    state["y_batch"],
+                ) = fm4m.multi_modal(
+                    model_list=selected_models,
+                    downstream_model=downstream_model,
+                    params=params,
+                    dataset=dataset,
+                )
 
+            elif task_type == "Regression":
                 if downstream_model == "Default Settings":
                     downstream_model = "DefaultRegressor"
                     params = None
 
-                result, RMSE, y_batch_test, y_prob, x_batch, y_batch = fm4m.multi_modal(model_list=selected_models,
-                                                                      downstream_model=downstream_model,
-                                                                      params=params,
-                                                                      dataset=dataset)
+                (
+                    result,
+                    state["RMSE"],
+                    state["y_batch_test"],
+                    state["y_prob"],
+                    state["x_batch"],
+                    state["y_batch"],
+                ) = fm4m.multi_modal(
+                    model_list=selected_models,
+                    downstream_model=downstream_model,
+                    params=params,
+                    dataset=dataset,
+                )
 
         else:
             if task_type == "Classification":
-                #result, roc_auc, fpr, tpr, x_batch, y_batch = fm4m.single_modal(model=selected_models[0],
-                #                                                                downstream_model="XGBClassifier",
-                #                                                                dataset=dataset.lower())
                 if downstream_model == "Default Settings":
                     downstream_model = "DefaultClassifier"
                     params = None
 
-                result, roc_auc, fpr, tpr, x_batch, y_batch = fm4m.single_modal(model=selected_models[0],
-                                                                                downstream_model=downstream_model,
-                                                                                params=params,
-                                                                                dataset=dataset)
+                (
+                    result,
+                    state["roc_auc"],
+                    state["fpr"],
+                    state["tpr"],
+                    state["x_batch"],
+                    state["y_batch"],
+                ) = fm4m.single_modal(
+                    model=selected_models[0],
+                    downstream_model=downstream_model,
+                    params=params,
+                    dataset=dataset,
+                )
 
             elif task_type == "Regression":
-                #result, RMSE, y_batch_test, y_prob = fm4m.single_modal(model=selected_models[0],
-                #                                                       downstream_model="XGBRegressor",
-                #                                                       dataset=dataset.lower())
-
                 if downstream_model == "Default Settings":
                     downstream_model = "DefaultRegressor"
                     params = None
 
-                result, RMSE, y_batch_test, y_prob, x_batch, y_batch = fm4m.single_modal(model=selected_models[0],
-                                                                       downstream_model=downstream_model,
-                                                                       params=params,
-                                                                       dataset=dataset)
+                (
+                    result,
+                    state["RMSE"],
+                    state["y_batch_test"],
+                    state["y_prob"],
+                    state["x_batch"],
+                    state["y_batch"],
+                ) = fm4m.single_modal(
+                    model=selected_models[0],
+                    downstream_model=downstream_model,
+                    params=params,
+                    dataset=dataset,
+                )
 
         if result == None:
             result = "Data & Model Setting is incorrect"
@@ -345,23 +333,15 @@ def display_eval(selected_models, dataset, task_type, downstream, fusion_type):
 
 
 # Function to handle plot display
-def display_plot(plot_type):
+def display_plot(plot_type, state):
     fig, ax = plt.subplots()
 
     if plot_type == "Latent Space":
-        global x_batch, y_batch
+        x_batch, y_batch = state.get("x_batch"), state.get("y_batch")
         ax.set_title("T-SNE Plot")
-        # reducer = umap.UMAP(metric='euclidean', n_neighbors=  10, n_components=2, low_memory=True, min_dist=0.1, verbose=False)
-        # features_umap = reducer.fit_transform(x_batch[:500])
-        # x = y_batch.values[:500]
-        # index_0 = [index for index in range(len(x)) if x[index] == 0]
-        # index_1 = [index for index in range(len(x)) if x[index] == 1]
-        class_0 = x_batch  # features_umap[index_0]
-        class_1 = y_batch  # features_umap[index_1]
-
-        """with open("latent_multi_bace.pkl", "rb") as f:
-            class_0, class_1 = pickle.load(f)
-        """
+        class_0 = x_batch
+        class_1 = y_batch
+
         plt.scatter(class_1[:, 0], class_1[:, 1], c='red', label='Class 1')
         plt.scatter(class_0[:, 0], class_0[:, 1], c='blue', label='Class 0')
 
@@ -370,10 +350,16 @@ def display_plot(plot_type):
         ax.set_title('Dataset Distribution')
 
     elif plot_type == "ROC-AUC":
-        global roc_auc, fpr, tpr
+        roc_auc, fpr, tpr = state.get("roc_auc"), state.get("fpr"), state.get("tpr")
         ax.set_title("ROC-AUC Curve")
         try:
-            ax.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.4f})')
+            ax.plot(
+                fpr,
+                tpr,
+                color='darkorange',
+                lw=2,
+                label=f'ROC curve (area = {roc_auc:.4f})',
+            )
             ax.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
             ax.set_xlim([0.0, 1.0])
             ax.set_ylim([0.0, 1.05])
@@ -385,7 +371,11 @@ def display_plot(plot_type):
         ax.legend(loc='lower right')
 
     elif plot_type == "Parity Plot":
-        global RMSE, y_batch_test, y_prob
+        RMSE, y_batch_test, y_prob = (
+            state.get("RMSE"),
+            state.get("y_batch_test"),
+            state.get("y_prob"),
+        )
         ax.set_title("Parity plot")
 
         # change format
@@ -394,7 +384,12 @@ def display_plot(plot_type):
             print(y_prob)
             y_batch_test = np.array(y_batch_test, dtype=float)
             y_prob = np.array(y_prob, dtype=float)
-            ax.scatter(y_batch_test, y_prob, color="blue", label=f"Predicted vs Actual (RMSE: {RMSE:.4f})")
+            ax.scatter(
+                y_batch_test,
+                y_prob,
+                color="blue",
+                label=f"Predicted vs Actual (RMSE: {RMSE:.4f})",
+            )
             min_val = min(min(y_batch_test), min(y_prob))
             max_val = max(max(y_batch_test), max(y_prob))
             ax.plot([min_val, max_val], [min_val, max_val], 'r-')
@@ -407,10 +402,6 @@ def display_plot(plot_type):
             print(y_batch_test)
             print(y_prob)
 
-
-
-
-
         ax.set_xlabel('Actual Values')
         ax.set_ylabel('Predicted Values')
 
@@ -429,13 +420,25 @@ predefined_datasets = {
 # Function to load a predefined dataset from the local path
 def load_predefined_dataset(dataset_name):
     val = predefined_datasets.get(dataset_name)
-    try: file_path = val.split(",")[0]
-    except:file_path=False
+    try:
+        file_path = val.split(",")[0]
+    except:
+        file_path = False
 
     if file_path:
         df = pd.read_csv(file_path)
-        return df.head(), gr.update(choices=list(df.columns)), gr.update(choices=list(df.columns)), f"{dataset_name.lower()}"
-    return pd.DataFrame(), gr.update(choices=[]), gr.update(choices=[]), f"Dataset not found"
+        return (
+            df.head(),
+            gr.update(choices=list(df.columns)),
+            gr.update(choices=list(df.columns)),
+            f"{dataset_name.lower()}",
+        )
+    return (
+        pd.DataFrame(),
+        gr.update(choices=[]),
+        gr.update(choices=[]),
+        f"Dataset not found",
+    )
 
 
 # Function to display the head of the uploaded CSV file
@@ -443,7 +446,11 @@ def display_csv_head(file):
     if file is not None:
         # Load the CSV file into a DataFrame
         df = pd.read_csv(file.name)
-        return df.head(), gr.update(choices=list(df.columns)), gr.update(choices=list(df.columns))
+        return (
+            df.head(),
+            gr.update(choices=list(df.columns)),
+            gr.update(choices=list(df.columns)),
+        )
     return pd.DataFrame(), gr.update(choices=[]), gr.update(choices=[])
 
 
@@ -451,28 +458,54 @@ def display_csv_head(file):
 def handle_dataset_selection(selected_dataset):
     if selected_dataset == "Custom Dataset":
         # Show file upload fields for train and test datasets if "Custom Dataset" is selected
-        return gr.update(visible=True), gr.update(visible=True),  gr.update(visible=True), gr.update(visible=True), gr.update(
-            visible=True), gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)
+        return (
+            gr.update(visible=True),
+            gr.update(visible=True),
+            gr.update(visible=True),
+            gr.update(visible=True),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=True),
+        )
     else:
-        return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(
-            visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+        return (
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+        )
 
 
 # Function to select input and output columns and display a message
-def select_columns(input_column, output_column, train_data, test_data,dataset_name):
+def select_columns(input_column, output_column, train_data, test_data, dataset_name):
     if input_column and output_column:
         return f"{train_data.name},{test_data.name},{input_column},{output_column},{dataset_name}"
     return "Please select both input and output columns."
 
-def set_dataname(dataset_name, dataset_selector ):
+
+def set_dataname(dataset_name, dataset_selector):
     if dataset_selector == "Custom Dataset":
         return f"{dataset_name}"
     return f"{dataset_selector}"
 
+
 # Function to create model based on user input
-def create_model(model_name, max_depth=None, n_estimators=None, alpha=None, degree=None, kernel=None):
+def create_model(
+    model_name, max_depth=None, n_estimators=None, alpha=None, degree=None, kernel=None
+):
     if model_name == "XGBClassifier":
-        model = xgb.XGBClassifier(objective='binary:logistic',eval_metric= 'auc', max_depth=max_depth, n_estimators=n_estimators, alpha=alpha)
+        model = xgb.XGBClassifier(
+            objective='binary:logistic',
+            eval_metric='auc',
+            max_depth=max_depth,
+            n_estimators=n_estimators,
+            alpha=alpha,
+        )
     elif model_name == "SVR":
         model = SVR(degree=degree, kernel=kernel)
     elif model_name == "Kernel Ridge":
@@ -486,224 +519,339 @@ def create_model(model_name, max_depth=None, n_estimators=None, alpha=None, degr
         return "Model not supported."
 
     return f"{model_name} * {model.get_params()}"
-def model_selector(model_name):
-    # Dynamically return the appropriate hyperparameter components based on the selected model
-    if model_name == "XGBClassifier":
-        return (
-            gr.Slider(1, 10, label="max_depth"),
-            gr.Slider(50, 500, label="n_estimators"),
-            gr.Slider(0.1, 10.0, step=0.1, label="alpha")
-        )
-    elif model_name == "SVR":
-        return (
-            gr.Slider(1, 5, label="degree"),
-            gr.Dropdown(["rbf", "poly", "linear"], label="kernel")
-        )
-    elif model_name == "Kernel Ridge":
-        return (
-            gr.Slider(0.1, 10.0, step=0.1, label="alpha"),
-            gr.Slider(1, 5, label="degree"),
-            gr.Dropdown(["rbf", "poly", "linear"], label="kernel")
-        )
-    elif model_name == "Linear Regression":
-        return ()  # No hyperparameters for Linear Regression
-    else:
-        return ()
-
 
 
 # Define the Gradio layout
-# with gr.Blocks(theme=my_theme) as demo:
 with gr.Blocks() as demo:
+    log_df = pd.DataFrame(
+        {"": [], 'Selected Models': [], 'Dataset': [], 'Task': [], 'Result': []}
+    )
+    state = gr.State({"log_df": log_df})
     with gr.Row():
         # Left Column
         with gr.Column():
-            gr.HTML('''
+            gr.HTML(
+                '''
            <div style="background-color: #6A8EAE; color: #FFFFFF; padding: 10px;">
                 <h3 style="color: #FFFFFF; margin: 0;font-size: 20px;"> Data & Model Setting</h3>
             </div>
-            ''')
-            # gr.Markdown("## Data & Model Setting")
-            #dataset_dropdown = gr.Dropdown(choices=datasets, label="Select Dat")
-
+            '''
+            )
             # Dropdown menu for predefined datasets including "Custom Dataset" option
-            dataset_selector = gr.Dropdown(label="Select Dataset",
-                                           choices=list(predefined_datasets.keys()) + ["Custom Dataset"])
+            dataset_selector = gr.Dropdown(
+                label="Select Dataset",
+                choices=list(predefined_datasets.keys()) + ["Custom Dataset"],
+            )
             # Display the message for selected columns
-            selected_columns_message = gr.Textbox(label="Selected Columns Info", visible=False)
+            selected_columns_message = gr.Textbox(
+                label="Selected Columns Info", visible=False
+            )
 
             with gr.Accordion("Dataset Settings", open=True):
                 # File upload options for custom dataset (train and test)
                 dataset_name = gr.Textbox(label="Dataset Name", visible=False)
-                train_file = gr.File(label="Upload Custom Train Dataset", file_types=[".csv"], visible=False)
-                train_display = gr.Dataframe(label="Train Dataset Preview (First 5 Rows)", visible=False, interactive=False)
+                train_file = gr.File(
+                    label="Upload Custom Train Dataset",
+                    file_types=[".csv"],
+                    visible=False,
+                )
+                train_display = gr.Dataframe(
+                    label="Train Dataset Preview (First 5 Rows)",
+                    visible=False,
+                    interactive=False,
+                )
 
-                test_file = gr.File(label="Upload Custom Test Dataset", file_types=[".csv"], visible=False)
-                test_display = gr.Dataframe(label="Test Dataset Preview (First 5 Rows)", visible=False, interactive=False)
+                test_file = gr.File(
+                    label="Upload Custom Test Dataset",
+                    file_types=[".csv"],
+                    visible=False,
+                )
+                test_display = gr.Dataframe(
+                    label="Test Dataset Preview (First 5 Rows)",
+                    visible=False,
+                    interactive=False,
+                )
 
                 # Predefined dataset displays
-                predefined_display = gr.Dataframe(label="Predefined Dataset Preview (First 5 Rows)", visible=False,
-                                                  interactive=False)
-
-
+                predefined_display = gr.Dataframe(
+                    label="Predefined Dataset Preview (First 5 Rows)",
+                    visible=False,
+                    interactive=False,
+                )
 
                 # Dropdowns for selecting input and output columns for the custom dataset
-                input_column_selector = gr.Dropdown(label="Select Input Column", choices=[], visible=False)
-                output_column_selector = gr.Dropdown(label="Select Output Column", choices=[], visible=False)
-
-                #selected_columns_message = gr.Textbox(label="Selected Columns Info", visible=True)
+                input_column_selector = gr.Dropdown(
+                    label="Select Input Column", choices=[], visible=False
+                )
+                output_column_selector = gr.Dropdown(
+                    label="Select Output Column", choices=[], visible=False
+                )
 
                 # When a dataset is selected, show either file upload fields (for custom) or load predefined datasets
-                dataset_selector.change(handle_dataset_selection,
-                                        inputs=dataset_selector,
-                                        outputs=[dataset_name, train_file, train_display, test_file, test_display, predefined_display,
-                                                 input_column_selector, output_column_selector])
+                dataset_selector.change(
+                    handle_dataset_selection,
+                    inputs=dataset_selector,
+                    outputs=[
+                        dataset_name,
+                        train_file,
+                        train_display,
+                        test_file,
+                        test_display,
+                        predefined_display,
+                        input_column_selector,
+                        output_column_selector,
+                    ],
+                )
 
                 # When a predefined dataset is selected, load its head and update column selectors
-                dataset_selector.change(load_predefined_dataset,
-                                        inputs=dataset_selector,
-                                        outputs=[predefined_display, input_column_selector, output_column_selector, selected_columns_message])
+                dataset_selector.change(
+                    load_predefined_dataset,
+                    inputs=dataset_selector,
+                    outputs=[
+                        predefined_display,
+                        input_column_selector,
+                        output_column_selector,
+                        selected_columns_message,
+                    ],
+                )
 
                 # When a custom train file is uploaded, display its head and update column selectors
-                train_file.change(display_csv_head, inputs=train_file,
-                                  outputs=[train_display, input_column_selector, output_column_selector])
+                train_file.change(
+                    display_csv_head,
+                    inputs=train_file,
+                    outputs=[
+                        train_display,
+                        input_column_selector,
+                        output_column_selector,
+                    ],
+                )
 
                 # When a custom test file is uploaded, display its head
-                test_file.change(display_csv_head, inputs=test_file,
-                                 outputs=[test_display, input_column_selector, output_column_selector])
+                test_file.change(
+                    display_csv_head,
+                    inputs=test_file,
+                    outputs=[
+                        test_display,
+                        input_column_selector,
+                        output_column_selector,
+                    ],
+                )
 
-                dataset_selector.change(set_dataname,
-                                    inputs=[dataset_name, dataset_selector],
-                                    outputs=dataset_name)
+                dataset_selector.change(
+                    set_dataname,
+                    inputs=[dataset_name, dataset_selector],
+                    outputs=dataset_name,
+                )
 
                 # Update the selected columns information when dropdown values are changed
-                input_column_selector.change(select_columns,
-                                             inputs=[input_column_selector, output_column_selector, train_file, test_file, dataset_name],
-                                             outputs=selected_columns_message)
-
-                output_column_selector.change(select_columns,
-                                              inputs=[input_column_selector, output_column_selector, train_file, test_file, dataset_name],
-                                              outputs=selected_columns_message)
+                input_column_selector.change(
+                    select_columns,
+                    inputs=[
+                        input_column_selector,
+                        output_column_selector,
+                        train_file,
+                        test_file,
+                        dataset_name,
+                    ],
+                    outputs=selected_columns_message,
+                )
 
-            model_checkbox = gr.CheckboxGroup(choices=models_enabled, label="Select Model")
+                output_column_selector.change(
+                    select_columns,
+                    inputs=[
+                        input_column_selector,
+                        output_column_selector,
+                        train_file,
+                        test_file,
+                        dataset_name,
+                    ],
+                    outputs=selected_columns_message,
+                )
 
-            # Add disabled checkboxes for GNN and FNN
-            # gnn_checkbox = gr.Checkbox(label="GNN (Disabled)", value=False, interactive=False)
-            # fnn_checkbox = gr.Checkbox(label="FNN (Disabled)", value=False, interactive=False)
+            model_checkbox = gr.CheckboxGroup(
+                choices=models_enabled, label="Select Model"
+            )
 
-            task_radiobutton = gr.Radio(choices=["Classification", "Regression"], label="Task Type")
+            task_radiobutton = gr.Radio(
+                choices=["Classification", "Regression"], label="Task Type"
+            )
 
             ####### adding hyper parameter tuning ###########
-            model_name = gr.Dropdown(["Default - Auto", "XGBClassifier", "SVR", "Kernel Ridge", "Linear Regression"], label="Select Downstream Model")
+            model_name = gr.Dropdown(
+                [
+                    "Default - Auto",
+                    "XGBClassifier",
+                    "SVR",
+                    "Kernel Ridge",
+                    "Linear Regression",
+                ],
+                label="Select Downstream Model",
+            )
             with gr.Accordion("Downstream Hyperparameter Settings", open=True):
                 # Create placeholders for hyperparameter components
-                max_depth = gr.Slider(1, 20, step=1,visible=False, label="max_depth")
-                n_estimators = gr.Slider(100, 5000, step=100, visible=False, label="n_estimators")
+                max_depth = gr.Slider(1, 20, step=1, visible=False, label="max_depth")
+                n_estimators = gr.Slider(
+                    100, 5000, step=100, visible=False, label="n_estimators"
+                )
                 alpha = gr.Slider(0.1, 10.0, step=0.1, visible=False, label="alpha")
-                degree = gr.Slider(1, 20, step=1,visible=False, label="degree")
-                kernel = gr.Dropdown(choices=["rbf", "poly", "linear"], visible=False, label="kernel")
+                degree = gr.Slider(1, 20, step=1, visible=False, label="degree")
+                kernel = gr.Dropdown(
+                    choices=["rbf", "poly", "linear"], visible=False, label="kernel"
+                )
 
                 # Output textbox
                 output = gr.Textbox(label="Loaded Parameters")
 
-
             # Dynamically show relevant hyperparameters based on selected model
             def update_hyperparameters(model_name):
                 if model_name == "XGBClassifier":
-                    return gr.update(visible=True), gr.update(visible=True), gr.update(visible=True), gr.update(
-                        visible=False), gr.update(visible=False)
+                    return (
+                        gr.update(visible=True),
+                        gr.update(visible=True),
+                        gr.update(visible=True),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                    )
                 elif model_name == "SVR":
-                    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(
-                        visible=True), gr.update(visible=True)
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=True),
+                        gr.update(visible=True),
+                    )
                 elif model_name == "Kernel Ridge":
-                    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True), gr.update(
-                        visible=True), gr.update(visible=True)
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=True),
+                        gr.update(visible=True),
+                        gr.update(visible=True),
+                    )
                 elif model_name == "Linear Regression":
-                    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(
-                        visible=False), gr.update(visible=False)
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                    )
                 elif model_name == "Default - Auto":
-                    return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(
-                        visible=False), gr.update(visible=False)
-
+                    return (
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                    )
 
             # When model is selected, update which hyperparameters are visible
-            model_name.change(update_hyperparameters, inputs=[model_name],
-                              outputs=[max_depth, n_estimators, alpha, degree, kernel])
+            model_name.change(
+                update_hyperparameters,
+                inputs=[model_name],
+                outputs=[max_depth, n_estimators, alpha, degree, kernel],
+            )
 
             # Submit button to create the model with selected hyperparameters
             submit_button = gr.Button("Create Downstream Model")
 
-
             # Function to handle model creation based on input parameters
             def on_submit(model_name, max_depth, n_estimators, alpha, degree, kernel):
                 if model_name == "XGBClassifier":
-                    return create_model(model_name, max_depth=max_depth, n_estimators=n_estimators, alpha=alpha)
+                    return create_model(
+                        model_name,
+                        max_depth=max_depth,
+                        n_estimators=n_estimators,
+                        alpha=alpha,
+                    )
                 elif model_name == "SVR":
                     return create_model(model_name, degree=degree, kernel=kernel)
                 elif model_name == "Kernel Ridge":
-                    return create_model(model_name, alpha=alpha, degree=degree, kernel=kernel)
+                    return create_model(
+                        model_name, alpha=alpha, degree=degree, kernel=kernel
+                    )
                 elif model_name == "Linear Regression":
                     return create_model(model_name)
                 elif model_name == "Default - Auto":
                     return create_model(model_name)
 
             # When the submit button is clicked, run the on_submit function
-            submit_button.click(on_submit, inputs=[model_name, max_depth, n_estimators, alpha, degree, kernel],
-                                outputs=output)
+            submit_button.click(
+                on_submit,
+                inputs=[model_name, max_depth, n_estimators, alpha, degree, kernel],
+                outputs=output,
+            )
             ###### End of hyper param tuning #########
 
             fusion_radiobutton = gr.Radio(choices=fusion_available, label="Fusion Type")
 
-
-
             eval_button = gr.Button("Train downstream model")
-            #eval_button.style(css_class="custom-button-left")
 
         # Middle Column
         with gr.Column():
-            gr.HTML('''
+            gr.HTML(
+                '''
            <div style="background-color: #8F9779; color: #FFFFFF; padding: 10px;">
                 <h3 style="color: #FFFFFF; margin: 0;font-size: 20px;"> Downstream Task 1: Property Prediction</h3>
             </div>
-            ''')
-            # gr.Markdown("## Downstream task Result")
+            '''
+            )
             eval_output = gr.Textbox(label="Train downstream model")
 
-            plot_radio = gr.Radio(choices=["ROC-AUC", "Parity Plot", "Latent Space"], label="Select Plot Type")
-            plot_output = gr.Plot(label="Visualization")#, height=250, width=250)
-
-            #download_rep = gr.Button("Download representation")
+            plot_radio = gr.Radio(
+                choices=["ROC-AUC", "Parity Plot", "Latent Space"],
+                label="Select Plot Type",
+            )
+            plot_output = gr.Plot(label="Visualization")
 
             create_log = gr.Button("Store log")
 
-            log_table = gr.Dataframe(value=log_df, label="Log of Selections and Results", interactive=False)
-
-            eval_button.click(display_eval,
-                              inputs=[model_checkbox, selected_columns_message, task_radiobutton, output, fusion_radiobutton],
-                              outputs=eval_output)
-
-            plot_radio.change(display_plot, inputs=plot_radio, outputs=plot_output)
-
+            log_table = gr.Dataframe(
+                value=log_df, label="Log of Selections and Results", interactive=False
+            )
+
+            eval_button.click(
+                display_eval,
+                inputs=[
+                    model_checkbox,
+                    selected_columns_message,
+                    task_radiobutton,
+                    output,
+                    fusion_radiobutton,
+                    state,
+                ],
+                outputs=eval_output,
+            )
+
+            plot_radio.change(
+                display_plot, inputs=[plot_radio, state], outputs=plot_output
+            )
 
             # Function to gather selected models
             def gather_selected_models(*models):
                 selected = [model for model in models if model]
                 return selected
 
-
-            create_log.click(evaluate_and_log, inputs=[model_checkbox, dataset_name, task_radiobutton, eval_output],
-                             outputs=log_table)
-            #download_rep.click(save_rep, inputs=[model_checkbox, dataset_name, task_radiobutton, eval_output],
-            #                 outputs=None)
-
+            create_log.click(
+                evaluate_and_log,
+                inputs=[
+                    model_checkbox,
+                    dataset_name,
+                    task_radiobutton,
+                    eval_output,
+                    state,
+                ],
+                outputs=log_table,
+            )
         # Right Column
         with gr.Column():
-            gr.HTML('''
+            gr.HTML(
+                '''
            <div style="background-color: #D2B48C; color: #FFFFFF; padding: 10px;">
                 <h3 style="color: #FFFFFF; margin: 0;font-size: 20px;"> Downstream Task 2: Molecule Generation</h3>
             </div>
-            ''')
-            # gr.Markdown("## Molecular Generation")
+            '''
+            )
             smiles_input = gr.Textbox(label="Input SMILES String")
             image_display = gr.Image(label="Molecule Image", height=250, width=250)
             # Show images for selection
@@ -712,24 +860,32 @@ with gr.Blocks() as demo:
                     choices=list(smiles_image_mapping.keys()),
                     label="Select from sample molecules",
                     value=None,
-                    #item_images=[load_image(smiles_image_mapping[key]["image"]) for key in smiles_image_mapping.keys()]
                 )
                 image_selector.change(load_image, image_selector, image_display)
             generate_button = gr.Button("Generate")
-            gen_image_display = gr.Image(label="Generated Molecule Image", height=250, width=250)
+            gen_image_display = gr.Image(
+                label="Generated Molecule Image", height=250, width=250
+            )
             generated_output = gr.Textbox(label="Generated Output")
             property_table = gr.Dataframe(label="Molecular Properties Comparison")
 
-
-
             # Handle image selection
-            image_selector.change(handle_image_selection, inputs=image_selector, outputs=[smiles_input, image_display])
-            smiles_input.change(smiles_to_image, inputs=smiles_input, outputs=image_display)
+            image_selector.change(
+                handle_image_selection,
+                inputs=image_selector,
+                outputs=[smiles_input, image_display],
+            )
+            smiles_input.change(
+                smiles_to_image, inputs=smiles_input, outputs=image_display
+            )
 
             # Generate button to display canonical SMILES and molecule image
-            generate_button.click(generate_canonical, inputs=smiles_input,
-                                  outputs=[property_table, generated_output, gen_image_display])
+            generate_button.click(
+                generate_canonical,
+                inputs=smiles_input,
+                outputs=[property_table, generated_output, gen_image_display],
+            )
 
 
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(server_name="0.0.0.0")

data/lce/test.csv

@@ -0,0 +1,31 @@
+smi1,conc1,smi2,conc2,smi3,conc3,smi4,conc4,smi5,conc5,smi6,conc6,LCE
+C1C(OC(=O)O1)F,0.733,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.267,O,0.0,O,0.0,O,0.0,O,0.0,1.629
+C1C(OC(=O)O1)F,0.497,COC(=O)OC,0.431,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,O,0.0,1.085
+COC(=O)OC,0.299,C(C(F)(F)F)OCC(F)(F)F,0.598,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.103,O,0.0,O,0.0,O,0.0,2.056
+COCCOC,0.358,O1CCOC1,0.532,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.074,[Li+].[N+](=O)([O-])[O-],,O,0.0,O,0.0,1.658
+C1COC(=O)O1,0.197,COC(=O)OC,0.156,COCCOCCOCCOCCOC,0.59,[Li+].F[P-](F)(F)(F)(F)F,0.026,[Li+].[N+](=O)([O-])[O-],0.031,O,0.0,1.638
+C1COC(=O)O1,0.496,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.002,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,1.276
+O1CCOC1,0.368,COCCOC,0.547,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.076,CSi(C)(C)([N+]).C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F,0.008,O,0.0,O,0.0,1.569
+COCCOC,0.507,COC(C(F)(F)F)C(F)(F)F,0.399,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.095,O,0.0,O,0.0,O,0.0,2.268
+C1COC(=O)O1,0.425,O=C(OCC)OCC(F)(F)F,0.481,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.094,O,0.0,O,0.0,O,0.0,1.602
+C1C(OC(=O)O1)F,0.318,CCOC(=O)OC,0.504,COC(=O)OC,0.094,B(O[Si](C)(C)C)(O[Si](C)(C)C)O[Si](C)(C),0.083,[Li+].F[P-](F)(F)(F)(F)F,0.001,O,0.0,1.678
+O=S1(=O)CCCC1,0.359,C(C(F)(F)F)OC(C(F)F)(F)F,0.504,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.133,[Li+].[N+](=O)([O-])[O-],0.004,O,0.0,O,0.0,2.0
+C1COC(=O)O1,0.594,O=C(OCC)OCC,0.327,[Li+].F[P-](F)(F)(F)(F)F,0.079,O,0.0,O,0.0,O,0.0,0.921
+C1COC(=O)O1,0.331,O=C(OCC)OCC,0.577,[Li+].[B-]1(OC(=O)C(=O)O1)(F)F,0.092,O,0.0,O,0.0,O,0.0,1.301
+C1COC(=O)O1,0.507,COC(=O)OC,0.402,C1=COC(=O)O1,0.022,[Li+].C(C(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(C(F)(F)F)(F)F)(F)(F)F,0.069,O,0.0,O,0.0,0.854
+C1C(OC(=O)O1)F,0.107,C1COC(=O)O1,0.526,O=C(OCC)OCC,0.289,[Li+].F[P-](F)(F)(F)(F)F,0.078,O,0.0,O,0.0,1.108
+O1CCOC1,0.322,COCCOC,0.478,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F,0.2,O,0.0,O,0.0,O,0.0,1.523
+CC1COC(=O)O1,0.595,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.405,O,0.0,O,0.0,O,0.0,O,0.0,1.921
+CC1COC(=O)O1,0.702,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.298,O,0.0,O,0.0,O,0.0,O,0.0,1.602
+O1CCOC1,0.375,COCCOC,0.557,[Li+][S-]SSS[S-][Li+],,[Li+].[N+](=O)([O-])[O-],0.008,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.061,O,0.0,1.523
+COC(=O)OC,0.161,FC(F)C(F)(F)COC(F)(F)C(F)F,0.355,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.484,O,0.0,O,0.0,O,0.0,2.155
+C1COC(=O)O1,0.338,COC(=O)OC,0.625,[Li+].[O-]P(=O)(F)F,0.008,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.03,O,0.0,O,0.0,1.26
+CN(C)C(=O)C(F)(F)F,0.362,C1C(OC(=O)O1)F,0.556,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.081,O,0.0,O,0.0,O,0.0,2.155
+C1C(OC(=O)O1)F,0.497,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.0,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,1.225
+COCCOC,0.231,FC1CCCCC1,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0.0,O,0.0,O,0.0,2.155
+COCCOC,0.277,FC(F)C(F)(F)COC(F)(F)C(F)F,0.555,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.168,O,0.0,O,0.0,O,0.0,2.155
+O1C(C)CCC1,0.331,FC(F)C(F)(F)COC(F)(F)C(F)F,0.498,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.171,O,0.0,O,0.0,O,0.0,2.301
+COCC(F)(F)C(F)(F)COC,0.864,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.136,O,0.0,O,0.0,O,0.0,O,0.0,1.991
+COC(=O)OC,0.29,C(C(F)(F)F)OCC(F)(F)F,0.589,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.121,O,0.0,O,0.0,O,0.0,2.301
+C1COC(=O)O1,0.425,O=C(OCC)OCC,0.234,[Li+].F[P-](F)(F)(F)(F)F,0.34,O,0.0,O,0.0,O,0.0,1.398
+COCCOC,0.707,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.147,[Li+].[B-]1(OC(=O)C(=O)O1)(F)F,0.147,O,0.0,O,0.0,O,0.0,1.268

data/lce/test_data.csv

@@ -0,0 +1,14 @@
+smiles1,conc1,mol1,smiles2,conc2,mol2,smiles3,conc3,mol3,smiles4,conc4,mol4,smiles5,conc5,mol5,smiles6,conc6,LCE_Predicted,LCE
+C1COC(=O)O1,0.519,51.92400559,COC(=O)OC,0.411,41.14791596,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.069,6.928078454,O,0,0,O,0,0,O,0,1.187,1.094
+COCCOC,0.596,59.5609428,COCCOCCOCCOCCOC,0.281,28.07124115,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.124,12.36781605,O,0,0,O,0,0,O,0,1.691,1.384
+C1COC(=O)O1,0.285,28.50894036,C1C(OC(=O)O1)F,0.261,26.07552384,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.228,22.82322096,COC(=O)OC,0.226,22.59231484,O,0,0,O,0,1.508,1.468
+COCCOC,0.434,43.4423376,COCCOCCOCCOCCOC,0.205,20.47449683,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.361,36.08316557,O,0,0,O,0,0,O,0,1.882,1.71
+C1C(OC(=O)O1)F,0.187,18.72872664,COC(=O)OC,0.162,16.22691423,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.109,10.92850826,FC(F)C(F)(F)COC(F)(F)C(F)F,0.541,54.11585087,O,0,0,O,0,2.103,1.832
+C1COC(=O)O1,0.134,13.35070843,C1C(OC(=O)O1)F,0.122,12.2111419,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.107,10.72028474,COC(=O)OC,0.106,10.57995858,FC(F)C(F)(F)COC(F)(F)C(F)F,0.531,53.13790635,O,0,2.077,2.104
+COCCOC,0.096,9.614613177,COCCOCCOCCOCCOC,0.045,4.53139444,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.12,12.01491409,C1COCO1,0.143,14.28400162,FC(F)C(F)(F)COC(F)(F)C(F)F,0.596,59.55507668,O,0,2.211,2.274
+C1COC(=O)O1,0.519,51.92400559,COC(=O)OC,0.411,41.14791596,[Li+].F[P-](F)(F)(F)(F)F,0.069,6.928078454,O,0,0,O,0,0,O,0,1.17,1.071
+C1COC(=O)O1,0.519,51.92400559,COC(=O)OC,0.411,41.14791596,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.069,6.928078454,O,0,0,O,0,0,O,0,1.077,1.166
+C1COC(=O)O1,0.519,51.85215842,COC(=O)OC,0.411,41.09097965,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.069,6.918492083,[Li+].[N+](=O)([O-])[O-],0.001,0.138369842,O,0,0,O,0,1.19,1.335
+C1COC(=O)O1,0.513,51.33049845,COC(=O)OC,0.407,40.6775828,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.069,6.9173773,C1=COC(=O)O1,0.011,1.07454145,O,0,0,O,0,1.114,1.129
+COCCOC,0.53,53.00533987,COCCOCCOCCOCCOC,0.25,24.98156691,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.22,22.01309322,O,0,0,O,0,0,O,0,1.758,1.501
+COCCOC,0.477,47.74974224,COCCOCCOCCOCCOC,0.225,22.50458884,[Li+].[N-](S(=O)(=O)F)S(=O)(=O)F,0.297,29.74566892,O,0,0,O,0,0,O,0,1.821,1.663

data/lce/train.csv

@@ -0,0 +1,121 @@
+smi1,conc1,smi2,conc2,smi3,conc3,smi4,conc4,smi5,conc5,smi6,conc6,LCE
+C1COC(=O)O1,0.327,O=C(OCC)OCC,0.594,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.079,O,0.0,O,0.0,O,0.0,1.155
+C1COC(=O)O1,0.356,COC(=O)OC,0.566,FC(F)(F)COB(OCC(F)(F)F)OCC(F)(F)F,0.007,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,1.046
+O=S1(=O)CCCC1,0.25,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.75,O,0.0,O,0.0,O,0.0,O,0.0,1.569
+C1COC(=O)O1,0.331,O=C(OCC)OCC,0.577,[Li+].F[P-](F)(F)(F)(F)F,0.092,O,0.0,O,0.0,O,0.0,0.886
+COCCOC,0.763,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.237,O,0.0,O,0.0,O,0.0,O,0.0,1.367
+COCCOC,0.2,FC(F)C(F)(F)COC(F)(F)C(F)F,0.6,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.2,O,0.0,O,0.0,O,0.0,2.301
+C1C(OC(=O)O1)F,0.873,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.127,O,0.0,O,0.0,O,0.0,O,0.0,1.489
+COCCOC,0.706,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.008,[Li+].[O-]P(=O)(F)F,0.286,O,0.0,O,0.0,O,0.0,1.244
+C1COC(=O)O1,0.3,CCOC(=O)OC,0.593,C1=COC(=O)O1,0.026,[Li+].F[P-](F)(F)(F)(F)F,0.081,O,0.0,O,0.0,0.745
+COCCOC,0.763,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.174,[Li+].[O-]P(=O)(F)F,0.063,O,0.0,O,0.0,O,0.0,1.292
+CCOCC,0.313,C(C(F)(F)F)OCC(F)(F)F,0.51,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.177,O,0.0,O,0.0,O,0.0,2.301
+O=S1(=O)CCCC1,0.75,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.25,O,0.0,O,0.0,O,0.0,O,0.0,1.745
+COC(=O)OC,0.29,C(C(F)(F)F)OCC(F)(F)F,0.589,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.121,O,0.0,O,0.0,O,0.0,1.745
+C1COC(=O)O1,0.682,CCOC(=O)OC,0.247,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.043,[Li+].O=C1O[B-]2(OC1=O)OC(=O)C(=O)O2,0.028,O,0.0,O,0.0,1.076
+C1COC(=O)O1,0.359,COC(=O)OC,0.569,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,O,0.0,0.854
+C1COC(=O)O1,0.305,COC(=O)OC,0.242,COCCOCCOCCOCCOC,0.392,[Li+].F[P-](F)(F)(F)(F)F,0.041,[Li+].[N+](=O)([O-])[O-],0.02,O,0.0,1.678
+FC(F)(F)COCCOCC,0.838,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.162,O,0.0,O,0.0,O,0.0,O,0.0,2.155
+CC#N,0.882,FC,0.065,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,,O,0.0,O,0.0,O,0.0,2.222
+COC(C)C(C)OC,0.879,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.121,O,0.0,O,0.0,O,0.0,O,0.0,1.638
+CCOP(=O)(OCC)OCC,0.728,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.272,O,0.0,O,0.0,O,0.0,O,0.0,2.0
+COC(=O)OC,0.375,FC(F)C(F)(F)COC(F)(F)C(F)F,0.375,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.25,O,0.0,O,0.0,O,0.0,1.854
+O1CCOC1,0.371,COCCOC,0.552,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.077,O,0.0,O,0.0,O,0.0,1.959
+C1C(OC(=O)O1)F,0.774,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.226,O,0.0,O,0.0,O,0.0,O,0.0,1.587
+CC1COC(=O)O1,0.875,C1C(OC(=O)O1)F,0.051,[Li+].[O-]Cl(=O)(=O)=O,0.074,O,0.0,O,0.0,O,0.0,0.699
+C1C(OC(=O)O1)F,0.264,COC(=O)OCCF,0.479,C(C(F)(F)F)OC(C(F)F)(F)F,0.155,[Li+].F[P-](F)(F)(F)(F)F,0.103,O,0.0,O,0.0,2.097
+C1C(OC(=O)O1)F,0.413,O=C(OCC)OCC,0.497,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.09,O,0.0,O,0.0,O,0.0,1.59
+C1C(OC(=O)O1)F,0.106,C1COC(=O)O1,0.522,O=C(OCC)OCC,0.287,[Li+].F[P-](F)(F)(F)(F)F,0.077,[Rb+].[O-][N+]([O-])=O,0.004,O1CCOCCOCCOCCOCCOCC1,0.004,1.252
+COCCOC,0.259,B(OCC(F)(F)F)(OCC(F)(F)F)OCC(F)(F)F,0.556,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.185,O,0.0,O,0.0,O,0.0,1.337
+C1CCOC1,0.925,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.075,O,0.0,O,0.0,O,0.0,O,0.0,1.377
+C1C(OC(=O)O1)F,0.82,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.18,O,0.0,O,0.0,O,0.0,O,0.0,1.544
+CCOP(=O)(OCC)OCC,0.5,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.5,O,0.0,O,0.0,O,0.0,O,0.0,2.097
+COCCOC,0.731,[Li+].[O-]P(=O)(F)F,0.064,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.205,O,0.0,O,0.0,O,0.0,1.215
+COCCOCCOCCOCCOC,0.819,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.181,O,0.0,O,0.0,O,0.0,O,0.0,1.222
+C1COC(=O)O1,0.338,COC(=O)OC,0.625,[Li+].[O-]P(=O)(F)F,0.008,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.03,O,0.0,O,0.0,1.194
+O1CCOC1,0.463,COCCOC,0.312,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.194,[Li+].[N+](=O)([O-])[O-],0.03,O,0.0,O,0.0,1.824
+C1C(OC(=O)O1)F,0.496,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.002,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,1.333
+O1CCOC1,0.539,COCCOC,0.363,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.075,[Li+].[N+](=O)([O-])[O-],0.023,O,0.0,O,0.0,1.824
+COCCOC,0.257,C(C(F)(F)F)OCC(F)(F)F,0.508,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.235,O,0.0,O,0.0,O,0.0,2.051
+COCCOC,0.906,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.047,[Li+].FP(F)(=O)([O-]),0.047,O,0.0,O,0.0,O,0.0,1.444
+O1CCOC1,0.478,COCCOC,0.322,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.134,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.067,O,0.0,O,0.0,1.854
+CCOCC,0.707,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.293,O,0.0,O,0.0,O,0.0,O,0.0,2.046
+C1COC(=O)O1,0.563,O=C(OCC)OCC,0.31,C1C(OC(=O)O1)F,0.052,[Li+].F[P-](F)(F)(F)(F)F,0.075,O,0.0,O,0.0,1.301
+C1CCOC1,0.942,FC,0.029,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,,O,0.0,O,0.0,O,0.0,2.222
+O1CCOC1,0.478,COCCOC,0.322,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.2,O,0.0,O,0.0,O,0.0,1.903
+COCCOC,0.906,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.094,O,0.0,O,0.0,O,0.0,O,0.0,1.561
+C1C(OC(=O)O1)F,0.149,COC(=O)OCCF,0.178,C(C(F)(F)F)OC(C(F)F)(F)F,0.564,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.108,O,0.0,O,0.0,1.735
+FC(F)COCCOCC(F)(F),0.845,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.155,O,0.0,O,0.0,O,0.0,O,0.0,2.301
+C1C(OC(=O)O1)F,0.495,COC(=O)OC,0.429,O1CCOCCOCCOCC1,0.003,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,1.498
+C1COC(=O)O1,0.507,COC(=O)OC,0.402,C1=COC(=O)O1,0.022,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.069,O,0.0,O,0.0,0.745
+O=S1(=O)CCCC1,0.758,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.235,[Li+].[N+](=O)([O-])[O-],0.007,O,0.0,O,0.0,O,0.0,1.824
+CCOCC,0.856,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.144,O,0.0,O,0.0,O,0.0,O,0.0,2.0
+O=C(OCC)C,0.105,ClCCl,0.64,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.255,O,0.0,O,0.0,O,0.0,1.456
+COCCOCCOCC(F)(F)OC(F)(F)OC(F)(F)COCCOCCOC,0.708,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.292,O,0.0,O,0.0,O,0.0,O,0.0,1.301
+COCCOC,0.583,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.278,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.139,O,0.0,O,0.0,O,0.0,1.678
+C1C(OC(=O)O1)F,0.662,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.338,O,0.0,O,0.0,O,0.0,O,0.0,1.646
+O1CCOC1,0.397,COCCOC,0.589,[Li+][S-]SSS[S-][Li+],,[Li+].[N+](=O)([O-])[O-],0.012,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.002,O,0.0,1.301
+C1COC(=O)O1,0.308,O=C(OCC)OCC(F)(F)F,0.349,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.343,O,0.0,O,0.0,O,0.0,2.046
+C1COC(=O)O1,0.362,O=C(OCC)OCC,0.548,[Li+].F[P-](F)(F)(F)(F)F,0.09,O,0.0,O,0.0,O,0.0,0.788
+C1C(OC(=O)O1)F,0.497,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.001,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,1.373
+O1CCOCC1,0.912,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.088,O,0.0,O,0.0,O,0.0,O,0.0,1.602
+CC#N,0.621,C1=COC(=O)O1,0.056,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.323,O,0.0,O,0.0,O,0.0,1.854
+COC(=O)OC,0.684,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.316,O,0.0,O,0.0,O,0.0,O,0.0,2.097
+O=S1(=O)CCCC1,0.714,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.286,O,0.0,O,0.0,O,0.0,O,0.0,1.699
+FC(F)(F)COCCOCC(F)(F)(F),0.838,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.162,O,0.0,O,0.0,O,0.0,O,0.0,2.155
+CCOCC,0.64,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.36,O,0.0,O,0.0,O,0.0,O,0.0,2.208
+COC(=O)OC,0.6,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.4,O,0.0,O,0.0,O,0.0,O,0.0,1.77
+CC1COC(=O)O1,0.887,[Li+].F[As-](F)(F)(F)(F)F,0.113,O,0.0,O,0.0,O,0.0,O,0.0,0.824
+C1COC(=O)O1,0.5,CCOC(=O)OC,0.423,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.046,[Li+].O=C1O[B-]2(OC1=O)OC(=O)C(=O)O2,0.031,O,0.0,O,0.0,0.924
+CCOP(=O)(OCC)OCC,0.214,C(C(F)(F)F)OCC(F)(F)F,0.642,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.144,O,0.0,O,0.0,O,0.0,2.097
+COCCOC,0.682,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.318,O,0.0,O,0.0,O,0.0,O,0.0,2.108
+CC1COC(=O)O1,0.922,[LI+].F[B-](F)(F)OC(C(F)(F)(F))(C(F)(F)(F))C(F)(F)(F),0.078,O,0.0,O,0.0,O,0.0,O,0.0,0.712
+C1COC(=O)O1,0.854,CCOC(=O)OC,0.08,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.039,[Li+].O=C1O[B-]2(OC1=O)OC(=O)C(=O)O2,0.026,O,0.0,O,0.0,1.081
+C1COC(=O)O1,0.519,O=C(OCC)OCC,0.387,[Li+].F[P-](F)(F)(F)(F)F,0.082,[Li+].[O-]P(=O)(F)F,0.012,O,0.0,O,0.0,1.319
+COC(=O)CC(F)(F)F,0.768,C1C(OC(=O)O1)F,0.134,[Li+].F[P-](F)(F)(F)(F)F,0.098,O,0.0,O,0.0,O,0.0,1.62
+C1C(OC(=O)O1)F,0.144,COC(=O)OCCF,0.173,C(C(F)(F)F)OC(C(F)F)(F)F,0.548,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.135,O,0.0,O,0.0,2.222
+C1COC(=O)O1,0.326,COC(=O)OC,0.602,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,O,0.0,0.777
+CCOCC,0.877,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.123,O,0.0,O,0.0,O,0.0,O,0.0,2.018
+COC(=O)OC,0.664,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.336,O,0.0,O,0.0,O,0.0,O,0.0,1.886
+C1COC(=O)O1,0.507,COC(=O)OC,0.402,C1=COC(=O)O1,0.022,[Li+].F[B-](F)(F)F,0.069,O,0.0,O,0.0,0.699
+CCOP(=O)(OCC)OCC,0.648,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.352,O,0.0,O,0.0,O,0.0,O,0.0,1.569
+C1C(OC(=O)O1)F,0.481,O=C(OCC)OCC,0.432,[Li+].F[P-](F)(F)(F)(F)F,0.087,O,0.0,O,0.0,O,0.0,1.523
+COCCOC,0.231,FC(F)C(F)(F)COC(F)(F)C(F)F,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0.0,O,0.0,O,0.0,2.155
+C1C(OC(=O)O1)F,0.496,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.001,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,1.488
+O1CCOC1,0.453,COCCOC,0.305,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.127,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.063,[Li+].[N+](=O)([O-])[O-],0.051,O,0.0,2.046
+C1C(OC(=O)O1)F,0.932,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.068,O,0.0,O,0.0,O,0.0,O,0.0,1.41
+COCCOC,0.139,COCC(F)(F)C(F)(F)C(F)(F)C(F)(F)COC,0.692,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.169,O,0.0,O,0.0,O,0.0,2.222
+C1C(OC(=O)O1)F,0.497,COC(=O)OC,0.431,O1CCOCCOCCOCC1,0.0,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,1.559
+COCCOC,0.231,FC(COC(OCC(F)(F)F)OCC(F)(F)F)(F)F,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0.0,O,0.0,O,0.0,2.301
+CN(C)S(=O)(=O)F,0.921,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.079,O,0.0,O,0.0,O,0.0,O,0.0,1.672
+C1C(OC(=O)O1)F,0.105,C1COC(=O)O1,0.518,O=C(OCC)OCC,0.285,[Li+].F[P-](F)(F)(F)(F)F,0.077,[Rb+].[O-][N+]([O-])=O,0.008,O1CCOCCOCCOCCOCCOCC1,0.008,1.538
+CC1CCC(C)O1,0.893,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.107,O,0.0,O,0.0,O,0.0,O,0.0,1.796
+C1C(OC(=O)O1)F,0.496,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.002,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0.0,O,0.0,1.355
+C1COC(=O)O1,0.444,C1COS(=O)O1,0.497,[Li+].[O-]Cl(=O)(=O)=O,0.059,O,0.0,O,0.0,O,0.0,1.523
+COCCOC,0.371,O1CCOC1,0.552,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.031,[Li+].[N+](=O)([O-])[O-],0.046,O,0.0,O,0.0,1.78
+O=S1(=O)CCCC1,0.764,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.236,O,0.0,O,0.0,O,0.0,O,0.0,1.456
+O1C(C)CCC1,0.908,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.092,O,0.0,O,0.0,O,0.0,O,0.0,1.745
+O1CCOC1,0.362,C(C(F)(F)F)OCC(F)(F)F,0.59,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.048,O,0.0,O,0.0,O,0.0,1.967
+COC(=O)OC,0.543,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.457,O,0.0,O,0.0,O,0.0,O,0.0,2.097
+COCCOC,0.73,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.27,O,0.0,O,0.0,O,0.0,O,0.0,1.143
+O1CCOC1,0.552,COCCOC,0.371,[Li+].[N+](=O)([O-])[O-],0.039,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.039,O,0.0,O,0.0,1.523
+COCCOC,0.242,FC(COC(OCC(F)(F)F)OCC(F)(F)F)(F)F,0.604,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.154,O,0.0,O,0.0,O,0.0,2.301
+CCOP(=O)(OCC)OCC,0.6,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.4,O,0.0,O,0.0,O,0.0,O,0.0,2.155
+C1C(OC(=O)O1)F,0.318,CCOC(=O)OC,0.504,COC(=O)OC,0.094,[Li+].F[P-](F)(F)(F)(F)F,0.083,O,0.0,O,0.0,1.301
+COCCOC,0.231,C(C(F)(F)F)OCC(F)(F)F,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0.0,O,0.0,O,0.0,2.222
+C1COC(=O)O1,0.507,COC(=O)OC,0.402,C1=COC(=O)O1,0.022,[Li+].F[P-](F)(F)(F)(F)F,0.069,O,0.0,O,0.0,0.699
+COCCOC,0.231,C(C(F)(F)F)OC(=O)OCC(F)(F)F,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0.0,O,0.0,O,0.0,1.495
+C1COC(=O)O1,0.32,COC(=O)OC,0.253,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.427,O,0.0,O,0.0,O,0.0,2.155
+C1C(OC(=O)O1)F,0.312,O=C1OCCC1,0.599,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.068,[Li+].[N+](=O)([O-])[O-],0.021,O,0.0,O,0.0,1.921
+COC(=O)OC,0.478,FC(F)C(F)(F)COC(F)(F)C(F)F,0.322,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.067,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.134,O,0.0,O,0.0,1.886
+CCOP(=O)(OCC)OCC,0.259,FC(F)C(F)(F)COC(F)(F)C(F)F,0.556,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.185,O,0.0,O,0.0,O,0.0,2.046
+COCCOC,0.677,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.323,O,0.0,O,0.0,O,0.0,O,0.0,1.745
+C1C(OC(=O)O1)F,0.696,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.304,O,0.0,O,0.0,O,0.0,O,0.0,1.633
+C1CCOC1,0.47,O1C(C)CCC1,0.378,[Li+].F[P-](F)(F)(F)(F)F,0.152,O,0.0,O,0.0,O,0.0,2.097
+FC(F)COCCOCC(F)(F)(F),0.838,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.162,O,0.0,O,0.0,O,0.0,O,0.0,2.301
+C1COC(=O)O1,0.496,COC(=O)OC,0.393,C1C(OC(=O)O1)F,0.045,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.066,O,0.0,O,0.0,1.108
+C1C(OC(=O)O1)F,0.62,C(C(F)(F)F)OC(=O)OCC(F)(F)F,0.291,[Li+].F[P-](F)(F)(F)(F)F,0.089,O,0.0,O,0.0,O,0.0,1.62
+CCOCC,0.906,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.094,O,0.0,O,0.0,O,0.0,O,0.0,1.959
+C1COC(=O)O1,0.526,O=C(OCC)OCC,0.392,[Li+].F[P-](F)(F)(F)(F)F,0.083,O,0.0,O,0.0,O,0.0,1.013
+C1COC(=O)O1,0.05,CCOC(=O)OC,0.237,C(C(F)(F)F)OCC(F)(F)F,0.575,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.123,[Li+].[B-]1(OC(=O)C(=O)O1)(F)F,0.015,O,0.0,1.824
+O=S1(=O)CCCC1,0.429,FC(F)C(F)(F)COC(F)(F)C(F)F,0.429,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.143,O,0.0,O,0.0,O,0.0,1.921

data/lce/train_data.csv

@@ -0,0 +1,148 @@
+smiles1,conc1,smiles2,conc2,smiles3,conc3,smiles4,conc4,smiles5,conc5,smiles6,conc6,LCE
+CC1COC(=O)O1,0.875,C1C(OC(=O)O1)F,0.051,[Li+].[O-]Cl(=O)(=O)=O,0.074,O,0,O,0,O,0,0.699
+C1COC(=O)O1,0.507,COC(=O)OC,0.402,C1=COC(=O)O1,0.022,[Li+].F[P-](F)(F)(F)(F)F,0.069,O,0,O,0,0.699
+FC(F)COCCOCC(F)(F),0.845,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.155,O,0,O,0,O,0,O,0,2.301
+FC(F)COCCOCC(F)(F)(F),0.838,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.162,O,0,O,0,O,0,O,0,2.301
+CN(C)C(=O)C(F)(F)F,0.362,C1C(OC(=O)O1)F,0.556,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.081,O,0,O,0,O,0,2.155
+COCCOC,0.231,FC1CCCCC1,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0,O,0,O,0,2.155
+CCOP(=O)(OCC)OCC,0.6,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.4,O,0,O,0,O,0,O,0,2.155
+O1CCOC1,0.362,C(C(F)(F)F)OCC(F)(F)F,0.59,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.048,O,0,O,0,O,0,1.967
+COCC(F)(F)C(F)(F)COC,0.864,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.136,O,0,O,0,O,0,O,0,1.991
+C1C(OC(=O)O1)F,0.662,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.338,O,0,O,0,O,0,O,0,1.646
+COCCOC,0.358,O1CCOC1,0.532,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.074,[Li+].[N+](=O)([O-])[O-],0.035,O,0,O,0,1.658
+CN(C)S(=O)(=O)F,0.921,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.079,O,0,O,0,O,0,O,0,1.672
+C1C(OC(=O)O1)F,0.106,C1COC(=O)O1,0.522,O=C(OCC)OCC,0.287,[Li+].F[P-](F)(F)(F)(F)F,0.077,[Rb+].[O-][N+]([O-])=O,0.004,O1CCOCCOCCOCCOCCOCC1,0.004,1.252
+C1COC(=O)O1,0.32,COC(=O)OC,0.253,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.427,O,0,O,0,O,0,2.155
+COCCOC,0.277,FC(F)C(F)(F)COC(F)(F)C(F)F,0.555,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.168,O,0,O,0,O,0,2.155
+COC(=O)OC,0.161,FC(F)C(F)(F)COC(F)(F)C(F)F,0.355,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.484,O,0,O,0,O,0,2.155
+FC(F)(F)COCCOCC,0.838,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.162,O,0,O,0,O,0,O,0,2.155
+FC(F)(F)COCCOCC(F)(F)(F),0.838,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.162,O,0,O,0,O,0,O,0,2.155
+CCOCC,0.64,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.36,O,0,O,0,O,0,O,0,2.208
+C1C(OC(=O)O1)F,0.144,COC(=O)OCCF,0.173,C(C(F)(F)F)OC(C(F)F)(F)F,0.548,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.135,O,0,O,0,2.222
+CC#N,0.882,FC,0.065,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.054,O,0,O,0,O,0,2.222
+C1CCOC1,0.942,FC,0.029,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.029,O,0,O,0,O,0,2.222
+COCCOC,0.139,COCC(F)(F)C(F)(F)C(F)(F)C(F)(F)COC,0.692,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.169,O,0,O,0,O,0,2.222
+COCCOC,0.231,C(C(F)(F)F)OCC(F)(F)F,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0,O,0,O,0,2.222
+COCCOC,0.507,COC(C(F)(F)F)C(F)(F)F,0.399,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.095,O,0,O,0,O,0,2.268
+CCOCC,0.313,C(C(F)(F)F)OCC(F)(F)F,0.51,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.177,O,0,O,0,O,0,2.301
+COC(=O)OC,0.29,C(C(F)(F)F)OCC(F)(F)F,0.589,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.121,O,0,O,0,O,0,2.301
+COCCOC,0.242,FC(COC(OCC(F)(F)F)OCC(F)(F)F)(F)F,0.604,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.154,O,0,O,0,O,0,2.301
+O1C(C)CCC1,0.331,FC(F)C(F)(F)COC(F)(F)C(F)F,0.498,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.171,O,0,O,0,O,0,2.301
+COCCOC,0.2,FC(F)C(F)(F)COC(F)(F)C(F)F,0.6,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.2,O,0,O,0,O,0,2.301
+COCCOC,0.231,FC(COC(OCC(F)(F)F)OCC(F)(F)F)(F)F,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0,O,0,O,0,2.301
+O=S1(=O)CCCC1,0.359,C(C(F)(F)F)OC(C(F)F)(F)F,0.504,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.133,[Li+].[N+](=O)([O-])[O-],0.004,O,0,O,0,2
+CCOCC,0.856,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.144,O,0,O,0,O,0,O,0,2
+CCOCC,0.877,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.123,O,0,O,0,O,0,O,0,2.018
+CCOCC,0.707,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.293,O,0,O,0,O,0,O,0,2.046
+C1COC(=O)O1,0.308,O=C(OCC)OCC(F)(F)F,0.349,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.343,O,0,O,0,O,0,2.046
+O1CCOC1,0.453,COCCOC,0.305,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.127,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.063,[Li+].[N+](=O)([O-])[O-],0.051,O,0,2.046
+CCOP(=O)(OCC)OCC,0.259,FC(F)C(F)(F)COC(F)(F)C(F)F,0.556,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.185,O,0,O,0,O,0,2.046
+COCCOC,0.257,C(C(F)(F)F)OCC(F)(F)F,0.508,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.235,O,0,O,0,O,0,2.051
+COC(=O)OC,0.299,C(C(F)(F)F)OCC(F)(F)F,0.598,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.103,O,0,O,0,O,0,2.056
+CCOP(=O)(OCC)OCC,0.214,C(C(F)(F)F)OCC(F)(F)F,0.642,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.144,O,0,O,0,O,0,2.097
+COC(=O)OC,0.684,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.316,O,0,O,0,O,0,O,0,2.097
+C1CCOC1,0.47,O1C(C)CCC1,0.378,[Li+].F[P-](F)(F)(F)(F)F,0.152,O,0,O,0,O,0,2.097
+C1C(OC(=O)O1)F,0.264,COC(=O)OCCF,0.479,C(C(F)(F)F)OC(C(F)F)(F)F,0.155,[Li+].F[P-](F)(F)(F)(F)F,0.103,O,0,O,0,2.097
+CCOP(=O)(OCC)OCC,0.5,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.5,O,0,O,0,O,0,O,0,2.097
+COC(=O)OC,0.543,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.457,O,0,O,0,O,0,O,0,2.097
+COCCOC,0.682,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.318,O,0,O,0,O,0,O,0,2.108
+COCCOC,0.231,FC(F)C(F)(F)COC(F)(F)C(F)F,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0,O,0,O,0,2.155
+CCOP(=O)(OCC)OCC,0.728,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.272,O,0,O,0,O,0,O,0,2
+COCCOC,0.583,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.278,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.139,O,0,O,0,O,0,1.678
+C1COC(=O)O1,0.305,COC(=O)OC,0.242,COCCOCCOCCOCCOC,0.392,[Li+].F[P-](F)(F)(F)(F)F,0.041,[Li+].[N+](=O)([O-])[O-],0.02,O,0,1.678
+C1C(OC(=O)O1)F,0.318,CCOC(=O)OC,0.504,COC(=O)OC,0.094,B(O[Si](C)(C)C)(O[Si](C)(C)C)O[Si](C)(C),0.083,[Li+].F[P-](F)(F)(F)(F)F,0.001,O,0,1.678
+O=S1(=O)CCCC1,0.714,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.286,O,0,O,0,O,0,O,0,1.699
+C1C(OC(=O)O1)F,0.149,COC(=O)OCCF,0.178,C(C(F)(F)F)OC(C(F)F)(F)F,0.564,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.108,O,0,O,0,1.735
+O=S1(=O)CCCC1,0.75,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.25,O,0,O,0,O,0,O,0,1.745
+COC(=O)OC,0.29,C(C(F)(F)F)OCC(F)(F)F,0.589,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.121,O,0,O,0,O,0,1.745
+COCCOC,0.677,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.323,O,0,O,0,O,0,O,0,1.745
+O1C(C)CCC1,0.908,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.092,O,0,O,0,O,0,O,0,1.745
+COC(=O)OC,0.6,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.4,O,0,O,0,O,0,O,0,1.77
+COCCOC,0.371,O1CCOC1,0.552,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.031,[Li+].[N+](=O)([O-])[O-],0.046,O,0,O,0,1.78
+CC1CCC(C)O1,0.893,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.107,O,0,O,0,O,0,O,0,1.796
+C1COC(=O)O1,0.05,CCOC(=O)OC,0.237,C(C(F)(F)F)OCC(F)(F)F,0.575,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.123,[Li+].[B-]1(OC(=O)C(=O)O1)(F)F,0.015,O,0,1.824
+O=S1(=O)CCCC1,0.758,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.235,[Li+].[N+](=O)([O-])[O-],0.007,O,0,O,0,O,0,1.824
+O1CCOC1,0.463,COCCOC,0.312,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.194,[Li+].[N+](=O)([O-])[O-],0.03,O,0,O,0,1.824
+O1CCOC1,0.539,COCCOC,0.363,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.075,[Li+].[N+](=O)([O-])[O-],0.023,O,0,O,0,1.824
+COC(=O)OC,0.375,FC(F)C(F)(F)COC(F)(F)C(F)F,0.375,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.25,O,0,O,0,O,0,1.854
+O1CCOC1,0.478,COCCOC,0.322,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.134,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.067,O,0,O,0,1.854
+CC#N,0.621,C1=COC(=O)O1,0.056,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.323,O,0,O,0,O,0,1.854
+COC(=O)OC,0.478,FC(F)C(F)(F)COC(F)(F)C(F)F,0.322,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.067,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.134,O,0,O,0,1.886
+COC(=O)OC,0.664,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.336,O,0,O,0,O,0,O,0,1.886
+O1CCOC1,0.478,COCCOC,0.322,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.2,O,0,O,0,O,0,1.903
+O=S1(=O)CCCC1,0.429,FC(F)C(F)(F)COC(F)(F)C(F)F,0.429,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.143,O,0,O,0,O,0,1.921
+C1C(OC(=O)O1)F,0.312,O=C1OCCC1,0.599,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.068,[Li+].[N+](=O)([O-])[O-],0.021,O,0,O,0,1.921
+CC1COC(=O)O1,0.595,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.405,O,0,O,0,O,0,O,0,1.921
+O1CCOC1,0.371,COCCOC,0.552,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.077,O,0,O,0,O,0,1.959
+CCOCC,0.906,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.094,O,0,O,0,O,0,O,0,1.959
+C1CCOC1,0.925,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.075,O,0,O,0,O,0,O,0,1.377
+C1COC(=O)O1,0.425,O=C(OCC)OCC,0.234,[Li+].F[P-](F)(F)(F)(F)F,0.34,O,0,O,0,O,0,1.398
+C1C(OC(=O)O1)F,0.932,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.068,O,0,O,0,O,0,O,0,1.41
+COCCOC,0.906,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.047,[Li+].FP(F)(=O)([O-]),0.047,O,0,O,0,O,0,1.444
+O=S1(=O)CCCC1,0.764,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.236,O,0,O,0,O,0,O,0,1.456
+O=C(OCC)C,0.105,ClCCl,0.64,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.255,O,0,O,0,O,0,1.456
+C1C(OC(=O)O1)F,0.496,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.001,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,1.488
+C1C(OC(=O)O1)F,0.873,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.127,O,0,O,0,O,0,O,0,1.489
+COCCOC,0.231,C(C(F)(F)F)OC(=O)OCC(F)(F)F,0.577,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.192,O,0,O,0,O,0,1.495
+C1C(OC(=O)O1)F,0.495,COC(=O)OC,0.429,O1CCOCCOCCOCC1,0.003,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,1.498
+C1C(OC(=O)O1)F,0.481,O=C(OCC)OCC,0.432,[Li+].F[P-](F)(F)(F)(F)F,0.087,O,0,O,0,O,0,1.523
+O1CCOC1,0.322,COCCOC,0.478,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F,0.2,O,0,O,0,O,0,1.523
+O1CCOC1,0.552,COCCOC,0.371,[Li+].[N+](=O)([O-])[O-],0.039,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.039,O,0,O,0,1.523
+C1COC(=O)O1,0.444,C1COS(=O)O1,0.497,[Li+].[O-]Cl(=O)(=O)=O,0.059,O,0,O,0,O,0,1.523
+C1C(OC(=O)O1)F,0.105,C1COC(=O)O1,0.518,O=C(OCC)OCC,0.285,[Li+].F[P-](F)(F)(F)(F)F,0.077,[Rb+].[O-][N+]([O-])=O,0.008,O1CCOCCOCCOCCOCCOCC1,0.008,1.538
+C1C(OC(=O)O1)F,0.82,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.18,O,0,O,0,O,0,O,0,1.544
+C1C(OC(=O)O1)F,0.497,COC(=O)OC,0.431,O1CCOCCOCCOCC1,0,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,1.559
+COCCOC,0.906,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.094,O,0,O,0,O,0,O,0,1.561
+CCOP(=O)(OCC)OCC,0.648,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.352,O,0,O,0,O,0,O,0,1.569
+O=S1(=O)CCCC1,0.25,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.75,O,0,O,0,O,0,O,0,1.569
+C1C(OC(=O)O1)F,0.774,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.226,O,0,O,0,O,0,O,0,1.587
+C1C(OC(=O)O1)F,0.413,O=C(OCC)OCC,0.497,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.09,O,0,O,0,O,0,1.59
+C1COC(=O)O1,0.425,O=C(OCC)OCC(F)(F)F,0.481,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.094,O,0,O,0,O,0,1.602
+CC1COC(=O)O1,0.702,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.298,O,0,O,0,O,0,O,0,1.602
+O1CCOCC1,0.912,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.088,O,0,O,0,O,0,O,0,1.602
+C1C(OC(=O)O1)F,0.62,C(C(F)(F)F)OC(=O)OCC(F)(F)F,0.291,[Li+].F[P-](F)(F)(F)(F)F,0.089,O,0,O,0,O,0,1.62
+COC(=O)CC(F)(F)F,0.768,C1C(OC(=O)O1)F,0.134,[Li+].F[P-](F)(F)(F)(F)F,0.098,O,0,O,0,O,0,1.62
+C1C(OC(=O)O1)F,0.733,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.267,O,0,O,0,O,0,O,0,1.629
+C1C(OC(=O)O1)F,0.696,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.304,O,0,O,0,O,0,O,0,1.633
+COC(C)C(C)OC,0.879,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.121,O,0,O,0,O,0,O,0,1.638
+C1COC(=O)O1,0.197,COC(=O)OC,0.156,COCCOCCOCCOCCOC,0.59,[Li+].F[P-](F)(F)(F)(F)F,0.026,[Li+].[N+](=O)([O-])[O-],0.031,O,0,1.638
+C1COC(=O)O1,0.338,COC(=O)OC,0.625,[Li+].[O-]P(=O)(F)F,0.008,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.03,O,0,O,0,1.26
+COCCOC,0.707,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.147,[Li+].[B-]1(OC(=O)C(=O)O1)(F)F,0.147,O,0,O,0,O,0,1.268
+C1COC(=O)O1,0.496,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.002,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,1.276
+COCCOC,0.763,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.174,[Li+].[O-]P(=O)(F)F,0.063,O,0,O,0,O,0,1.292
+C1COC(=O)O1,0.563,O=C(OCC)OCC,0.31,C1C(OC(=O)O1)F,0.052,[Li+].F[P-](F)(F)(F)(F)F,0.075,O,0,O,0,1.301
+COCCOCCOCC(F)(F)OC(F)(F)OC(F)(F)COCCOCCOC,0.708,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.292,O,0,O,0,O,0,O,0,1.301
+C1COC(=O)O1,0.331,O=C(OCC)OCC,0.577,[Li+].[B-]1(OC(=O)C(=O)O1)(F)F,0.092,O,0,O,0,O,0,1.301
+C1C(OC(=O)O1)F,0.318,CCOC(=O)OC,0.504,COC(=O)OC,0.094,[Li+].F[P-](F)(F)(F)(F)F,0.083,O,0,O,0,1.301
+C1COC(=O)O1,0.519,O=C(OCC)OCC,0.387,[Li+].F[P-](F)(F)(F)(F)F,0.082,[Li+].[O-]P(=O)(F)F,0.012,O,0,O,0,1.319
+C1C(OC(=O)O1)F,0.496,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.002,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,1.333
+COCCOC,0.259,B(OCC(F)(F)F)(OCC(F)(F)F)OCC(F)(F)F,0.556,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.185,O,0,O,0,O,0,1.337
+C1C(OC(=O)O1)F,0.496,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.002,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,1.355
+COCCOC,0.763,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.237,O,0,O,0,O,0,O,0,1.367
+C1C(OC(=O)O1)F,0.497,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0.001,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,1.373
+C1COC(=O)O1,0.507,COC(=O)OC,0.402,C1=COC(=O)O1,0.022,[Li+].F[B-](F)(F)F,0.069,O,0,O,0,0.699
+CC1COC(=O)O1,0.922,[Li+].F[B-](F)(F)OC(C(F)(F)(F))(C(F)(F)(F))C(F)(F)(F),0.078,O,0,O,0,O,0,O,0,0.712
+C1COC(=O)O1,0.3,CCOC(=O)OC,0.593,C1=COC(=O)O1,0.026,[Li+].F[P-](F)(F)(F)(F)F,0.081,O,0,O,0,0.745
+C1COC(=O)O1,0.507,COC(=O)OC,0.402,C1=COC(=O)O1,0.022,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.069,O,0,O,0,0.745
+C1COC(=O)O1,0.326,COC(=O)OC,0.602,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,O,0,0.777
+C1COC(=O)O1,0.362,O=C(OCC)OCC,0.548,[Li+].F[P-](F)(F)(F)(F)F,0.09,O,0,O,0,O,0,0.788
+CC1COC(=O)O1,0.887,[Li+].F[As-](F)(F)(F)(F)F,0.113,O,0,O,0,O,0,O,0,0.824
+C1COC(=O)O1,0.507,COC(=O)OC,0.402,C1=COC(=O)O1,0.022,[Li+].C(C(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(C(F)(F)F)(F)F)(F)(F)F,0.069,O,0,O,0,0.854
+C1COC(=O)O1,0.359,COC(=O)OC,0.569,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,O,0,0.854
+C1COC(=O)O1,0.331,O=C(OCC)OCC,0.577,[Li+].F[P-](F)(F)(F)(F)F,0.092,O,0,O,0,O,0,0.886
+C1COC(=O)O1,0.594,O=C(OCC)OCC,0.327,[Li+].F[P-](F)(F)(F)(F)F,0.079,O,0,O,0,O,0,0.921
+C1COC(=O)O1,0.5,CCOC(=O)OC,0.423,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.046,[Li+].O=C1O[B-]2(OC1=O)OC(=O)C(=O)O2,0.031,O,0,O,0,0.924
+C1COC(=O)O1,0.526,O=C(OCC)OCC,0.392,[Li+].F[P-](F)(F)(F)(F)F,0.083,O,0,O,0,O,0,1.013
+C1COC(=O)O1,0.356,COC(=O)OC,0.566,FC(F)(F)COB(OCC(F)(F)F)OCC(F)(F)F,0.007,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,1.046
+C1COC(=O)O1,0.682,CCOC(=O)OC,0.247,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.043,[Li+].O=C1O[B-]2(OC1=O)OC(=O)C(=O)O2,0.028,O,0,O,0,1.076
+C1COC(=O)O1,0.854,CCOC(=O)OC,0.08,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.039,[Li+].O=C1O[B-]2(OC1=O)OC(=O)C(=O)O2,0.026,O,0,O,0,1.081
+C1C(OC(=O)O1)F,0.497,COC(=O)OC,0.431,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,O,0,1.085
+C1C(OC(=O)O1)F,0.107,C1COC(=O)O1,0.526,O=C(OCC)OCC,0.289,[Li+].F[P-](F)(F)(F)(F)F,0.078,O,0,O,0,1.108
+C1COC(=O)O1,0.496,COC(=O)OC,0.393,C1C(OC(=O)O1)F,0.045,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.066,O,0,O,0,1.108
+COCCOC,0.73,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.27,O,0,O,0,O,0,O,0,1.143
+C1COC(=O)O1,0.327,O=C(OCC)OCC,0.594,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.079,O,0,O,0,O,0,1.155
+C1COC(=O)O1,0.338,COC(=O)OC,0.625,[Li+].[O-]P(=O)(F)F,0.008,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.03,O,0,O,0,1.194
+COCCOC,0.731,[Li+].[O-]P(=O)(F)F,0.064,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.205,O,0,O,0,O,0,1.215
+COCCOCCOCCOCCOC,0.819,FS([N-]S(F)(=O)=O)(=O)=O.[Li+],0.181,O,0,O,0,O,0,O,0,1.222
+C1C(OC(=O)O1)F,0.497,COC(=O)OC,0.43,O1CCOCCOCCOCC1,0,[Li+].F[P-](F)(F)(F)(F)F,0.072,O,0,O,0,1.225
+COCCOC,0.706,[Li+].C(F)(F)(F)S(=O)(=O)[N-]S(=O)(=O)C(F)(F)F,0.008,[Li+].[O-]P(=O)(F)F,0.286,O,0,O,0,O,0,1.244

models/.gitattributes

@@ -0,0 +1,3 @@
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

models/fm4m.py

@@ -25,9 +25,17 @@ from sklearn.preprocessing import MinMaxScaler
 import torch
 from transformers import AutoTokenizer, AutoModel
 
-from .selfies_model.load import SELFIES as bart
-from .mhg_model import load as mhg
-from .smi_ted.smi_ted_light.load import load_smi_ted
+import sys
+sys.path.append("models/")
+
+from models.selfies_ted.load import SELFIES as bart
+from models.mhg_model import load as mhg
+from models.smi_ted.smi_ted_light.load import load_smi_ted
+
+import mordred
+from mordred import Calculator, descriptors
+from rdkit import Chem
+from rdkit.Chem import AllChem
 
 datasets = {}
 models = {}
@@ -48,7 +56,7 @@ def avail_models_data():
 
 
     models = [{"Name": "bart","Model Name": "SELFIES-TED","Description": "BART model for string based SELFIES modality", "Timestamp": "2024-06-21 12:32:20"},
-  {"Name": "mol-xl","Model Name": "Molformer", "Description": "MolFormer model for string based SMILES modality", "Timestamp": "2024-06-21 12:35:56"},
+  {"Name": "mol-xl","Model Name": "MolFormer", "Description": "MolFormer model for string based SMILES modality", "Timestamp": "2024-06-21 12:35:56"},
   {"Name": "mhg", "Model Name": "MHG-GED","Description": "Molecular hypergraph model", "Timestamp": "2024-07-10 00:09:42"},
   {"Name": "smi-ted", "Model Name": "SMI-TED","Description": "SMILES based encoder decoder model", "Timestamp": "2024-07-10 00:09:42"}]
 
@@ -58,8 +66,10 @@ def avail_models(raw=False):
 
     models = [{"Name": "smi-ted", "Model Name": "SMI-TED","Description": "SMILES based encoder decoder model"},
               {"Name": "bart","Model Name": "SELFIES-TED","Description": "BART model for string based SELFIES modality"},
-              {"Name": "mol-xl","Model Name": "Molformer", "Description": "MolFormer model for string based SMILES modality"},
+              {"Name": "mol-xl","Model Name": "MolFormer", "Description": "MolFormer model for string based SMILES modality"},
               {"Name": "mhg", "Model Name": "MHG-GED","Description": "Molecular hypergraph model"},
+              {"Name": "Mordred", "Model Name": "Mordred","Description": "Baseline: A descriptor-calculation software application that can calculate more than 1800 two- and three-dimensional descriptors"},
+              {"Name": "MorganFingerprint", "Model Name": "MorganFingerprint","Description": "Baseline: Circular atom environments based descriptor"}              
   ]
 
 
@@ -70,12 +80,22 @@ def avail_models(raw=False):
 
     return models
 
-def avail_downstream_models():
+def avail_downstream_models(raw=False):
     global downstream_models
 
-    with open("downstream_models.json", "r") as outfile:
-        downstream_models = json.load(outfile)
-    return downstream_models
+    downstream_models = [{"Name": "XGBClassifier", "Task Type": "Classfication"},
+                         {"Name": "DefaultClassifier", "Task Type": "Classfication"},
+                        {"Name": "SVR", "Task Type": "Regression"},
+                        {"Name": "Kernel Ridge", "Task Type": "Regression"},
+                        {"Name": "Linear Regression", "Task Type": "Regression"},
+                        {"Name": "DefaultRegressor", "Task Type": "Regression"},
+                         ]
+
+    if raw: return downstream_models
+    else:
+        return pd.DataFrame(downstream_models)
+
+
 
 def avail_datasets():
     global datasets
@@ -178,13 +198,15 @@ def update_downstream_model_list(list_model):
 
 avail_models_data()
 
+
+
 def get_representation(train_data,test_data,model_type, return_tensor=True):
     alias = {"MHG-GED": "mhg", "SELFIES-TED": "bart", "MolFormer": "mol-xl", "Molformer": "mol-xl", "SMI-TED": "smi-ted"}
     if model_type in alias.keys():
         model_type = alias[model_type]
 
     if model_type == "mhg":
-        model = mhg.load("models/mhg_model/pickles/mhggnn_pretrained_model_0724_2023.pickle")
+        model = mhg.load("../models/mhg_model/pickles/mhggnn_pretrained_model_0724_2023.pickle")
         with torch.no_grad():
             train_emb = model.encode(train_data)
             x_batch = torch.stack(train_emb)
@@ -196,7 +218,6 @@ def get_representation(train_data,test_data,model_type, return_tensor=True):
             x_batch_test = pd.DataFrame(x_batch_test)
 
 
-
     elif model_type == "bart":
         model = bart()
         model.load()
@@ -204,7 +225,7 @@ def get_representation(train_data,test_data,model_type, return_tensor=True):
         x_batch_test = model.encode(test_data, return_tensor=return_tensor)
 
     elif model_type == "smi-ted":
-        model = load_smi_ted(folder='./models/smi_ted/smi_ted_light', ckpt_filename='smi-ted-Light_40.pt')
+        model = load_smi_ted(folder='../models/smi_ted/smi_ted_light', ckpt_filename='smi-ted-Light_40.pt')
         with torch.no_grad():
             x_batch = model.encode(train_data, return_torch=return_tensor)
             x_batch_test = model.encode(test_data, return_torch=return_tensor)
@@ -237,35 +258,78 @@ def get_representation(train_data,test_data,model_type, return_tensor=True):
         if not return_tensor:
             x_batch = pd.DataFrame(x_batch)
             x_batch_test = pd.DataFrame(x_batch_test)
-
+    
+    elif model_type == 'Mordred':
+        all_data = train_data + test_data
+        calc = Calculator(descriptors, ignore_3D=True)
+        mol_list = [Chem.MolFromSmiles(sm) for sm in all_data]
+        x_all = calc.pandas(mol_list)
+        print (f'original mordred fv dim: {x_all.shape}')
+        
+        for j in x_all.columns:
+            for k in range(len(x_all[j])):
+                i = x_all.loc[k, j]
+                if type(i) is mordred.error.Missing or type(i) is mordred.error.Error:
+                    x_all.loc[k, j] = np.nan
+                    
+        x_all.dropna(how="any", axis = 1, inplace=True)
+        print (f'Nan excluded mordred fv dim: {x_all.shape}')
+        
+        x_batch = x_all.iloc[:len(train_data)]
+        x_batch_test = x_all.iloc[len(train_data):]
+        # print(f'x_batch: {len(x_batch)}, x_batch_test: {len(x_batch_test)}')
+        
+    elif model_type == 'MorganFingerprint':
+        params = {'radius':2, 'nBits':1024}
+        
+        mol_train = [Chem.MolFromSmiles(sm) for sm in train_data]
+        mol_test = [Chem.MolFromSmiles(sm) for sm in test_data]
+        
+        x_batch = []
+        for mol in mol_train:
+            info = {}
+            fp = AllChem.GetMorganFingerprintAsBitVect(mol, **params, bitInfo=info)
+            vector = list(fp)
+            x_batch.append(vector)
+        x_batch = pd.DataFrame(x_batch)
+        
+        x_batch_test = []
+        for mol in mol_test:
+            info = {}
+            fp = AllChem.GetMorganFingerprintAsBitVect(mol, **params, bitInfo=info)
+            vector = list(fp)
+            x_batch_test.append(vector)
+        x_batch_test = pd.DataFrame(x_batch_test)
 
     return x_batch, x_batch_test
 
-def single_modal(model,dataset, downstream_model,params):
+def single_modal(model,dataset=None, downstream_model=None, params=None, x_train=None, x_test=None, y_train=None, y_test=None):
     print(model)
-    alias = {"MHG-GED":"mhg", "SELFIES-TED": "bart", "MolFormer":"mol-xl", "SMI-TED": "smi-ted"}
+    alias = {"MHG-GED":"mhg", "SELFIES-TED": "bart", "MolFormer":"mol-xl", "Molformer": "mol-xl", "SMI-TED": "smi-ted"}
     data = avail_models(raw=True)
     df = pd.DataFrame(data)
-    print(list(df["Name"].values))
-    if alias[model] in list(df["Name"].values):
-        if model in alias.keys():
+    #print(list(df["Name"].values))
+    
+    if model in list(df["Name"].values):
+        model_type = model
+    elif alias[model] in list(df["Name"].values):
             model_type = alias[model]
-        else:
-            model_type = model
     else:
         print("Model not available")
         return
+    
 
     data = avail_datasets()
     df = pd.DataFrame(data)
-    print(list(df["Dataset"].values))
+    #print(list(df["Dataset"].values))
 
     if dataset in list(df["Dataset"].values):
         task = dataset
-        with open(f"./representation/{task}_{model_type}.pkl", "rb") as f1:
+        with open(f"representation/{task}_{model_type}.pkl", "rb") as f1:
             x_batch, y_batch, x_batch_test, y_batch_test = pickle.load(f1)
         print(f" Representation loaded successfully")
-    else:
+
+    elif x_train==None:
 
         print("Custom Dataset")
         #return
@@ -283,14 +347,40 @@ def single_modal(model,dataset, downstream_model,params):
 
         print(f" Representation loaded successfully")
 
+    else:
 
-
-
+        y_batch = y_train
+        y_batch_test = y_test
+        x_batch, x_batch_test = get_representation(x_train, x_test, model_type)
+    
+    # exclude row containing Nan value
+    if isinstance(x_batch, torch.Tensor):
+        x_batch = pd.DataFrame(x_batch)    
+    nan_indices = x_batch.index[x_batch.isna().any(axis=1)]
+    if len(nan_indices) > 0:
+        x_batch.dropna(inplace = True)
+        for index in sorted(nan_indices, reverse=True):
+            del y_batch[index]
+        print(f'x_batch Nan index: {nan_indices}')
+        print(f'x_batch shape: {x_batch.shape}, y_batch len: {len(y_batch)}')
+            
+    if isinstance(x_batch_test, torch.Tensor):
+        x_batch_test = pd.DataFrame(x_batch_test)
+    nan_indices = x_batch_test.index[x_batch_test.isna().any(axis=1)]
+    if len(nan_indices) > 0:
+        x_batch_test.dropna(inplace = True)
+        for index in sorted(nan_indices, reverse=True):
+            del y_batch_test[index]
+        print(f'x_batch_test Nan index: {nan_indices}')
+        print(f'x_batch_test shape: {x_batch_test.shape}, y_batch_test len: {len(y_batch_test)}')
 
     print(f" Calculating ROC AUC Score ...")
 
     if downstream_model == "XGBClassifier":
-        xgb_predict_concat = XGBClassifier(**params) # n_estimators=5000, learning_rate=0.01, max_depth=10
+        if params == None:
+            xgb_predict_concat = XGBClassifier()
+        else:
+            xgb_predict_concat = XGBClassifier(**params) # n_estimators=5000, learning_rate=0.01, max_depth=10
         xgb_predict_concat.fit(x_batch, y_batch)
 
         y_prob = xgb_predict_concat.predict_proba(x_batch_test)[:, 1]
@@ -300,21 +390,26 @@ def single_modal(model,dataset, downstream_model,params):
         print(f"ROC-AUC Score: {roc_auc:.4f}")
 
         try:
-            with open(f"./plot_emb/{task}_{model_type}.pkl", "rb") as f1:
+            with open(f"plot_emb/{task}_{model_type}.pkl", "rb") as f1:
                 class_0,class_1 = pickle.load(f1)
         except:
             print("Generating latent plots")
             reducer = umap.UMAP(metric='euclidean', n_neighbors=10, n_components=2, low_memory=True, min_dist=0.1,
                                 verbose=False)
             n_samples = np.minimum(1000, len(x_batch))
-            features_umap = reducer.fit_transform(x_batch[:n_samples])
+
             try:x = y_batch.values[:n_samples]
-            except:x = y_batch[:n_samples]
+            except: x = y_batch[:n_samples]
             index_0 = [index for index in range(len(x)) if x[index] == 0]
             index_1 = [index for index in range(len(x)) if x[index] == 1]
 
-            class_0 = features_umap[index_0]
-            class_1 = features_umap[index_1]
+            try:
+                features_umap = reducer.fit_transform(x_batch[:n_samples])
+                class_0 = features_umap[index_0]
+                class_1 = features_umap[index_1]
+            except:
+                class_0 = []
+                class_1 = []
             print("Generating latent plots : Done")
 
         #vizualize(roc_auc,fpr, tpr, x_batch, y_batch )
@@ -334,20 +429,29 @@ def single_modal(model,dataset, downstream_model,params):
         print(f"ROC-AUC Score: {roc_auc:.4f}")
 
         try:
-            with open(f"./plot_emb/{task}_{model_type}.pkl", "rb") as f1:
+            with open(f"plot_emb/{task}_{model_type}.pkl", "rb") as f1:
                 class_0,class_1 = pickle.load(f1)
         except:
             print("Generating latent plots")
             reducer = umap.UMAP(metric='euclidean', n_neighbors=  10, n_components=2, low_memory=True, min_dist=0.1, verbose=False)
             n_samples = np.minimum(1000,len(x_batch))
-            features_umap = reducer.fit_transform(x_batch[:n_samples])
-            try:x = y_batch.values[:n_samples]
-            except:x = y_batch[:n_samples]
-            index_0 = [index for index in range(len(x)) if x[index] == 0]
-            index_1 = [index for index in range(len(x)) if x[index] == 1]
 
-            class_0 = features_umap[index_0]
-            class_1 = features_umap[index_1]
+            try:
+                x = y_batch.values[:n_samples]
+            except:
+                x = y_batch[:n_samples]
+
+            try:
+                features_umap = reducer.fit_transform(x_batch[:n_samples])
+                index_0 = [index for index in range(len(x)) if x[index] == 0]
+                index_1 = [index for index in range(len(x)) if x[index] == 1]
+
+                class_0 = features_umap[index_0]
+                class_1 = features_umap[index_1]
+            except:
+                class_0 = []
+                class_1 = []
+
             print("Generating latent plots : Done")
 
         #vizualize(roc_auc,fpr, tpr, x_batch, y_batch )
@@ -355,16 +459,19 @@ def single_modal(model,dataset, downstream_model,params):
         result = f"ROC-AUC Score: {roc_auc:.4f}"
 
         return result, roc_auc,fpr, tpr, class_0, class_1
-
+    
     elif downstream_model == "SVR":
-        regressor = SVR(**params)
+        if params == None:
+            regressor = SVR()
+        else:            
+            regressor = SVR(**params)
         model = TransformedTargetRegressor(regressor= regressor,
                                                 transformer = MinMaxScaler(feature_range=(-1, 1))
                                                 ).fit(x_batch,y_batch)
-
+        
         y_prob = model.predict(x_batch_test)
         RMSE_score = np.sqrt(mean_squared_error(y_batch_test, y_prob))
-
+        
         print(f"RMSE Score: {RMSE_score:.4f}")
         result = f"RMSE Score: {RMSE_score:.4f}"
 
@@ -372,20 +479,28 @@ def single_modal(model,dataset, downstream_model,params):
         reducer = umap.UMAP(metric='euclidean', n_neighbors=10, n_components=2, low_memory=True, min_dist=0.1,
                             verbose=False)
         n_samples = np.minimum(1000, len(x_batch))
-        features_umap = reducer.fit_transform(x_batch[:n_samples])
-        try:x = y_batch.values[:n_samples]
-        except:x = y_batch[:n_samples]
+
+        try: x = y_batch.values[:n_samples]
+        except: x = y_batch[:n_samples]
         #index_0 = [index for index in range(len(x)) if x[index] == 0]
         #index_1 = [index for index in range(len(x)) if x[index] == 1]
 
-        class_0 = features_umap#[index_0]
-        class_1 = features_umap#[index_1]
+        try:
+            features_umap = reducer.fit_transform(x_batch[:n_samples])
+            class_0 = features_umap#[index_0]
+            class_1 = features_umap#[index_1]
+        except:
+            class_0 = []
+            class_1 = []
         print("Generating latent plots : Done")
-
+        
         return result, RMSE_score,y_batch_test, y_prob, class_0, class_1
 
     elif downstream_model == "Kernel Ridge":
-        regressor = KernelRidge(**params)
+        if params == None:
+            regressor = KernelRidge()
+        else:
+            regressor = KernelRidge(**params)
         model = TransformedTargetRegressor(regressor=regressor,
                                            transformer=MinMaxScaler(feature_range=(-1, 1))
                                            ).fit(x_batch, y_batch)
@@ -401,8 +516,8 @@ def single_modal(model,dataset, downstream_model,params):
                             verbose=False)
         n_samples = np.minimum(1000, len(x_batch))
         features_umap = reducer.fit_transform(x_batch[:n_samples])
-        try:x = y_batch.values[:n_samples]
-        except:x = y_batch[:n_samples]
+        try: x = y_batch.values[:n_samples]
+        except: x = y_batch[:n_samples]
         # index_0 = [index for index in range(len(x)) if x[index] == 0]
         # index_1 = [index for index in range(len(x)) if x[index] == 1]
 
@@ -414,7 +529,10 @@ def single_modal(model,dataset, downstream_model,params):
 
 
     elif downstream_model == "Linear Regression":
-        regressor = LinearRegression(**params)
+        if params == None:
+            regressor = LinearRegression()
+        else:
+            regressor = LinearRegression(**params)
         model = TransformedTargetRegressor(regressor=regressor,
                                            transformer=MinMaxScaler(feature_range=(-1, 1))
                                            ).fit(x_batch, y_batch)
@@ -431,7 +549,7 @@ def single_modal(model,dataset, downstream_model,params):
         n_samples = np.minimum(1000, len(x_batch))
         features_umap = reducer.fit_transform(x_batch[:n_samples])
         try:x = y_batch.values[:n_samples]
-        except:x = y_batch[:n_samples]
+        except: x = y_batch[:n_samples]
         # index_0 = [index for index in range(len(x)) if x[index] == 0]
         # index_1 = [index for index in range(len(x)) if x[index] == 1]
 
@@ -460,7 +578,7 @@ def single_modal(model,dataset, downstream_model,params):
         n_samples = np.minimum(1000, len(x_batch))
         features_umap = reducer.fit_transform(x_batch[:n_samples])
         try:x = y_batch.values[:n_samples]
-        except:x = y_batch[:n_samples]
+        except: x = y_batch[:n_samples]
         # index_0 = [index for index in range(len(x)) if x[index] == 0]
         # index_1 = [index for index in range(len(x)) if x[index] == 1]
 
@@ -469,10 +587,10 @@ def single_modal(model,dataset, downstream_model,params):
         print("Generating latent plots : Done")
 
         return result, RMSE_score, y_batch_test, y_prob, class_0, class_1
+        
 
-
-def multi_modal(model_list,dataset, downstream_model,params):
-    print(model_list)
+def multi_modal(model_list,dataset=None, downstream_model=None,params=None, x_train=None, x_test=None, y_train=None, y_test=None):
+    #print(model_list)
     data = avail_datasets()
     df = pd.DataFrame(data)
     list(df["Dataset"].values)
@@ -480,7 +598,7 @@ def multi_modal(model_list,dataset, downstream_model,params):
     if dataset in list(df["Dataset"].values):
         task = dataset
         predefined = True
-    else:
+    elif x_train==None:
         predefined = False
         components = dataset.split(",")
         train_data = pd.read_csv(components[0])[components[2]]
@@ -490,13 +608,18 @@ def multi_modal(model_list,dataset, downstream_model,params):
         y_batch_test = pd.read_csv(components[1])[components[3]]
 
         print("Custom Dataset loaded")
-
+    else:
+        predefined = False
+        y_batch = y_train
+        y_batch_test = y_test
+        train_data = x_train
+        test_data = x_test
 
     data = avail_models(raw=True)
     df = pd.DataFrame(data)
     list(df["Name"].values)
 
-    alias = {"MHG-GED":"mhg", "SELFIES-TED": "bart", "MolFormer":"mol-xl", "SMI-TED":"smi-ted"}
+    alias = {"MHG-GED":"mhg", "SELFIES-TED": "bart", "MolFormer":"mol-xl",  "Molformer": "mol-xl","SMI-TED":"smi-ted", "Mordred": "Mordred", "MorganFingerprint": "MorganFingerprint"}
     #if set(model_list).issubset(list(df["Name"].values)):
     if set(model_list).issubset(list(alias.keys())):
         for i, model in enumerate(model_list):
@@ -507,7 +630,7 @@ def multi_modal(model_list,dataset, downstream_model,params):
 
             if i == 0:
                 if predefined:
-                    with open(f"./representation/{task}_{model_type}.pkl", "rb") as f1:
+                    with open(f"representation/{task}_{model_type}.pkl", "rb") as f1:
                         x_batch, y_batch, x_batch_test, y_batch_test = pickle.load(f1)
                     print(f" Loaded representation/{task}_{model_type}.pkl")
                 else:
@@ -517,7 +640,7 @@ def multi_modal(model_list,dataset, downstream_model,params):
 
             else:
                 if predefined:
-                    with open(f"./representation/{task}_{model_type}.pkl", "rb") as f1:
+                    with open(f"representation/{task}_{model_type}.pkl", "rb") as f1:
                         x_batch_1, y_batch_1, x_batch_test_1, y_batch_test_1 = pickle.load(f1)
                         print(f" Loaded representation/{task}_{model_type}.pkl")
                 else:
@@ -528,7 +651,6 @@ def multi_modal(model_list,dataset, downstream_model,params):
                 x_batch = pd.concat([x_batch, x_batch_1], axis=1)
                 x_batch_test = pd.concat([x_batch_test, x_batch_test_1], axis=1)
 
-
     else:
         print("Model not available")
         return
@@ -538,11 +660,31 @@ def multi_modal(model_list,dataset, downstream_model,params):
 
     num_columns = x_batch.shape[1]
     x_batch.columns = [f'{i + 1}' for i in range(num_columns)]
-
+    
+    # exclude row containing Nan value
+    if isinstance(x_batch, torch.Tensor):
+        x_batch = pd.DataFrame(x_batch)    
+    nan_indices = x_batch.index[x_batch.isna().any(axis=1)]
+    if len(nan_indices) > 0:
+        x_batch.dropna(inplace = True)
+        for index in sorted(nan_indices, reverse=True):
+            del y_batch[index]
+        print(f'x_batch Nan index: {nan_indices}')
+        print(f'x_batch shape: {x_batch.shape}, y_batch len: {len(y_batch)}')
+            
+    if isinstance(x_batch_test, torch.Tensor):
+        x_batch_test = pd.DataFrame(x_batch_test)
+    nan_indices = x_batch_test.index[x_batch_test.isna().any(axis=1)]
+    if len(nan_indices) > 0:
+        x_batch_test.dropna(inplace = True)
+        for index in sorted(nan_indices, reverse=True):
+            del y_batch_test[index]
+        print(f'x_batch_test Nan index: {nan_indices}')
+        print(f'x_batch_test shape: {x_batch_test.shape}, y_batch_test len: {len(y_batch_test)}')
 
     print(f"Representations loaded successfully")
     try:
-        with open(f"./plot_emb/{task}_multi.pkl", "rb") as f1:
+        with open(f"plot_emb/{task}_multi.pkl", "rb") as f1:
             class_0, class_1 = pickle.load(f1)
     except:
         print("Generating latent plots")
@@ -552,7 +694,7 @@ def multi_modal(model_list,dataset, downstream_model,params):
         features_umap = reducer.fit_transform(x_batch[:n_samples])
 
         if "Classifier" in downstream_model:
-            try:x = y_batch.values[:n_samples]
+            try: x = y_batch.values[:n_samples]
             except: x = y_batch[:n_samples]
             index_0 = [index for index in range(len(x)) if x[index] == 0]
             index_1 = [index for index in range(len(x)) if x[index] == 1]
@@ -570,7 +712,10 @@ def multi_modal(model_list,dataset, downstream_model,params):
 
 
     if downstream_model == "XGBClassifier":
-        xgb_predict_concat = XGBClassifier(**params)#n_estimators=5000, learning_rate=0.01, max_depth=10)
+        if params == None:
+            xgb_predict_concat = XGBClassifier()
+        else:            
+            xgb_predict_concat = XGBClassifier(**params)#n_estimators=5000, learning_rate=0.01, max_depth=10)
         xgb_predict_concat.fit(x_batch, y_batch)
 
         y_prob = xgb_predict_concat.predict_proba(x_batch_test)[:, 1]
@@ -608,21 +753,27 @@ def multi_modal(model_list,dataset, downstream_model,params):
         return result, roc_auc,fpr, tpr, class_0, class_1
 
     elif downstream_model == "SVR":
-        regressor = SVR(**params)
+        if params == None:
+            regressor = SVR()
+        else:
+            regressor = SVR(**params)
         model = TransformedTargetRegressor(regressor= regressor,
                                                 transformer = MinMaxScaler(feature_range=(-1, 1))
                                                 ).fit(x_batch,y_batch)
-
+        
         y_prob = model.predict(x_batch_test)
         RMSE_score = np.sqrt(mean_squared_error(y_batch_test, y_prob))
-
+        
         print(f"RMSE Score: {RMSE_score:.4f}")
         result = f"RMSE Score: {RMSE_score:.4f}"
-
+        
         return result, RMSE_score,y_batch_test, y_prob, class_0, class_1
 
     elif downstream_model == "Linear Regression":
-        regressor = LinearRegression(**params)
+        if params == None:
+            regressor = LinearRegression()
+        else:
+            regressor = LinearRegression(**params)
         model = TransformedTargetRegressor(regressor=regressor,
                                            transformer=MinMaxScaler(feature_range=(-1, 1))
                                            ).fit(x_batch, y_batch)
@@ -636,7 +787,10 @@ def multi_modal(model_list,dataset, downstream_model,params):
         return result, RMSE_score, y_batch_test, y_prob, class_0, class_1
 
     elif downstream_model == "Kernel Ridge":
-        regressor = KernelRidge(**params)
+        if params == None:
+            regressor = KernelRidge()
+        else:
+            regressor = KernelRidge(**params)
         model = TransformedTargetRegressor(regressor=regressor,
                                            transformer=MinMaxScaler(feature_range=(-1, 1))
                                            ).fit(x_batch, y_batch)
@@ -665,6 +819,144 @@ def multi_modal(model_list,dataset, downstream_model,params):
 
 
 
+def finetune_optuna(x_batch,y_batch, x_batch_test, y_test ):
+    print(f" Finetuning with Optuna and calculating ROC AUC Score ...")
+    X_train = x_batch.values
+    y_train = y_batch.values
+    X_test = x_batch_test.values
+    y_test = y_test.values
+    def objective(trial):
+        # Define parameters to be optimized
+        params = {
+            # 'objective': 'binary:logistic',
+            'eval_metric': 'auc',
+            'verbosity': 0,
+            'n_estimators': trial.suggest_int('n_estimators', 1000, 10000),
+            # 'booster': trial.suggest_categorical('booster', ['gbtree', 'gblinear', 'dart']),
+            # 'lambda': trial.suggest_loguniform('lambda', 1e-8, 1.0),
+            'alpha': trial.suggest_loguniform('alpha', 1e-8, 1.0),
+            'max_depth': trial.suggest_int('max_depth', 1, 12),
+            # 'eta': trial.suggest_loguniform('eta', 1e-8, 1.0),
+            # 'gamma': trial.suggest_loguniform('gamma', 1e-8, 1.0),
+            # 'grow_policy': trial.suggest_categorical('grow_policy', ['depthwise', 'lossguide']),
+            # "subsample": trial.suggest_float("subsample", 0.05, 1.0),
+            # "colsample_bytree": trial.suggest_float("colsample_bytree", 0.05, 1.0),
+        }
+
+        # Train XGBoost model
+        dtrain = xgb.DMatrix(X_train, label=y_train)
+        dtest = xgb.DMatrix(X_test, label=y_test)
+
+        model = xgb.train(params, dtrain)
+
+        # Predict probabilities
+        y_pred = model.predict(dtest)
+
+        # Calculate ROC AUC score
+        roc_auc = roc_auc_score(y_test, y_pred)
+        print("ROC_AUC : ", roc_auc)
+
+        return roc_auc
+
+def add_new_model():
+    models = avail_models(raw=True)
+
+    # Function to display models
+    def display_models():
+        for model in models:
+            model_display = f"Name: {model['Name']}, Description: {model['Description']}, Timestamp: {model['Timestamp']}"
+            print(model_display)
+
+    # Function to update models
+    def update_models(new_name, new_description, new_path):
+        new_model = {
+            "Name": new_name,
+            "Description": new_description,
+            "Timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            #"path": new_path
+        }
+        models.append(new_model)
+        with open("models.json", "w") as outfile:
+            json.dump(models, outfile)
+
+        print("Model uploaded and updated successfully!")
+        list_models()
+        #display_models()
+
+    # Widgets
+    name_text = widgets.Text(description="Name:", layout=Layout(width='50%'))
+    description_text = widgets.Text(description="Description:", layout=Layout(width='50%'))
+    path_text = widgets.Text(description="Path:", layout=Layout(width='50%'))
+
+    def browse_callback(b):
+        root = tk.Tk()
+        root.withdraw()  # Hide the main window
+        file_path = filedialog.askopenfilename(title="Select a Model File")
+        if file_path:
+            path_text.value = file_path
+
+    browse_button = widgets.Button(description="Browse")
+    browse_button.on_click(browse_callback)
+
+    def submit_callback(b):
+        update_models(name_text.value, description_text.value, path_text.value)
+
+    submit_button = widgets.Button(description="Submit")
+    submit_button.on_click(submit_callback)
+
+    # Display widgets
+    display(VBox([name_text, description_text, path_text, browse_button, submit_button]))
+
+
+def add_new_dataset():
+    # Sample data
+    datasets = avail_datasets()
+
+    # Function to display models
+    def display_datasets():
+        for dataset in datasets:
+            dataset_display = f"Name: {dataset['Dataset']}, Input: {dataset['Input']},Output: {dataset['Output']},Path: {dataset['Path']}, Timestamp: {dataset['Timestamp']}"
+
+    # Function to update models
+    def update_datasets(new_dataset, new_input, new_output, new_path):
+        new_model = {
+            "Dataset": new_dataset,
+            "Input": new_input,
+            "Output": new_output,
+            "Timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "Path": os.path.basename(new_path)
+        }
+        datasets.append(new_model)
+        with open("datasets.json", "w") as outfile:
+            json.dump(datasets, outfile)
+
+        print("Dataset uploaded and updated successfully!")
+        list_data()
+
+
+    # Widgets
+    dataset_text = widgets.Text(description="Dataset:", layout=Layout(width='50%'))
+    input_text = widgets.Text(description="Input:", layout=Layout(width='50%'))
+    output_text = widgets.Text(description="Output:", layout=Layout(width='50%'))
+    path_text = widgets.Text(description="Path:", layout=Layout(width='50%'))
+
+    def browse_callback(b):
+        root = tk.Tk()
+        root.withdraw()  # Hide the main window
+        file_path = filedialog.askopenfilename(title="Select a Dataset File")
+        if file_path:
+            path_text.value = file_path
+
+    browse_button = widgets.Button(description="Browse")
+    browse_button.on_click(browse_callback)
+
+    def submit_callback(b):
+        update_datasets(dataset_text.value, input_text.value, output_text.value, path_text.value)
+
+    submit_button = widgets.Button(description="Submit")
+    submit_button.on_click(submit_callback)
+
+    display(VBox([dataset_text, input_text, output_text, path_text, browse_button, submit_button]))
 
 
 

models/mhg_model/README.md

@@ -27,7 +27,7 @@ In addition, the decoder inherits the theoretical guarantee of MHG on always gen
 
 ### Pretrained Models and Training Logs
 
-We provide checkpoints of the MHG-GNN model pre-trained on a dataset of ~1.34M molecules curated from PubChem. (later) For model weights: [HuggingFace Link]()
+We provide checkpoints of the MHG-GNN model pre-trained on a dataset of ~1.34M molecules curated from PubChem. (later) For model weights: [HuggingFace Link](https://huggingface.co/ibm/materials.mhg-ged/blob/main/mhggnn_pretrained_model_0724_2023.pickle)
 
 Add the MHG-GNN `pre-trained weights.pt` to the `models/` directory according to your needs. 
 

models/mhg_model/load.py

@@ -17,6 +17,7 @@ from typing_extensions import Self
 
 from .graph_grammar.io.smi import hg_to_mol
 from .models.mhgvae import GrammarGINVAE
+
 from huggingface_hub import hf_hub_download
 
 
@@ -73,12 +74,30 @@ class PretrainedModelWrapper:
         return output
 
 
-def load(model_name: str = "models/mhg_model/pickles/mhggnn_pretrained_model_0724_2023.pickle") -> Optional[
+def load(model_name: str = "mhg_model/pickles/mhggnn_pretrained_model_0724_2023.pickle") -> Optional[
     PretrainedModelWrapper]:
+
     repo_id = "ibm/materials.mhg-ged"
     filename = "pytorch_model.bin" #"mhggnn_pretrained_model_0724_2023.pickle"
     file_path = hf_hub_download(repo_id=repo_id, filename=filename)
     with open(file_path, "rb") as f:
         model_dict = torch.load(f)
         return PretrainedModelWrapper(model_dict)
+
+
+    """try:
+        if os.path.isfile(model_name):
+            with open(model_name, "rb") as f:
+                model_dict = pickle.load(f)
+                print("MHG Model Loaded")
+                return PretrainedModelWrapper(model_dict)
+
+    except:
+
+        for p in sys.path:
+            file = p + "/" + model_name
+            if os.path.isfile(file):
+                with open(file, "rb") as f:
+                    model_dict = pickle.load(f)
+                    return PretrainedModelWrapper(model_dict)"""
     return None

models/selfies_ted/README.md

@@ -0,0 +1,87 @@
+---
+license: apache-2.0
+library_name: transformers
+pipeline_tag: feature-extraction
+tags:
+- chemistry
+---
+
+# selfies-ted
+
+selfies-ted is a project for encoding SMILES (Simplified Molecular Input Line Entry System) into SELFIES (SELF-referencing Embedded Strings) and generating embeddings for molecular representations.
+
+![selfies-ted](selfies-ted.png)
+## Model Architecture
+
+Configuration details
+
+Encoder and Decoder FFN dimensions: 256
+Number of attention heads: 4
+Number of encoder and decoder layers: 2
+Total number of hidden layers: 6
+Maximum position embeddings: 128
+Model dimension (d_model): 256
+
+## Pretrained Models and Training Logs
+We provide checkpoints of the selfies-ted model pre-trained on a dataset of molecules curated from PubChem. The pre-trained model shows competitive performance on molecular representation tasks. For model weights: "HuggingFace link".
+
+To install and use the pre-trained model:
+
+Download the selfies_ted_model.pkl file from the "HuggingFace link".
+Add the selfies-ted selfies_ted_model.pkl to the models/ directory. The directory structure should look like the following:
+
+```
+models/
+└── selfies_ted_model.pkl
+```
+
+## Installation
+
+To use this project, you'll need to install the required dependencies. We recommend using a virtual environment:
+
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows use `venv\Scripts\activate`
+```
+
+Install the required dependencies
+
+```
+pip install -r requirements.txt
+```
+
+
+## Usage
+
+### Import
+
+```
+import load
+```
+### Training the Model
+
+To train the model, use the train.py script:
+
+```
+python train.py -f <path_to_your_data_file>
+```
+
+
+Note: The actual usage may depend on the specific implementation in load.py. Please refer to the source code for detailed functionality.
+
+### Load the model and tokenizer
+```
+load.load("path/to/checkpoint.pkl")
+```
+### Encode SMILES strings
+```
+smiles_list = ["COC", "CCO"]
+```
+```
+embeddings = load.encode(smiles_list)
+```
+
+
+## Example Notebook
+
+Example notebook of this project is `selfies-ted-example.ipynb`. 

models/selfies_ted/load.py

@@ -0,0 +1,92 @@
+import os
+import sys
+import torch
+import selfies as sf  # selfies>=2.1.1
+import pickle
+import pandas as pd
+import numpy as np
+from datasets import Dataset
+from rdkit import Chem
+from transformers import AutoTokenizer, AutoModel
+
+
+class SELFIES(torch.nn.Module):
+
+    def __init__(self):
+        super().__init__()
+        self.model = None
+        self.tokenizer = None
+        self.invalid = []
+
+    def get_selfies(self, smiles_list):
+        self.invalid = []
+        spaced_selfies_batch = []
+        for i, smiles in enumerate(smiles_list):
+            try:
+                selfies = sf.encoder(smiles.rstrip())
+            except:
+                try:
+                    smiles = Chem.MolToSmiles(Chem.MolFromSmiles(smiles.rstrip()))
+                    selfies = sf.encoder(smiles)
+                except:
+                    selfies = "[]"
+                    self.invalid.append(i)
+
+            spaced_selfies_batch.append(selfies.replace('][', '] ['))
+
+        return spaced_selfies_batch
+
+
+    def get_embedding(self, selfies):
+        encoding = self.tokenizer(selfies["selfies"], return_tensors='pt', max_length=128, truncation=True, padding='max_length')
+        input_ids = encoding['input_ids']
+        attention_mask = encoding['attention_mask']
+        outputs = self.model.encoder(input_ids=input_ids, attention_mask=attention_mask)
+        model_output = outputs.last_hidden_state
+
+        input_mask_expanded = attention_mask.unsqueeze(-1).expand(model_output.size()).float()
+        sum_embeddings = torch.sum(model_output * input_mask_expanded, 1)
+        sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+        model_output = sum_embeddings / sum_mask
+
+        del encoding['input_ids']
+        del encoding['attention_mask']
+
+        encoding["embedding"] = model_output
+
+        return encoding
+
+
+    def load(self, checkpoint="bart-2908.pickle"):
+        """
+            inputs :
+                   checkpoint (pickle object)
+        """
+
+        self.tokenizer = AutoTokenizer.from_pretrained("ibm/materials.selfies-ted")
+        self.model = AutoModel.from_pretrained("ibm/materials.selfies-ted")
+
+
+
+
+
+    # TODO: remove `use_gpu` argument in validation pipeline
+    def encode(self, smiles_list=[], use_gpu=False, return_tensor=False):
+        """
+            inputs :
+                   checkpoint (pickle object)
+            :return: embedding
+        """
+        selfies = self.get_selfies(smiles_list)
+        selfies_df = pd.DataFrame(selfies,columns=["selfies"])
+        data = Dataset.from_pandas(selfies_df)
+        embedding = data.map(self.get_embedding, batched=True, num_proc=1, batch_size=128)
+        emb = np.asarray(embedding["embedding"].copy())
+
+        for idx in self.invalid:
+            emb[idx] = np.nan
+            print("Cannot encode {0} to selfies and embedding replaced by NaN".format(smiles_list[idx]))
+
+        if return_tensor:
+            return torch.tensor(emb)
+        return pd.DataFrame(emb)

models/selfies_ted/requirements.txt

@@ -0,0 +1,12 @@
+torch>=2.1.0
+transformers>=4.38
+numpy>=1.26.1
+datasets>=2.13.1
+evaluate>=0.4.0
+selfies>=2.1.0
+scikit-learn>=1.2.1
+pyarrow>=14.0.1
+requests>=2.31.0
+urllib3>=2.0.7
+aiohttp>=3.9.0
+zipp>=3.17.0

models/selfies_ted/selfies-ted-example.ipynb

@@ -0,0 +1,136 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9d9b6eb8-9edb-44bd-9e5a-3a6ea67f5117",
+   "metadata": {},
+   "source": [
+    "### Import library"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c3ac4418",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from load import SELFIES"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "790061cf-5470-4564-987e-aa2e492337db",
+   "metadata": {},
+   "source": [
+    "### Initialize and load"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "85847f26-e2f4-475a-a88e-41fd9cccfc0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = SELFIES()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "095e864c",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "model.load(checkpoint=\"bart-2908.pickle\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55f1a68c-c462-4dee-9139-9befb469f176",
+   "metadata": {},
+   "source": [
+    "### Example to get embeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2357ef0a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b494cbf9878a4f5c8f4093e38fb82fd5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/3 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "smiles_list = [\"CCO\", \"O=C=O\", \"OC(=O)c1ccccc1C(=O)O\"]\n",
+    "embeddings = model.encode(smiles_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3871c513-d0a9-4e70-9c18-3f0b491e07b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(3, 1024)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "embeddings.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "289a8795-d6d8-4828-b2b2-b4d4a97a4604",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

models/smi_ted/.gitignore

@@ -0,0 +1,18 @@
+# Model weights
+inference/smi_ted_light/smi-ted-Light_40.pt
+
+# pyenv
+.python-version
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# editor files
+.vscode/
+.DS_Store

models/smi_ted/README.md

@@ -0,0 +1,138 @@
+# SMILES-based Transformer Encoder-Decoder (SMI-TED)
+
+This repository provides PyTorch source code associated with our publication, "A Large Encoder-Decoder Family of Foundation Models for Chemical Language".
+
+**Paper:** [Arxiv Link](https://arxiv.org/abs/2407.20267)
+
+**HuggingFace:** [HuggingFace Link](https://huggingface.co/ibm/materials.smi-ted)
+
+For more information contact: [email protected] or [email protected].
+
+![ted-smi](images/smi-ted.png)
+
+## Introduction
+
+We present a large encoder-decoder chemical foundation model, SMILES-based Transformer Encoder-Decoder (SMI-TED), pre-trained on a curated dataset of 91 million SMILES samples sourced from PubChem, equivalent to 4 billion molecular tokens. SMI-TED supports various complex tasks, including quantum property prediction, with two main variants ($289M$ and $8 \times 289M$). Our experiments across multiple benchmark datasets demonstrate state-of-the-art performance for various tasks. Model weights are available at: [HuggingFace Link](https://huggingface.co/ibm/materials.smi-ted).
+
+## Table of Contents
+
+1. [Getting Started](#getting-started)
+    1. [Pretrained Models and Training Logs](#pretrained-models-and-training-logs)
+    2. [Replicating Conda Environment](#replicating-conda-environment)
+2. [Pretraining](#pretraining)
+3. [Finetuning](#finetuning)
+4. [Feature Extraction](#feature-extraction)
+5. [Citations](#citations)
+
+## Getting Started
+
+**This code and environment have been tested on Nvidia V100s and Nvidia A100s**
+
+### Pretrained Models and Training Logs
+
+We provide checkpoints of the SMI-TED model pre-trained on a dataset of ~91M molecules curated from PubChem. The pre-trained model shows competitive performance on classification and regression benchmarks from MoleculeNet. For model weights: [HuggingFace Link](https://huggingface.co/ibm/materials.smi-ted)
+
+Add the SMI-TED `pre-trained weights.pt` to the `inference/` or `finetune/` directory according to your needs. The directory structure should look like the following:
+
+```
+inference/
+├── smi_ted_light
+│   ├── smi_ted_light.pt
+│   ├── bert_vocab_curated.txt
+│   └── load.py
+```
+and/or:
+
+```
+finetune/
+├── smi_ted_light
+│   ├── smi_ted_light.pt
+│   ├── bert_vocab_curated.txt
+│   └── load.py
+```
+
+### Replicating Conda Environment
+
+Follow these steps to replicate our Conda environment and install the necessary libraries:
+
+#### Create and Activate Conda Environment
+
+```
+conda create --name smi-ted-env python=3.10
+conda activate smi-ted-env
+```
+
+#### Install Packages with Conda
+
+```
+conda install pytorch=2.1.0 pytorch-cuda=11.8 -c pytorch -c nvidia
+```
+
+#### Install Packages with Pip
+
+```
+pip install -r requirements.txt
+pip install pytorch-fast-transformers
+```
+
+## Pretraining
+
+For pretraining, we use two strategies: the masked language model method to train the encoder part and an encoder-decoder strategy to refine SMILES reconstruction and improve the generated latent space.
+
+SMI-TED is pre-trained on canonicalized and curated 91M SMILES from PubChem with the following constraints:
+
+- Compounds are filtered to a maximum length of 202 tokens during preprocessing.
+- A 95/5/0 split is used for encoder training, with 5% of the data for decoder pretraining.
+- A 100/0/0 split is also used to train the encoder and decoder directly, enhancing model performance.
+
+The pretraining code provides examples of data processing and model training on a smaller dataset, requiring 8 A100 GPUs.
+
+To pre-train the two variants of the SMI-TED model, run:
+
+```
+bash training/run_model_light_training.sh
+```
+or
+```
+bash training/run_model_large_training.sh
+```
+
+Use `train_model_D.py` to train only the decoder or `train_model_ED.py` to train both the encoder and decoder.
+
+## Finetuning
+
+The finetuning datasets and environment can be found in the [finetune](finetune/) directory. After setting up the environment, you can run a finetuning task with:
+
+```
+bash finetune/smi_ted_light/esol/run_finetune_esol.sh
+```
+
+Finetuning training/checkpointing resources will be available in directories named `checkpoint_<measure_name>`.
+
+## Feature Extraction
+
+The example notebook [smi_ted_encoder_decoder_example.ipynb](notebooks/smi_ted_encoder_decoder_example.ipynb) contains code to load checkpoint files and use the pre-trained model for encoder and decoder tasks. It also includes examples of classification and regression tasks. For model weights: [HuggingFace Link](https://huggingface.co/ibm/materials.smi-ted)
+
+To load smi-ted, you can simply use:
+
+```python
+model = load_smi_ted(
+    folder='../inference/smi_ted_light',
+    ckpt_filename='smi_ted_light.pt'
+)
+```
+
+To encode SMILES into embeddings, you can use:
+
+```python
+with torch.no_grad():
+    encoded_embeddings = model.encode(df['SMILES'], return_torch=True)
+```
+For decoder, you can use the function, so you can return from embeddings to SMILES strings:
+
+```python
+with torch.no_grad():
+    decoded_smiles = model.decode(encoded_embeddings)
+```
+
+

models/smi_ted/finetune/args.py

@@ -0,0 +1,337 @@
+import argparse
+
+
+def get_parser(parser=None):
+    if parser is None:
+        parser = argparse.ArgumentParser()
+
+    # Model
+    # model_arg = parser.add_argument_group('Model')
+    parser.add_argument("--n_head", type=int, default=8, help="GPT number of heads")
+    parser.add_argument("--n_layer", type=int, default=12, help="GPT number of layers")
+    parser.add_argument(
+        "--q_dropout", type=float, default=0.5, help="Encoder layers dropout"
+    )
+    parser.add_argument(
+        "--d_dropout", type=float, default=0.1, help="Decoder layers dropout"
+    )
+    parser.add_argument(
+        "--n_embd", type=int, default=768, help="Latent vector dimensionality"
+    )
+    parser.add_argument(
+        "--fc_h", type=int, default=512, help="Fully connected hidden dimensionality"
+    )
+    parser.add_argument("--n_output", type=int, default=1)
+
+    # Train
+    # train_arg = parser.add_argument_group('Train')
+    parser.add_argument("--n_batch", type=int, default=512, help="Batch size")
+    parser.add_argument(
+        "--unlike_alpha", type=float, default=1.0, help="unlikelihood loss alpha weight"
+    )
+    parser.add_argument(
+        "--from_scratch",
+        action="store_true",
+        default=False,
+        help="train on qm9 from scratch",
+    )
+    parser.add_argument(
+        "--unlikelihood",
+        action="store_true",
+        default=False,
+        help="use unlikelihood loss with gpt pretrain",
+    )
+    parser.add_argument(
+        "--grad_acc",
+        type=int,
+        default=1,
+        help="number of batches to accumulate gradients",
+    )
+    parser.add_argument(
+        "--checkpoint_every",
+        type=int,
+        default=1000,
+        help="save checkpoint every x iterations",
+    )
+    parser.add_argument(
+        "--clip_grad", type=int, default=50, help="Clip gradients to this value"
+    )
+    parser.add_argument(
+        "--lr_start", type=float, default=3 * 1e-4, help="Initial lr value"
+    )
+    parser.add_argument(
+        "--lr_end", type=float, default=3 * 1e-4, help="Maximum lr weight value"
+    )
+    parser.add_argument(
+        "--lr_multiplier", type=int, default=1, help="lr weight multiplier"
+    )
+    parser.add_argument(
+        "--n_last", type=int, default=1000, help="Number of iters to smooth loss calc"
+    )
+    parser.add_argument("--n_jobs", type=int, default=1, help="Number of threads")
+    parser.add_argument(
+        "--accelerator",
+        type=str,
+        default="ddp",
+        help="The accelerator backend to use (previously known as distributed_backend)",
+    )
+    parser.add_argument(
+        "--num_nodes",
+        type=int,
+        default=1,
+        help="number of GPU nodes for distributed training",
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="cuda",
+        help='Device to run: "cpu" or "cuda:<device number>"',
+    )
+    parser.add_argument("--seed", type=int, default=12345, help="Seed")
+    parser.add_argument(
+        "--init_params_from",
+        type=str,
+        default="",
+        help="Path to a ckpt used to initialize the parameters if no restart_path is provided",
+    )
+    parser.add_argument(
+        "--train_decoder_every",
+        type=int,
+        default=10,
+        help="Optimize decoder params every n batches",
+    )
+    parser.add_argument(
+        "--lr_decoder", type=float, default=1e-4, help="Learning rate for decoder part"
+    )
+    parser.add_argument(
+        "--local_rank",
+        type=int,
+        default=-1,
+        help="local_rank for distributed training on gpus",
+    )
+    parser.add_argument("--gpu", default=None, type=int, help="GPU id to use.")
+    parser.add_argument(
+        "--dist-backend", default="nccl", type=str, help="distributed backend"
+    )
+    parser.add_argument(
+        "--tensorboard_path", default="./runs/deepspeed", help="tensorboard log dir"
+    )
+
+    # common_arg = parser.add_argument_group('Common')
+    parser.add_argument(
+        "--vocab_load", type=str, required=False, help="Where to load the vocab"
+    )
+    parser.add_argument(
+        "--n_samples", type=int, required=False, help="Number of samples to sample"
+    )
+    parser.add_argument(
+        "--gen_save", type=str, required=False, help="Where to save the gen molecules"
+    )
+    parser.add_argument(
+        "--max_len", type=int, default=100, help="Max of length of SMILES"
+    )
+    parser.add_argument(
+        "--train_load", type=str, required=False, help="Where to load the model"
+    )
+    parser.add_argument(
+        "--val_load", type=str, required=False, help="Where to load the model"
+    )
+    parser.add_argument(
+        "--n_workers",
+        type=int,
+        required=False,
+        default=1,
+        help="Where to load the model",
+    )
+    # beam search hyper parameters
+    parser.add_argument(
+        "--beam_size", type=int, default=0, help="Number of beams to generate"
+    )
+    parser.add_argument(
+        "--num_seq_returned",
+        type=int,
+        default=0,
+        help="number of beams to be returned (must be <= beam_size",
+    )
+    parser.add_argument(
+        "--min_len", type=int, default=1, help="minimum length to be generated"
+    )
+    parser.add_argument(
+        "--nucleus_thresh", type=float, default=0.9, help="nucleus sampling threshold"
+    )
+    parser.add_argument(
+        "--finetune_path",
+        type=str,
+        default="",
+        help="path to  trainer file to continue training",
+    )
+    parser.add_argument(
+        "--restart_path",
+        type=str,
+        default="",
+        help="path to  trainer file to continue training",
+    )
+    parser.add_argument(
+        "--data_path", type=str, default="", help="path to pubchem file"
+    )
+    parser.add_argument(
+        "--pretext_size", type=int, default=0, help="number of k-mers to pretext"
+    )
+    parser.add_argument(
+        "--model_save_dir",
+        type=str,
+        required=False,
+        default="./models_dump/",
+        help="Where to save the models/log/config/vocab",
+    )
+    parser.add_argument(
+        "--model_save",
+        type=str,
+        required=False,
+        default="model.pt",
+        help="Where to save the model",
+    )
+    # parser.add_argument('--save_frequency',
+    #                        type=int, default=20,
+    #                        help='How often to save the model')
+    parser.add_argument(
+        "--num_epoch", type=int, default=1, help="number of epochs to train"
+    )
+    # parser.add_argument('--num_iter',
+    #                        type=int, default=-1,
+    #                        help='how many itersations per epoch (for unlikelihood tuning)')
+    parser.add_argument(
+        "--log_file", type=str, required=False, help="Where to save the log"
+    )
+    parser.add_argument(
+        "--tb_loc",
+        type=str,
+        required=False,
+        help="Where to save the tensorflow location",
+    )
+    parser.add_argument(
+        "--config_save", type=str, required=False, help="Where to save the config"
+    )
+    parser.add_argument("--vocab_save", type=str, help="Where to save the vocab")
+
+    # resume_arg = parser.add_argument_group('Resume')
+    parser.add_argument(
+        "--debug",
+        default=False,
+        action="store_true",
+        help="do not erase cache at end of program",
+    )
+    parser.add_argument(
+        "--fast_dev_run",
+        default=False,
+        help="This flag runs a “unit test” by running n if set to n (int) else 1 if set to True training and validation batch(es).",
+    )
+    parser.add_argument(
+        "--freeze_model",
+        default=False,
+        action="store_true",
+        help="freeze weights of bert model during fine tuning",
+    )
+    parser.add_argument(
+        "--resume", default=False, action="store_true", help="Resume from a saved model"
+    )
+    parser.add_argument(
+        "--rotate",
+        default=False,
+        action="store_true",
+        help="use rotational relative embedding",
+    )
+    parser.add_argument(
+        "--model_load", type=str, required=False, help="Where to load the model"
+    )
+    parser.add_argument(
+        "--root_dir", type=str, required=False, default=".", help="location of root dir"
+    )
+    parser.add_argument(
+        "--config_load", type=str, required=False, help="Where to load the config"
+    )
+    parser.add_argument(
+        "--gpus", type=int, required=False, default=1, help="number of gpus to use"
+    )
+    # parser.add_argument('--start_epoch',
+    #                        type=int, required=False, default=0,
+    #                        help='Where to load the config')
+
+    parser.add_argument(
+        "--model_arch",
+        type=str,
+        required=False,
+        help="used to teack model arch in params",
+    )
+    parser.add_argument(
+        "--eval_every",
+        type=int,
+        default=50000,
+        help="run evaluation every x iterations",
+    )
+    parser.add_argument(
+        "--num_feats",
+        type=int,
+        required=False,
+        default=32,
+        help="number of random reatures for FAVOR+",
+    )
+    parser.add_argument(
+        "--max_epochs", type=int, required=False, default=1, help="max number of epochs"
+    )
+
+    # debug() FINE TUNEING
+    # parser.add_argument('--save_dir', type=str, required=True)
+    parser.add_argument(
+        "--mode", type=str, default="cls", help="type of pooling to use"
+    )
+    parser.add_argument("--dataset_length", type=int, default=None, required=False)
+    parser.add_argument("--num_workers", type=int, default=0, required=False)
+    parser.add_argument("--dropout", type=float, default=0.1, required=False)
+    # parser.add_argument("--dims", type=int, nargs="*", default="", required=False)
+    parser.add_argument(
+        "--smiles_embedding",
+        type=str,
+        default="/dccstor/medscan7/smallmolecule/runs/ba-predictor/small-data/embeddings/protein/ba_embeddings_tanh_512_2986138_2.pt",
+    )
+    # parser.add_argument("--train_pct", type=str, required=False, default="95")
+    # parser.add_argument("--aug", type=int, required=True)
+    parser.add_argument("--dataset_name", type=str, required=False, default="sol")
+    parser.add_argument("--measure_name", type=str, required=False, default="measure")
+    # parser.add_argument("--emb_type", type=str, required=True)
+    parser.add_argument("--checkpoints_folder", type=str, required=True)
+    # parser.add_argument("--results_dir", type=str, required=True)
+    # parser.add_argument("--patience_epochs", type=int, required=True)
+    parser.add_argument("--model_path", type=str, default="./smi_ted/")
+    parser.add_argument("--ckpt_filename", type=str, default="smi_ted_Light_40.pt")
+    parser.add_argument("--restart_filename", type=str, default="")
+    # parser.add_argument('--n_output', type=int, default=1)
+    parser.add_argument("--save_every_epoch", type=int, default=0)
+    parser.add_argument("--save_ckpt", type=int, default=1)
+    parser.add_argument("--start_seed", type=int, default=0)
+    parser.add_argument("--smi_ted_version", type=str, default="v1")
+    parser.add_argument("--train_decoder", type=int, default=1)
+    parser.add_argument("--target_metric", type=str, default="rmse")
+    parser.add_argument("--loss_fn", type=str, default="mae")
+
+    parser.add_argument(
+        "--data_root",
+        type=str,
+        required=False,
+        default="/dccstor/medscan7/smallmolecule/runs/ba-predictor/small-data/affinity",
+    )
+    # parser.add_argument("--use_bn", type=int, default=0)
+    parser.add_argument("--use_linear", type=int, default=0)
+
+    parser.add_argument("--lr", type=float, default=0.001)
+    # parser.add_argument("--weight_decay", type=float, default=5e-4)
+    # parser.add_argument("--val_check_interval", type=float, default=1.0)
+    parser.add_argument("--batch_size", type=int, default=64)
+
+    return parser
+
+
+def parse_args():
+    parser = get_parser()
+    args = parser.parse_args()
+    return args

models/smi_ted/finetune/finetune_classification.py

@@ -0,0 +1,68 @@
+# Deep learning
+import torch
+import torch.nn as nn
+from torch import optim
+from trainers import TrainerClassifier
+from utils import get_optim_groups
+
+# Data
+import pandas as pd
+import numpy as np
+
+# Standard library
+import args
+import os
+
+
+def main(config):
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    # load dataset
+    df_train = pd.read_csv(f"{config.data_root}/train.csv")
+    df_valid = pd.read_csv(f"{config.data_root}/valid.csv")
+    df_test  = pd.read_csv(f"{config.data_root}/test.csv")
+
+    # load model
+    if config.smi_ted_version == 'v1':
+        from smi_ted_light.load import load_smi_ted
+    elif config.smi_ted_version == 'v2':
+        from smi_ted_large.load import load_smi_ted
+
+    model = load_smi_ted(folder=config.model_path, ckpt_filename=config.ckpt_filename, n_output=config.n_output, eval=False)
+    model.net.apply(model._init_weights)
+    print(model.net)
+
+    lr = config.lr_start*config.lr_multiplier
+    optim_groups = get_optim_groups(model, keep_decoder=bool(config.train_decoder))
+    if config.loss_fn == 'crossentropy':
+        loss_function = nn.CrossEntropyLoss()
+
+    # init trainer
+    trainer = TrainerClassifier(
+        raw_data=(df_train, df_valid, df_test),
+        dataset_name=config.dataset_name,
+        target=config.measure_name,
+        batch_size=config.n_batch,
+        hparams=config,
+        target_metric=config.target_metric,
+        seed=config.start_seed,
+        smi_ted_version=config.smi_ted_version,
+        checkpoints_folder=config.checkpoints_folder,
+        restart_filename=config.restart_filename,
+        device=device,
+        save_every_epoch=bool(config.save_every_epoch),
+        save_ckpt=bool(config.save_ckpt)
+    )
+    trainer.compile(
+        model=model,
+        optimizer=optim.AdamW(optim_groups, lr=lr, betas=(0.9, 0.99)),
+        loss_fn=loss_function
+    )
+    trainer.fit(max_epochs=config.max_epochs)
+    trainer.evaluate()
+
+
+if __name__ == '__main__':
+    parser = args.get_parser()
+    config = parser.parse_args()
+    main(config)

models/smi_ted/finetune/finetune_classification_multitask.py

@@ -0,0 +1,101 @@
+# Deep learning
+import torch
+import torch.nn as nn
+from torch import optim
+from trainers import TrainerClassifierMultitask
+from utils import get_optim_groups
+
+# Data
+import pandas as pd
+import numpy as np
+
+# Standard library
+import args
+import os
+
+
+def main(config):
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    # Define Target and Causal Features
+    if config.dataset_name == 'tox21':
+        targets = ['NR-AR', 'NR-AR-LBD', 'NR-AhR', 'NR-Aromatase', 'NR-ER', 'NR-ER-LBD',
+                  'NR-PPAR-gamma', 'SR-ARE', 'SR-ATAD5', 'SR-HSE', 'SR-MMP', 'SR-p53']
+    elif config.dataset_name == 'clintox':
+        targets = ['FDA_APPROVED', 'CT_TOX']
+    elif config.dataset_name == 'sider':
+        targets = [
+            'Hepatobiliary disorders', 'Metabolism and nutrition disorders',
+            'Product issues', 'Eye disorders', 'Investigations',
+            'Musculoskeletal and connective tissue disorders',
+            'Gastrointestinal disorders', 'Social circumstances',
+            'Immune system disorders', 'Reproductive system and breast disorders',
+            'Neoplasms benign, malignant and unspecified (incl cysts and polyps)',
+            'General disorders and administration site conditions',
+            'Endocrine disorders', 'Surgical and medical procedures',
+            'Vascular disorders', 'Blood and lymphatic system disorders',
+            'Skin and subcutaneous tissue disorders',
+            'Congenital, familial and genetic disorders', 'Infections and infestations',
+            'Respiratory, thoracic and mediastinal disorders', 'Psychiatric disorders',
+            'Renal and urinary disorders',
+            'Pregnancy, puerperium and perinatal conditions',
+            'Ear and labyrinth disorders', 'Cardiac disorders',
+            'Nervous system disorders', 'Injury, poisoning and procedural complications'
+        ]
+    elif config.dataset_name == 'muv':
+        targets = [
+            'MUV-466', 'MUV-548', 'MUV-600', 'MUV-644', 'MUV-652', 'MUV-689',
+            'MUV-692', 'MUV-712', 'MUV-713', 'MUV-733', 'MUV-737', 'MUV-810',
+            'MUV-832', 'MUV-846', 'MUV-852', 'MUV-858', 'MUV-859'
+        ]
+    config.n_output = len(targets)
+
+    # load dataset
+    df_train = pd.read_csv(f"{config.data_root}/train.csv")
+    df_valid = pd.read_csv(f"{config.data_root}/valid.csv")
+    df_test  = pd.read_csv(f"{config.data_root}/test.csv")
+
+    # load model
+    if config.smi_ted_version == 'v1':
+        from smi_ted_light.load import load_smi_ted
+    elif config.smi_ted_version == 'v2':
+        from smi_ted_large.load import load_smi_ted
+
+    model = load_smi_ted(folder=config.model_path, ckpt_filename=config.ckpt_filename, n_output=len(targets), eval=False)
+    model.net.apply(model._init_weights)
+    print(model.net)
+
+    lr = config.lr_start*config.lr_multiplier
+    optim_groups = get_optim_groups(model, keep_decoder=bool(config.train_decoder))
+    if config.loss_fn == 'bceloss':
+        loss_function = nn.BCELoss()
+
+    # init trainer
+    trainer = TrainerClassifierMultitask(
+        raw_data=(df_train, df_valid, df_test),
+        dataset_name=config.dataset_name,
+        target=targets,
+        batch_size=config.n_batch,
+        hparams=config,
+        target_metric=config.target_metric,
+        seed=config.start_seed,
+        smi_ted_version=config.smi_ted_version,
+        checkpoints_folder=config.checkpoints_folder,
+        restart_filename=config.restart_filename,
+        device=device,
+        save_every_epoch=bool(config.save_every_epoch),
+        save_ckpt=bool(config.save_ckpt)
+    )
+    trainer.compile(
+        model=model,
+        optimizer=optim.AdamW(optim_groups, lr=lr, betas=(0.9, 0.99)),
+        loss_fn=loss_function
+    )
+    trainer.fit(max_epochs=config.max_epochs)
+    trainer.evaluate()
+
+
+if __name__ == '__main__':
+    parser = args.get_parser()
+    config = parser.parse_args()
+    main(config)

models/smi_ted/finetune/finetune_regression.py

@@ -0,0 +1,70 @@
+# Deep learning
+import torch
+import torch.nn as nn
+from torch import optim
+from trainers import TrainerRegressor
+from utils import RMSELoss, get_optim_groups
+
+# Data
+import pandas as pd
+import numpy as np
+
+# Standard library
+import args
+import os
+
+
+def main(config):
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    # load dataset
+    df_train = pd.read_csv(f"{config.data_root}/train.csv")
+    df_valid = pd.read_csv(f"{config.data_root}/valid.csv")
+    df_test  = pd.read_csv(f"{config.data_root}/test.csv")
+
+    # load model
+    if config.smi_ted_version == 'v1':
+        from smi_ted_light.load import load_smi_ted
+    elif config.smi_ted_version == 'v2':
+        from smi_ted_large.load import load_smi_ted
+
+    model = load_smi_ted(folder=config.model_path, ckpt_filename=config.ckpt_filename, n_output=config.n_output, eval=False)
+    model.net.apply(model._init_weights)
+    print(model.net)
+
+    lr = config.lr_start*config.lr_multiplier
+    optim_groups = get_optim_groups(model, keep_decoder=bool(config.train_decoder))
+    if config.loss_fn == 'rmse':
+        loss_function = RMSELoss()
+    elif config.loss_fn == 'mae':
+        loss_function = nn.L1Loss()
+
+    # init trainer
+    trainer = TrainerRegressor(
+        raw_data=(df_train, df_valid, df_test),
+        dataset_name=config.dataset_name,
+        target=config.measure_name,
+        batch_size=config.n_batch,
+        hparams=config,
+        target_metric=config.target_metric,
+        seed=config.start_seed,
+        smi_ted_version=config.smi_ted_version,
+        checkpoints_folder=config.checkpoints_folder,
+        restart_filename=config.restart_filename,
+        device=device,
+        save_every_epoch=bool(config.save_every_epoch),
+        save_ckpt=bool(config.save_ckpt)
+    )
+    trainer.compile(
+        model=model,
+        optimizer=optim.AdamW(optim_groups, lr=lr, betas=(0.9, 0.99)),
+        loss_fn=loss_function
+    )
+    trainer.fit(max_epochs=config.max_epochs)
+    trainer.evaluate()
+
+
+if __name__ == '__main__':
+    parser = args.get_parser()
+    config = parser.parse_args()
+    main(config)

models/smi_ted/finetune/moleculenet/bace/test.csv

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

models/smi_ted/finetune/moleculenet/bace/train.csv

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

models/smi_ted/finetune/moleculenet/bace/valid.csv

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

models/smi_ted/finetune/moleculenet/bbbp/test.csv

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

models/smi_ted/finetune/moleculenet/bbbp/train.csv

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

models/smi_ted/finetune/moleculenet/bbbp/valid.csv

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

models/smi_ted/finetune/moleculenet/biodegradability/biodeg_example.csv

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

models/smi_ted/finetune/moleculenet/biodegradability/biodegradability.csv

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

models/smi_ted/finetune/moleculenet/biodegradability/test.csv

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

models/smi_ted/finetune/moleculenet/biodegradability/train.csv

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

models/smi_ted/finetune/moleculenet/biodegradability/valid.csv

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

models/smi_ted/finetune/moleculenet/clintox/test.csv

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

models/smi_ted/finetune/moleculenet/clintox/train.csv

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

models/smi_ted/finetune/moleculenet/clintox/valid.csv

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

models/smi_ted/finetune/moleculenet/esol/test.csv

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

models/smi_ted/finetune/moleculenet/esol/train.csv

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

models/smi_ted/finetune/moleculenet/esol/valid.csv

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

models/smi_ted/finetune/moleculenet/freesolv/test.csv

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

models/smi_ted/finetune/moleculenet/freesolv/train.csv

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

models/smi_ted/finetune/moleculenet/freesolv/valid.csv

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