Upload folder using huggingface_hub

.gitattributes

@@ -104,3 +104,79 @@ wandb/run-20250720_171431-y7ebdfsw/run-y7ebdfsw.wandb filter=lfs diff=lfs merge=
 wandb/run-20250720_203832-beztzgvz/run-beztzgvz.wandb filter=lfs diff=lfs merge=lfs -text
 wandb/run-20250720_210448-dhzemttz/run-dhzemttz.wandb filter=lfs diff=lfs merge=lfs -text
 wandb/run-20250721_155939-ib4az6kg/run-ib4az6kg.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/data/pubchem_2_epoch_50M filter=lfs diff=lfs merge=lfs -text
+simson_modeling/regression/PI_Tg_P308K_synth_db_chem.csv filter=lfs diff=lfs merge=lfs -text
+simson_modeling/regression/polyGNN_combined_mols_.csv filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/offline-run-20250722_135829-kk172e65/run-kk172e65.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/offline-run-20250723_215057-mgnloe91/run-mgnloe91.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/offline-run-20250723_220103-olccslmp/run-olccslmp.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/offline-run-20250723_221245-dtzrj4ds/run-dtzrj4ds.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/offline-run-20250723_222918-2pja97j3/.ipynb_checkpoints/run-2pja97j3-checkpoint.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/offline-run-20250723_222918-2pja97j3/run-2pja97j3.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/offline-run-20250807_164332-cd5u0onl/run-cd5u0onl.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/offline-run-20250807_165940-vwaul17m/run-vwaul17m.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250717_233437-v8x24r2k/run-v8x24r2k.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250717_235006-x4au33ay/run-x4au33ay.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250717_235346-1bpueejc/run-1bpueejc.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_000137-paiph8s9/run-paiph8s9.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_000333-i8pujeh7/run-i8pujeh7.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_001003-mng2732j/run-mng2732j.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_001219-y8uqpgnp/run-y8uqpgnp.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_001953-ewfpx2ex/run-ewfpx2ex.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_005226-taow6dte/run-taow6dte.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_005742-vqbu5dpw/run-vqbu5dpw.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_010148-xoj8gemp/run-xoj8gemp.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_010520-r0bl1m8z/run-r0bl1m8z.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_010659-paetqmbl/run-paetqmbl.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_010918-245xlfgs/run-245xlfgs.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_011120-bbibop4i/run-bbibop4i.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_011447-dpcb0hru/run-dpcb0hru.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_012254-nm4a474i/run-nm4a474i.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_012858-z6yfzboi/run-z6yfzboi.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_013314-g5gjoskc/run-g5gjoskc.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_013859-x86s4jyn/run-x86s4jyn.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_015325-kvu5ufqh/run-kvu5ufqh.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_015851-qc2xd8ms/run-qc2xd8ms.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_020908-wpetqjkc/run-wpetqjkc.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_031955-y1l0kk0w/run-y1l0kk0w.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_032230-55hrsoty/run-55hrsoty.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_032523-4u6u8fp8/run-4u6u8fp8.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_033334-wu8q3oan/run-wu8q3oan.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_034824-816krhgj/run-816krhgj.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_041024-clv8syyg/run-clv8syyg.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_041516-qnappj7f/run-qnappj7f.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_041821-cgsw0t5g/run-cgsw0t5g.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_043059-am04u0y9/run-am04u0y9.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_043256-7xdyfnu4/run-7xdyfnu4.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_043758-vlc0kqs1/run-vlc0kqs1.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_044126-kmk3sbwz/run-kmk3sbwz.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_070426-51daq8vc/run-51daq8vc.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_175738-ujiejljj/run-ujiejljj.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_180457-hq6awr0t/run-hq6awr0t.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_183118-1pjl1dv9/run-1pjl1dv9.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_183521-04jk637s/run-04jk637s.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_184320-412ie9zf/run-412ie9zf.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_185342-3oree65g/run-3oree65g.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_185832-apvwgarm/run-apvwgarm.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_190229-vt2nljbo/run-vt2nljbo.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_190608-gr6g2t8w/run-gr6g2t8w.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_190920-9osopmwr/run-9osopmwr.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_191351-ratgo9nz/run-ratgo9nz.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_191845-jdddfbuz/run-jdddfbuz.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_192326-kna5ek5b/run-kna5ek5b.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_193021-f1whl1ia/run-f1whl1ia.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_193519-iabkuiuw/run-iabkuiuw.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_195706-6kh0cz53/run-6kh0cz53.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250718_200252-d4gaj5js/run-d4gaj5js.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250719_150546-agpbqxyy/run-agpbqxyy.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250719_153452-unskjdue/run-unskjdue.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250719_160238-27fpkd86/run-27fpkd86.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250719_192211-3rfzbgfw/run-3rfzbgfw.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250719_193400-bhymonq7/run-bhymonq7.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250719_195543-l3p5eitx/run-l3p5eitx.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250719_200341-hnsgsmyc/run-hnsgsmyc.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250720_160322-rfm1amqg/run-rfm1amqg.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250720_171431-y7ebdfsw/run-y7ebdfsw.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250720_203832-beztzgvz/run-beztzgvz.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250720_210448-dhzemttz/run-dhzemttz.wandb filter=lfs diff=lfs merge=lfs -text
+simson_modeling/wandb/run-20250721_155939-ib4az6kg/run-ib4az6kg.wandb filter=lfs diff=lfs merge=lfs -text

simson_modeling/.ipynb_checkpoints/create_augmented_dataset-checkpoint.py

@@ -0,0 +1,83 @@
+import pandas as pd
+from tqdm import tqdm
+from rdkit import Chem, RDLogger
+from datasets import load_dataset
+from multiprocessing import Pool, cpu_count
+import os
+
+# Suppress RDKit console output for cleaner logs
+RDLogger.DisableLog('rdApp.*')
+
+class SmilesEnumerator:
+    """
+    A simple class to encapsulate the SMILES randomization logic.
+    Needed for multiprocessing to work correctly with instance methods.
+    """
+    def randomize_smiles(self, smiles):
+        """Generates a randomized SMILES string."""
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            # Return a randomized, non-canonical SMILES string
+            return Chem.MolToSmiles(mol, doRandom=True, canonical=False) if mol else smiles
+        except:
+            # If RDKit fails, return the original smiles string
+            return smiles
+
+def create_augmented_pair(smiles_string):
+    """
+    Worker function: takes one SMILES string and returns a tuple
+    containing two different randomized versions of it.
+    """
+    enumerator = SmilesEnumerator()
+    smiles_1 = enumerator.randomize_smiles(smiles_string)
+    smiles_2 = enumerator.randomize_smiles(smiles_string)
+    return smiles_1, smiles_2
+
+def main():
+    """
+    Main function to run the parallel data preprocessing.
+    """
+    # --- Configuration ---
+    # Load your desired dataset from Hugging Face
+    dataset_name = 'jablonkagroup/pubchem-smiles-molecular-formula'
+    # Specify the column containing the SMILES strings
+    smiles_column_name = 'smiles'
+    # Set the output file path
+    output_path = 'data/pubchem_2_epoch'
+
+    # --- Data Loading ---
+    print(f"Loading dataset '{dataset_name}'...")
+    # Use streaming to avoid downloading the whole dataset if you only need a subset
+    #dataset = pd.read_csv('/home/jovyan/simson_training_bolgov/data/PI1M_v2.csv')
+    dataset = load_dataset(dataset_name)['train']
+    # Take the desired number of samples
+    smiles_list = dataset[smiles_column_name].to_list()
+    print(f"Successfully fetched {len(smiles_list)} SMILES strings.")
+
+    # --- Parallel Processing ---
+    # Use all available CPU cores for maximum speed
+    num_workers = cpu_count()
+    print(f"Starting SMILES augmentation with {num_workers} worker processes...")
+
+    # A Pool of processes will run the `create_augmented_pair` function in parallel
+    with Pool(num_workers) as p:
+        # Use tqdm to create a progress bar for the mapping operation
+        results = list(tqdm(p.imap(create_augmented_pair, smiles_list), total=len(smiles_list), desc="Augmenting Pairs"))
+
+    # --- Saving Data ---
+    print("Processing complete. Converting to DataFrame...")
+    # Convert the list of tuples into a pandas DataFrame
+    df = pd.DataFrame(results, columns=['smiles_1', 'smiles_2'])
+
+    # Ensure the output directory exists
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+    print(f"Saving augmented pairs to '{output_path}'...")
+    # Save the DataFrame to a Parquet file for efficient storage and loading
+    df.to_parquet(output_path)
+    
+    print("All done. Your pre-computed dataset is ready!")
+
+if __name__ == '__main__':
+    main()
+

simson_modeling/.ipynb_checkpoints/create_augmented_dataset.py-checkpoint.save

@@ -0,0 +1,83 @@
+import pandas as pd
+from tqdm import tqdm
+from rdkit import Chem, RDLogger
+from datasets import load_dataset
+from multiprocessing import Pool, cpu_count
+import os
+
+# Suppress RDKit console output for cleaner logs
+RDLogger.DisableLog('rdApp.*')
+
+class SmilesEnumerator:
+    """
+    A simple class to encapsulate the SMILES randomization logic.
+    Needed for multiprocessing to work correctly with instance methods.
+    """
+    def randomize_smiles(self, smiles):
+        """Generates a randomized SMILES string."""
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            # Return a randomized, non-canonical SMILES string
+            return Chem.MolToSmiles(mol, doRandom=True, canonical=False) if mol else smiles
+        except:
+            # If RDKit fails, return the original smiles string
+            return smiles
+
+def create_augmented_pair(smiles_string):
+    """
+    Worker function: takes one SMILES string and returns a tuple
+    containing two different randomized versions of it.
+    """
+    enumerator = SmilesEnumerator()
+    smiles_1 = enumerator.randomize_smiles(smiles_string)
+    smiles_2 = enumerator.randomize_smiles(smiles_string)
+    return smiles_1, smiles_2
+
+def main():
+    """
+    Main function to run the parallel data preprocessing.
+    """
+    # --- Configuration ---
+    # Load your desired dataset from Hugging Face
+    dataset_name = 'jablonkagroup/pubchem-smiles-molecular-formula'
+    # Specify the column containing the SMILES strings
+    smiles_column_name = 'smiles'
+    # Set the output file path
+    output_path = 'data/pubchem_computed_110_end_M.parquet'
+
+    # --- Data Loading ---
+    print(f"Loading dataset '{dataset_name}'...")
+    # Use streaming to avoid downloading the whole dataset if you only need a subset
+    dataset = load_dataset(dataset_name, split='train').select(range(110_000_000, ))
+    
+    # Take the desired number of samples
+    smiles_list = dataset[smiles_column_name]
+    print(f"Successfully fetched {len(smiles_list)} SMILES strings.")
+
+    # --- Parallel Processing ---
+    # Use all available CPU cores for maximum speed
+    num_workers = cpu_count()
+    print(f"Starting SMILES augmentation with {num_workers} worker processes...")
+
+    # A Pool of processes will run the `create_augmented_pair` function in parallel
+    with Pool(num_workers) as p:
+        # Use tqdm to create a progress bar for the mapping operation
+        results = list(tqdm(p.imap(create_augmented_pair, smiles_list), total=len(smiles_list), desc="Augmenting Pairs"))
+
+    # --- Saving Data ---
+    print("Processing complete. Converting to DataFrame...")
+    # Convert the list of tuples into a pandas DataFrame
+    df = pd.DataFrame(results, columns=['smiles_1', 'smiles_2'])
+
+    # Ensure the output directory exists
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+    print(f"Saving augmented pairs to '{output_path}'...")
+    # Save the DataFrame to a Parquet file for efficient storage and loading
+    df.to_parquet(output_path)
+    
+    print("All done. Your pre-computed dataset is ready!")
+
+if __name__ == '__main__':
+    main()
+

simson_modeling/.ipynb_checkpoints/create_splits-checkpoint.py

@@ -0,0 +1,200 @@
+import os
+import pandas as pd
+from pathlib import Path
+import numpy as np
+from sklearn.model_selection import train_test_split
+
+def concatenate_and_split_parquet(
+    input_dir: str, 
+    output_dir: str, 
+    val_size: int = 10000, 
+    test_size: int = 5000,
+    random_state: int = 42
+):
+    """
+    Concatenate all parquet files in a directory and split into train/val/test sets.
+    
+    Args:
+        input_dir: Path to directory containing parquet files
+        output_dir: Path to directory where split files will be saved
+        val_size: Number of samples for validation set (default: 10000)
+        test_size: Number of samples for test set (default: 5000)
+        random_state: Random seed for reproducibility
+    """
+    
+    # Create output directory if it doesn't exist
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    
+    # Find all parquet files in the input directory
+    input_path = Path(input_dir)
+    parquet_files = list(input_path.glob("*.parquet"))
+    
+    if not parquet_files:
+        raise ValueError(f"No parquet files found in {input_dir}")
+    
+    print(f"Found {len(parquet_files)} parquet files")
+    
+    # Read and concatenate all parquet files
+    print("Reading and concatenating parquet files...")
+    dataframes = []
+    
+    for file_path in parquet_files:
+        print(f"Reading {file_path.name}...")
+        df = pd.read_parquet(file_path)
+        dataframes.append(df)
+    
+    # Concatenate all dataframes
+    combined_df = pd.concat(dataframes, ignore_index=True)
+    print(f"Combined dataset shape: {combined_df.shape}")
+    
+    # Check if we have enough samples
+    total_samples = len(combined_df)
+    required_samples = val_size + test_size
+    
+    if total_samples < required_samples:
+        raise ValueError(
+            f"Not enough samples. Required: {required_samples}, Available: {total_samples}"
+        )
+    
+    # Shuffle the data
+    combined_df = combined_df.sample(frac=1, random_state=random_state).reset_index(drop=True)
+    
+    # Split the data
+    print("Splitting data...")
+    
+    # First split: separate test set
+    temp_df, test_df = train_test_split(
+        combined_df, 
+        test_size=test_size, 
+        random_state=random_state
+    )
+    
+    # Second split: separate validation from remaining data
+    train_df, val_df = train_test_split(
+        temp_df, 
+        test_size=val_size, 
+        random_state=random_state
+    )
+    
+    print(f"Training set shape: {train_df.shape}")
+    print(f"Validation set shape: {val_df.shape}")
+    print(f"Test set shape: {test_df.shape}")
+    
+    # Save the splits as parquet files
+    output_path = Path(output_dir)
+    
+    train_path = output_path / "train.parquet"
+    val_path = output_path / "validation.parquet"
+    test_path = output_path / "test.parquet"
+    
+    print("Saving split datasets...")
+    train_df.to_parquet(train_path, index=False)
+    val_df.to_parquet(val_path, index=False)
+    test_df.to_parquet(test_path, index=False)
+    
+    print(f"Files saved to:")
+    print(f"  Training: {train_path}")
+    print(f"  Validation: {val_path}")
+    print(f"  Test: {test_path}")
+    
+    return train_df, val_df, test_df
+
+# Alternative version using PyArrow for better performance with large files
+def concatenate_and_split_parquet_arrow(
+    input_dir: str, 
+    output_dir: str, 
+    val_size: int = 10000, 
+    test_size: int = 5000,
+    random_state: int = 42
+):
+    """
+    Same functionality as above but using PyArrow for better performance.
+    """
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    
+    # Create output directory if it doesn't exist
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    
+    # Find all parquet files
+    input_path = Path(input_dir)
+    parquet_files = list(input_path.glob("*.parquet"))
+    
+    if not parquet_files:
+        raise ValueError(f"No parquet files found in {input_dir}")
+    
+    print(f"Found {len(parquet_files)} parquet files")
+    
+    # Read and concatenate using PyArrow
+    print("Reading and concatenating parquet files...")
+    tables = []
+    
+    for file_path in parquet_files:
+        print(f"Reading {file_path.name}...")
+        table = pq.read_table(file_path)
+        tables.append(table)
+    
+    # Concatenate tables
+    combined_table = pa.concat_tables(tables)
+    combined_df = combined_table.to_pandas()
+    
+    print(f"Combined dataset shape: {combined_df.shape}")
+    
+    # Rest of the function is the same as above
+    total_samples = len(combined_df)
+    required_samples = val_size + test_size
+    
+    if total_samples < required_samples:
+        raise ValueError(
+            f"Not enough samples. Required: {required_samples}, Available: {total_samples}"
+        )
+    
+    # Shuffle and split
+    combined_df = combined_df.sample(frac=1, random_state=random_state).reset_index(drop=True)
+    
+    temp_df, test_df = train_test_split(
+        combined_df, test_size=test_size, random_state=random_state
+    )
+    
+    train_df, val_df = train_test_split(
+        temp_df, test_size=val_size, random_state=random_state
+    )
+    
+    print(f"Training set shape: {train_df.shape}")
+    print(f"Validation set shape: {val_df.shape}")
+    print(f"Test set shape: {test_df.shape}")
+    
+    # Save using PyArrow
+    output_path = Path(output_dir)
+    
+    pq.write_table(pa.Table.from_pandas(train_df), output_path / "train.parquet")
+    pq.write_table(pa.Table.from_pandas(val_df), output_path / "validation.parquet")
+    pq.write_table(pa.Table.from_pandas(test_df), output_path / "test.parquet")
+    
+    print(f"Files saved to {output_dir}")
+    
+    return train_df, val_df, test_df
+
+# Example usage
+if __name__ == "__main__":
+    # Example usage
+    input_directory = "data"
+    output_directory = "data/polymer_splits"
+    
+    # Using pandas version
+    train_df, val_df, test_df = concatenate_and_split_parquet(
+        input_dir=input_directory,
+        output_dir=output_directory,
+        val_size=10000,
+        test_size=5000,
+        random_state=42
+    )
+    
+    # Or using PyArrow version for better performance
+    # train_df, val_df, test_df = concatenate_and_split_parquet_arrow(
+    #     input_dir=input_directory,
+    #     output_dir=output_directory,
+    #     val_size=10000,
+    #     test_size=5000,
+    #     random_state=42
+    # )

simson_modeling/.ipynb_checkpoints/fingerprint_training-checkpoint.ipynb

@@ -0,0 +1,1550 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3d5d52d1-4874-44b5-b532-ef03da47644a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from rdkit import Chem\n",
+    "from rdkit.Chem import Descriptors, rdMolDescriptors, Crippen, Lipinski\n",
+    "from tqdm import tqdm\n",
+    "import warnings\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import random\n",
+    "from concurrent.futures import ProcessPoolExecutor\n",
+    "import multiprocessing\n",
+    "\n",
+    "def analyze_polymer_features_rdkit(smiles):\n",
+    "    mol = Chem.MolFromSmiles(smiles)\n",
+    "    if mol is None:\n",
+    "        return None\n",
+    "    \n",
+    "    features = {}\n",
+    "    \n",
+    "    # Basic molecular properties\n",
+    "    features['mol_weight'] = Descriptors.MolWt(mol)\n",
+    "    features['exact_mol_weight'] = Descriptors.ExactMolWt(mol)\n",
+    "    features['num_heavy_atoms'] = mol.GetNumHeavyAtoms()\n",
+    "    features['num_atoms'] = mol.GetNumAtoms()\n",
+    "    features['num_bonds'] = mol.GetNumBonds()\n",
+    "    \n",
+    "    # Hydrogen bonding features\n",
+    "    features['num_hbond_donors'] = Descriptors.NumHDonors(mol)\n",
+    "    features['num_hbond_acceptors'] = Descriptors.NumHAcceptors(mol)\n",
+    "    features['num_heteroatoms'] = Descriptors.NumHeteroatoms(mol)\n",
+    "    \n",
+    "    # Structural complexity\n",
+    "    features['num_rotatable_bonds'] = Descriptors.NumRotatableBonds(mol)\n",
+    "    features['num_saturated_rings'] = Descriptors.NumSaturatedRings(mol)\n",
+    "    features['num_aromatic_rings'] = Descriptors.NumAromaticRings(mol)\n",
+    "    features['num_aliphatic_rings'] = Descriptors.NumAliphaticRings(mol)\n",
+    "    features['ring_count'] = Descriptors.RingCount(mol)\n",
+    "    features['fraction_csp3'] = Descriptors.FractionCSP3(mol)\n",
+    "    \n",
+    "    # Surface area and polarity\n",
+    "    features['tpsa'] = Descriptors.TPSA(mol)\n",
+    "    features['polar_surface_area'] = rdMolDescriptors.CalcTPSA(mol)\n",
+    "    \n",
+    "    # Lipophilicity and solubility\n",
+    "    features['logp'] = Descriptors.MolLogP(mol)\n",
+    "    features['crippen_logp'] = Crippen.MolLogP(mol)\n",
+    "    features['crippen_mr'] = Crippen.MolMR(mol)  # Molar refractivity\n",
+    "    \n",
+    "    # Flexibility and rigidity\n",
+    "    features['kappa1'] = Descriptors.Kappa1(mol)  # Molecular shape index\n",
+    "    features['kappa2'] = Descriptors.Kappa2(mol)\n",
+    "    features['kappa3'] = Descriptors.Kappa3(mol)\n",
+    "    features['chi0v'] = Descriptors.Chi0v(mol)  # Connectivity indices\n",
+    "    features['chi1v'] = Descriptors.Chi1v(mol)\n",
+    "    features['chi2v'] = Descriptors.Chi2v(mol)\n",
+    "    \n",
+    "    # Electronic properties\n",
+    "    features['balaban_j'] = Descriptors.BalabanJ(mol)\n",
+    "    features['bertz_ct'] = Descriptors.BertzCT(mol)  # Complexity index\n",
+    "    \n",
+    "    # Polymer-specific features\n",
+    "    features['num_radical_electrons'] = Descriptors.NumRadicalElectrons(mol)\n",
+    "    features['num_valence_electrons'] = Descriptors.NumValenceElectrons(mol)\n",
+    "    \n",
+    "    # Atom type counts\n",
+    "    atom_counts = {}\n",
+    "    for atom in mol.GetAtoms():\n",
+    "        symbol = atom.GetSymbol()\n",
+    "        atom_counts[symbol] = atom_counts.get(symbol, 0) + 1\n",
+    "    \n",
+    "    # Add individual atom counts as features\n",
+    "    for element in ['C', 'N', 'O', 'S', 'P', 'F', 'Cl', 'Br', 'I']:\n",
+    "        features[f'count_{element}'] = atom_counts.get(element, 0)\n",
+    "        features[f'ratio_{element}'] = atom_counts.get(element, 0) / features['num_atoms'] if features['num_atoms'] > 0 else 0\n",
+    "    \n",
+    "    # Bond type analysis\n",
+    "    bond_types = {'SINGLE': 0, 'DOUBLE': 0, 'TRIPLE': 0, 'AROMATIC': 0}\n",
+    "    for bond in mol.GetBonds():\n",
+    "        bond_type = str(bond.GetBondType())\n",
+    "        if bond_type in bond_types:\n",
+    "            bond_types[bond_type] += 1\n",
+    "    \n",
+    "    for bond_type, count in bond_types.items():\n",
+    "        features[f'num_{bond_type.lower()}_bonds'] = count\n",
+    "        features[f'ratio_{bond_type.lower()}_bonds'] = count / features['num_bonds'] if features['num_bonds'] > 0 else 0\n",
+    "    \n",
+    "    # Hybridization analysis\n",
+    "    hybridization_counts = {'SP': 0, 'SP2': 0, 'SP3': 0, 'SP3D': 0, 'SP3D2': 0}\n",
+    "    for atom in mol.GetAtoms():\n",
+    "        hyb = str(atom.GetHybridization())\n",
+    "        if hyb in hybridization_counts:\n",
+    "            hybridization_counts[hyb] += 1\n",
+    "    \n",
+    "    for hyb_type, count in hybridization_counts.items():\n",
+    "        features[f'num_{hyb_type.lower()}_carbons'] = count\n",
+    "        features[f'ratio_{hyb_type.lower()}_carbons'] = count / features['num_atoms'] if features['num_atoms'] > 0 else 0\n",
+    "    \n",
+    "    # Formal charge analysis\n",
+    "    formal_charges = [atom.GetFormalCharge() for atom in mol.GetAtoms()]\n",
+    "    features['total_formal_charge'] = sum(formal_charges)\n",
+    "    features['abs_total_formal_charge'] = sum(abs(charge) for charge in formal_charges)\n",
+    "    features['max_formal_charge'] = max(formal_charges) if formal_charges else 0\n",
+    "    features['min_formal_charge'] = min(formal_charges) if formal_charges else 0\n",
+    "    \n",
+    "    # Aromaticity features\n",
+    "    aromatic_atoms = sum(1 for atom in mol.GetAtoms() if atom.GetIsAromatic())\n",
+    "    features['num_aromatic_atoms'] = aromatic_atoms\n",
+    "    features['aromatic_ratio'] = aromatic_atoms / features['num_atoms'] if features['num_atoms'] > 0 else 0\n",
+    "    \n",
+    "    # Ring size analysis\n",
+    "    ring_info = mol.GetRingInfo()\n",
+    "    ring_sizes = [len(ring) for ring in ring_info.AtomRings()]\n",
+    "    if ring_sizes:\n",
+    "        features['avg_ring_size'] = sum(ring_sizes) / len(ring_sizes)\n",
+    "        features['max_ring_size'] = max(ring_sizes)\n",
+    "        features['min_ring_size'] = min(ring_sizes)\n",
+    "        features['num_3_rings'] = sum(1 for size in ring_sizes if size == 3)\n",
+    "        features['num_4_rings'] = sum(1 for size in ring_sizes if size == 4)\n",
+    "        features['num_5_rings'] = sum(1 for size in ring_sizes if size == 5)\n",
+    "        features['num_6_rings'] = sum(1 for size in ring_sizes if size == 6)\n",
+    "        features['num_7_rings'] = sum(1 for size in ring_sizes if size == 7)\n",
+    "        features['num_large_rings'] = sum(1 for size in ring_sizes if size > 7)\n",
+    "    else:\n",
+    "        features.update({\n",
+    "            'avg_ring_size': 0, 'max_ring_size': 0, 'min_ring_size': 0,\n",
+    "            'num_3_rings': 0, 'num_4_rings': 0, 'num_5_rings': 0,\n",
+    "            'num_6_rings': 0, 'num_7_rings': 0, 'num_large_rings': 0\n",
+    "        })\n",
+    "    \n",
+    "    # Polymer-specific structural features\n",
+    "    features['has_polymer_notation'] = '*' in smiles\n",
+    "    features['smiles_length'] = len(smiles)\n",
+    "    features['branch_count'] = smiles.count('(')\n",
+    "    features['branch_ratio'] = smiles.count('(') / len(smiles) if len(smiles) > 0 else 0\n",
+    "    \n",
+    "    return features\n",
+    "\n",
+    "def add_features(df, num_workers=None):\n",
+    "    \"\"\"\n",
+    "    Improved version using multiprocessing to calculate RDKit descriptors efficiently.\n",
+    "    \n",
+    "    Parameters:\n",
+    "    df: pandas DataFrame with 'Smiles' column\n",
+    "    num_workers: Number of worker processes (defaults to number of CPU cores)\n",
+    "    \"\"\"\n",
+    "    if num_workers is None:\n",
+    "        num_workers = multiprocessing.cpu_count()\n",
+    "    \n",
+    "    smiles_list = df['Smiles'].tolist()\n",
+    "    \n",
+    "    with ProcessPoolExecutor(max_workers=num_workers) as executor:\n",
+    "        # Use tqdm with executor.map for progress tracking\n",
+    "        features_list = list(tqdm(executor.map(analyze_polymer_features_rdkit, smiles_list), \n",
+    "                                total=len(smiles_list), \n",
+    "                                desc=\"Computing RDKit descriptors\"))\n",
+    "    \n",
+    "    # Convert results to DataFrame\n",
+    "    features_df = pd.DataFrame(features_list)\n",
+    "    \n",
+    "    # Concatenate with original DataFrame\n",
+    "    df_result = pd.concat([df, features_df], axis=1)\n",
+    "    \n",
+    "    return df_result\n",
+    "\n",
+    "def get_list_dif(l1, l2):\n",
+    "    return list(set(l1) - set(l2))\n",
+    "\n",
+    "# Usage example:\n",
+    "# df_with_features = add_features(df, num_workers=4)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "155598af-79f3-4933-8b5c-1fd11f64b870",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('/home/jovyan/simson_training_bolgov/regression/PI_Tg_P308K_synth_db_chem.csv').drop(columns=['Unnamed: 0'], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c69cc497-9fb6-4f74-96eb-257d7aa4a91a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('/home/jovyan/simson_training_bolgov/kaggle_comp/train.csv')\n",
+    "df['Smiles'] = df['SMILES']\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b076c55-d6ef-4780-af97-5fccd5062661",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sample_df = df.iloc[:10_000]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "96313883-c2ca-4eb8-9ec7-9aaca8dba077",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "features_df = add_features(sample_df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "41c7f85a-ea65-42e5-b315-ef304ba311c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "selected_features = ['mol_weight', 'exact_mol_weight', 'num_heavy_atoms', 'num_atoms',\n",
+    "       'num_bonds', 'num_hbond_donors', 'num_hbond_acceptors',\n",
+    "       'num_heteroatoms', 'num_rotatable_bonds', 'num_saturated_rings',\n",
+    "       'num_aromatic_rings', 'num_aliphatic_rings', 'ring_count',\n",
+    "       'fraction_csp3', 'tpsa', 'polar_surface_area', 'logp', 'crippen_logp',\n",
+    "       'crippen_mr', 'kappa1', 'kappa2', 'kappa3', 'chi0v', 'chi1v', 'chi2v',\n",
+    "       'balaban_j', 'bertz_ct', 'num_radical_electrons',\n",
+    "       'num_valence_electrons',\n",
+    "       'count_O', 'ratio_O', 'count_S', 'ratio_S', 'count_P', 'ratio_P',\n",
+    "       'count_F', 'ratio_F', 'count_Cl', 'ratio_Cl', 'count_Br', 'ratio_Br',\n",
+    "       'count_I', 'ratio_I', 'num_single_bonds', 'ratio_single_bonds',\n",
+    "       'num_double_bonds', 'ratio_double_bonds', 'num_triple_bonds',\n",
+    "       'ratio_triple_bonds', 'num_aromatic_bonds', 'ratio_aromatic_bonds',\n",
+    "       'num_sp_carbons', 'ratio_sp_carbons', 'num_sp2_carbons',\n",
+    "       'ratio_sp2_carbons', 'num_sp3_carbons', 'ratio_sp3_carbons',\n",
+    "       'num_sp3d_carbons', 'ratio_sp3d_carbons', 'num_sp3d2_carbons',\n",
+    "       'ratio_sp3d2_carbons', 'total_formal_charge', 'abs_total_formal_charge',\n",
+    "       'max_formal_charge', 'min_formal_charge', 'num_aromatic_atoms',\n",
+    "       'aromatic_ratio', 'avg_ring_size', 'max_ring_size', 'min_ring_size',\n",
+    "       'num_3_rings', 'num_4_rings', 'num_5_rings', 'num_6_rings',\n",
+    "       'num_7_rings', 'num_large_rings', 'has_polymer_notation',\n",
+    "       'branch_count', 'branch_ratio']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc31605d-cc21-4533-b04e-f8acdaef1a65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scalers = []\n",
+    "for col in selected_features:\n",
+    "    scaler = StandardScaler()\n",
+    "    features_df[col] = scaler.fit_transform(features_df[col].to_numpy().reshape(-1, 1)).flatten()\n",
+    "    scalers.append(scaler)\n",
+    "    \n",
+    "features_df.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f2f1a614-0ba7-4a01-9731-532afc1d14e0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['mol_weight', 'exact_mol_weight', 'fraction_csp3', 'tpsa', 'polar_surface_area', 'logp', 'crippen_logp', 'crippen_mr', 'kappa1', 'kappa2', 'kappa3', 'chi0v', 'chi1v', 'chi2v', 'balaban_j', 'bertz_ct', 'ratio_O', 'ratio_single_bonds', 'ratio_double_bonds', 'ratio_aromatic_bonds', 'ratio_sp2_carbons', 'ratio_sp3_carbons', 'aromatic_ratio', 'branch_ratio', 'Smiles']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(25, 79)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "new_features = []\n",
+    "\n",
+    "for feature in selected_features:\n",
+    "    unique_list = features_df[feature].unique()\n",
+    "    if len(unique_list) > 300:\n",
+    "        new_features.append(feature)\n",
+    "new_features.append('Smiles')\n",
+    "print(new_features)\n",
+    "len(new_features), len(selected_features)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "28cbac75-8a9f-4292-aedb-11f33f5a6056",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c065d950-7a63-4424-9923-1072d2e2268c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "features_df.to_csv('7k_w_descriptors.csv', index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "069a9021-d440-4bf1-9882-a2af25f2e801",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>id</th>\n",
+       "      <th>SMILES</th>\n",
+       "      <th>Tg</th>\n",
+       "      <th>FFV</th>\n",
+       "      <th>Tc</th>\n",
+       "      <th>Density</th>\n",
+       "      <th>Rg</th>\n",
+       "      <th>Smiles</th>\n",
+       "      <th>mol_weight</th>\n",
+       "      <th>exact_mol_weight</th>\n",
+       "      <th>...</th>\n",
+       "      <th>num_3_rings</th>\n",
+       "      <th>num_4_rings</th>\n",
+       "      <th>num_5_rings</th>\n",
+       "      <th>num_6_rings</th>\n",
+       "      <th>num_7_rings</th>\n",
+       "      <th>num_large_rings</th>\n",
+       "      <th>has_polymer_notation</th>\n",
+       "      <th>smiles_length</th>\n",
+       "      <th>branch_count</th>\n",
+       "      <th>branch_ratio</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>87817</td>\n",
+       "      <td>*CC(*)c1ccccc1C(=O)OCCCCCC</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.374645</td>\n",
+       "      <td>0.205667</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*CC(*)c1ccccc1C(=O)OCCCCCC</td>\n",
+       "      <td>-0.875755</td>\n",
+       "      <td>-0.875617</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>-0.626991</td>\n",
+       "      <td>-0.788904</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>26</td>\n",
+       "      <td>-0.985221</td>\n",
+       "      <td>-0.813832</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>106919</td>\n",
+       "      <td>*Nc1ccc([C@H](CCC)c2ccc(C3(c4ccc([C@@H](CCC)c5...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.370410</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*Nc1ccc([C@H](CCC)c2ccc(C3(c4ccc([C@@H](CCC)c5...</td>\n",
+       "      <td>0.651876</td>\n",
+       "      <td>0.651916</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>-0.626991</td>\n",
+       "      <td>0.736852</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>82</td>\n",
+       "      <td>0.336345</td>\n",
+       "      <td>-0.286141</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>388772</td>\n",
+       "      <td>*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C4(c5ccc(Oc6ccc(...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.378860</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C4(c5ccc(Oc6ccc(...</td>\n",
+       "      <td>2.336573</td>\n",
+       "      <td>2.336165</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>-0.626991</td>\n",
+       "      <td>2.644047</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>134</td>\n",
+       "      <td>1.657910</td>\n",
+       "      <td>-0.109289</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>519416</td>\n",
+       "      <td>*Nc1ccc(-c2c(-c3ccc(C)cc3)c(-c3ccc(C)cc3)c(N*)...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.387324</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*Nc1ccc(-c2c(-c3ccc(C)cc3)c(-c3ccc(C)cc3)c(N*)...</td>\n",
+       "      <td>0.417716</td>\n",
+       "      <td>0.417722</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>-0.626991</td>\n",
+       "      <td>1.118291</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>79</td>\n",
+       "      <td>0.556606</td>\n",
+       "      <td>0.132247</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>539187</td>\n",
+       "      <td>*Oc1ccc(OC(=O)c2cc(OCCCCCCCCCOCC3CCCN3c3ccc([N...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.355470</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*Oc1ccc(OC(=O)c2cc(OCCCCCCCCCOCC3CCCN3c3ccc([N...</td>\n",
+       "      <td>2.178003</td>\n",
+       "      <td>2.178499</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>1.501149</td>\n",
+       "      <td>0.355413</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>118</td>\n",
+       "      <td>0.556606</td>\n",
+       "      <td>-0.830501</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7968</th>\n",
+       "      <td>2146592435</td>\n",
+       "      <td>*Oc1cc(CCCCCCCC)cc(OC(=O)c2cccc(C(*)=O)c2)c1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.367498</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*Oc1cc(CCCCCCCC)cc(OC(=O)c2cccc(C(*)=O)c2)c1</td>\n",
+       "      <td>-0.375261</td>\n",
+       "      <td>-0.375084</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>-0.626991</td>\n",
+       "      <td>-0.407465</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>44</td>\n",
+       "      <td>-0.324438</td>\n",
+       "      <td>0.124891</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7969</th>\n",
+       "      <td>2146810552</td>\n",
+       "      <td>*C(=O)OCCN(CCOC(=O)c1ccc2c(c1)C(=O)N(c1cccc(N3...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.353280</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*C(=O)OCCN(CCOC(=O)c1ccc2c(c1)C(=O)N(c1cccc(N3...</td>\n",
+       "      <td>1.284275</td>\n",
+       "      <td>1.284737</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>1.501149</td>\n",
+       "      <td>0.736852</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>110</td>\n",
+       "      <td>1.217388</td>\n",
+       "      <td>0.008668</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7970</th>\n",
+       "      <td>2147191531</td>\n",
+       "      <td>*c1cc(C(=O)NCCCCCCCC)cc(N2C(=O)c3ccc(-c4ccc5c(...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.369411</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*c1cc(C(=O)NCCCCCCCC)cc(N2C(=O)c3ccc(-c4ccc5c(...</td>\n",
+       "      <td>0.329570</td>\n",
+       "      <td>0.329823</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>1.501149</td>\n",
+       "      <td>-0.026026</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>73</td>\n",
+       "      <td>0.336345</td>\n",
+       "      <td>0.021405</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7971</th>\n",
+       "      <td>2147435020</td>\n",
+       "      <td>*C=C(*)c1ccccc1C</td>\n",
+       "      <td>261.662355</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*C=C(*)c1ccccc1C</td>\n",
+       "      <td>-1.359802</td>\n",
+       "      <td>-1.359728</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>-0.626991</td>\n",
+       "      <td>-0.788904</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>16</td>\n",
+       "      <td>-1.205481</td>\n",
+       "      <td>-1.182617</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7972</th>\n",
+       "      <td>2147438299</td>\n",
+       "      <td>*c1ccc(OCCCCCCCCCCCOC(=O)CCCCC(=O)OCCCCCCCCCCC...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.374049</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*c1ccc(OCCCCCCCCCCCOC(=O)CCCCC(=O)OCCCCCCCCCCC...</td>\n",
+       "      <td>1.160667</td>\n",
+       "      <td>1.160653</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.048476</td>\n",
+       "      <td>-0.069289</td>\n",
+       "      <td>0.437079</td>\n",
+       "      <td>-0.407465</td>\n",
+       "      <td>-0.051542</td>\n",
+       "      <td>-0.047917</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>72</td>\n",
+       "      <td>-0.324438</td>\n",
+       "      <td>-1.005054</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>7973 rows × 92 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              id                                             SMILES  \\\n",
+       "0          87817                         *CC(*)c1ccccc1C(=O)OCCCCCC   \n",
+       "1         106919  *Nc1ccc([C@H](CCC)c2ccc(C3(c4ccc([C@@H](CCC)c5...   \n",
+       "2         388772  *Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C4(c5ccc(Oc6ccc(...   \n",
+       "3         519416  *Nc1ccc(-c2c(-c3ccc(C)cc3)c(-c3ccc(C)cc3)c(N*)...   \n",
+       "4         539187  *Oc1ccc(OC(=O)c2cc(OCCCCCCCCCOCC3CCCN3c3ccc([N...   \n",
+       "...          ...                                                ...   \n",
+       "7968  2146592435       *Oc1cc(CCCCCCCC)cc(OC(=O)c2cccc(C(*)=O)c2)c1   \n",
+       "7969  2146810552  *C(=O)OCCN(CCOC(=O)c1ccc2c(c1)C(=O)N(c1cccc(N3...   \n",
+       "7970  2147191531  *c1cc(C(=O)NCCCCCCCC)cc(N2C(=O)c3ccc(-c4ccc5c(...   \n",
+       "7971  2147435020                                   *C=C(*)c1ccccc1C   \n",
+       "7972  2147438299  *c1ccc(OCCCCCCCCCCCOC(=O)CCCCC(=O)OCCCCCCCCCCC...   \n",
+       "\n",
+       "              Tg       FFV        Tc  Density  Rg  \\\n",
+       "0            NaN  0.374645  0.205667      NaN NaN   \n",
+       "1            NaN  0.370410       NaN      NaN NaN   \n",
+       "2            NaN  0.378860       NaN      NaN NaN   \n",
+       "3            NaN  0.387324       NaN      NaN NaN   \n",
+       "4            NaN  0.355470       NaN      NaN NaN   \n",
+       "...          ...       ...       ...      ...  ..   \n",
+       "7968         NaN  0.367498       NaN      NaN NaN   \n",
+       "7969         NaN  0.353280       NaN      NaN NaN   \n",
+       "7970         NaN  0.369411       NaN      NaN NaN   \n",
+       "7971  261.662355       NaN       NaN      NaN NaN   \n",
+       "7972         NaN  0.374049       NaN      NaN NaN   \n",
+       "\n",
+       "                                                 Smiles  mol_weight  \\\n",
+       "0                            *CC(*)c1ccccc1C(=O)OCCCCCC   -0.875755   \n",
+       "1     *Nc1ccc([C@H](CCC)c2ccc(C3(c4ccc([C@@H](CCC)c5...    0.651876   \n",
+       "2     *Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C4(c5ccc(Oc6ccc(...    2.336573   \n",
+       "3     *Nc1ccc(-c2c(-c3ccc(C)cc3)c(-c3ccc(C)cc3)c(N*)...    0.417716   \n",
+       "4     *Oc1ccc(OC(=O)c2cc(OCCCCCCCCCOCC3CCCN3c3ccc([N...    2.178003   \n",
+       "...                                                 ...         ...   \n",
+       "7968       *Oc1cc(CCCCCCCC)cc(OC(=O)c2cccc(C(*)=O)c2)c1   -0.375261   \n",
+       "7969  *C(=O)OCCN(CCOC(=O)c1ccc2c(c1)C(=O)N(c1cccc(N3...    1.284275   \n",
+       "7970  *c1cc(C(=O)NCCCCCCCC)cc(N2C(=O)c3ccc(-c4ccc5c(...    0.329570   \n",
+       "7971                                   *C=C(*)c1ccccc1C   -1.359802   \n",
+       "7972  *c1ccc(OCCCCCCCCCCCOC(=O)CCCCC(=O)OCCCCCCCCCCC...    1.160667   \n",
+       "\n",
+       "      exact_mol_weight  ...  num_3_rings  num_4_rings  num_5_rings  \\\n",
+       "0            -0.875617  ...    -0.048476    -0.069289    -0.626991   \n",
+       "1             0.651916  ...    -0.048476    -0.069289    -0.626991   \n",
+       "2             2.336165  ...    -0.048476    -0.069289    -0.626991   \n",
+       "3             0.417722  ...    -0.048476    -0.069289    -0.626991   \n",
+       "4             2.178499  ...    -0.048476    -0.069289     1.501149   \n",
+       "...                ...  ...          ...          ...          ...   \n",
+       "7968         -0.375084  ...    -0.048476    -0.069289    -0.626991   \n",
+       "7969          1.284737  ...    -0.048476    -0.069289     1.501149   \n",
+       "7970          0.329823  ...    -0.048476    -0.069289     1.501149   \n",
+       "7971         -1.359728  ...    -0.048476    -0.069289    -0.626991   \n",
+       "7972          1.160653  ...    -0.048476    -0.069289     0.437079   \n",
+       "\n",
+       "      num_6_rings  num_7_rings  num_large_rings  has_polymer_notation  \\\n",
+       "0       -0.788904    -0.051542        -0.047917                   0.0   \n",
+       "1        0.736852    -0.051542        -0.047917                   0.0   \n",
+       "2        2.644047    -0.051542        -0.047917                   0.0   \n",
+       "3        1.118291    -0.051542        -0.047917                   0.0   \n",
+       "4        0.355413    -0.051542        -0.047917                   0.0   \n",
+       "...           ...          ...              ...                   ...   \n",
+       "7968    -0.407465    -0.051542        -0.047917                   0.0   \n",
+       "7969     0.736852    -0.051542        -0.047917                   0.0   \n",
+       "7970    -0.026026    -0.051542        -0.047917                   0.0   \n",
+       "7971    -0.788904    -0.051542        -0.047917                   0.0   \n",
+       "7972    -0.407465    -0.051542        -0.047917                   0.0   \n",
+       "\n",
+       "      smiles_length  branch_count  branch_ratio  \n",
+       "0                26     -0.985221     -0.813832  \n",
+       "1                82      0.336345     -0.286141  \n",
+       "2               134      1.657910     -0.109289  \n",
+       "3                79      0.556606      0.132247  \n",
+       "4               118      0.556606     -0.830501  \n",
+       "...             ...           ...           ...  \n",
+       "7968             44     -0.324438      0.124891  \n",
+       "7969            110      1.217388      0.008668  \n",
+       "7970             73      0.336345      0.021405  \n",
+       "7971             16     -1.205481     -1.182617  \n",
+       "7972             72     -0.324438     -1.005054  \n",
+       "\n",
+       "[7973 rows x 92 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "features_df = pd.read_csv('7k_w_descriptors.csv')\n",
+    "features_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "49998b8a-3925-4383-917a-116f70187d46",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n"
+     ]
+    }
+   ],
+   "source": [
+    "old_len = len(features_df)\n",
+    "new_len = len(features_df.drop_duplicates())\n",
+    "print(new_len - old_len)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c2f08ca9-21f6-4a79-ab94-80556b8dab1d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████| 6378/6378 [00:01<00:00, 3382.49it/s]\n",
+      "100%|█████████████████████████████████████| 1595/1595 [00:00<00:00, 3554.96it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from tqdm import tqdm\n",
+    "import copy\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "def create_splits(df):\n",
+    "    train, test = train_test_split(df, test_size=0.2)\n",
+    "    return train, test\n",
+    "\n",
+    "def create_samples(df, features):\n",
+    "    samples = []\n",
+    "    features_without_smiles = copy.deepcopy(features)\n",
+    "    features_without_smiles.remove('Smiles')\n",
+    "    for i, row in tqdm(df.iterrows(), total=len(df)):\n",
+    "        properties = torch.Tensor(row[features_without_smiles].to_list())\n",
+    "        sample = {'Smiles': row['Smiles'], 'property_tensor': properties}\n",
+    "        samples.append(sample)\n",
+    "    return samples\n",
+    "\n",
+    "train, val = create_splits(features_df.reset_index(drop=True))\n",
+    "\n",
+    "train = train.reset_index(drop=True)\n",
+    "val = val.reset_index(drop=True)\n",
+    "\n",
+    "train_list = create_samples(train, new_features)\n",
+    "val_list = create_samples(val, new_features)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2fdb3171-deda-4c1f-ae4b-853d781ffdd5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████| 20/20 [00:00<00:00, 74764.78it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.metrics.pairwise import cosine_similarity\n",
+    "\n",
+    "prop_vectors = [el['property_tensor'] for el in train_list[:20]]\n",
+    "\n",
+    "sim_matrix = cosine_similarity(prop_vectors)\n",
+    "    \n",
+    "n = len(prop_vectors)\n",
+    "positive_pairs, negative_candidates = [], []\n",
+    "sims = []\n",
+    "\n",
+    "positive_threshold = 0.9\n",
+    "negative_threshold = 0.2\n",
+    "\n",
+    "for i in tqdm(range(n)):\n",
+    "    for j in range(i + 1, n):\n",
+    "        sim = sim_matrix[i, j]\n",
+    "\n",
+    "        if sim > positive_threshold:\n",
+    "            positive_pairs.append((i, j, sim))\n",
+    "        elif sim < negative_threshold:\n",
+    "            negative_candidates.append((i, j, sim))\n",
+    "        sims.append(float(sim))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "54f29e98-7c32-441c-bb1b-cdaf3fd1df49",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(positive_pairs), len(negative_candidates)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22e0f46e-2673-4840-95fd-f98914e57b78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "plt.plot(sims)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "79e7e873-7950-4123-ab13-299360ae19ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "from transformers import BertConfig, BertModel, AutoTokenizer\n",
+    "import pickle\n",
+    "import numpy as np\n",
+    "from sklearn.metrics.pairwise import cosine_similarity\n",
+    "\n",
+    "def global_ap(x):\n",
+    "    return torch.mean(x.view(x.size(0), x.size(1), -1), dim=1)\n",
+    "\n",
+    "class SimSonEncoder(nn.Module):\n",
+    "    def __init__(self, config: BertConfig, max_len: int, dropout: float = 0.1):\n",
+    "        super(SimSonEncoder, self).__init__()\n",
+    "        self.config = config\n",
+    "        self.max_len = max_len\n",
+    "        \n",
+    "        self.bert = BertModel(config, add_pooling_layer=False)\n",
+    "        \n",
+    "        self.linear = nn.Linear(config.hidden_size, max_len)\n",
+    "        self.dropout = nn.Dropout(dropout)\n",
+    "        \n",
+    "    def forward(self, input_ids, attention_mask=None):\n",
+    "        if attention_mask is None:\n",
+    "            attention_mask = input_ids.ne(0)\n",
+    "            \n",
+    "        outputs = self.bert(\n",
+    "            input_ids=input_ids,\n",
+    "            attention_mask=attention_mask\n",
+    "        )\n",
+    "        \n",
+    "        hidden_states = outputs.last_hidden_state\n",
+    "        \n",
+    "        hidden_states = self.dropout(hidden_states)\n",
+    "        \n",
+    "        pooled = global_ap(hidden_states)\n",
+    "        \n",
+    "        out = self.linear(pooled)\n",
+    "        \n",
+    "        return out\n",
+    "\n",
+    "def initialize_model_and_tokenizer():\n",
+    "    \"\"\"Initialize BERT model from config and ChemBERTa tokenizer\"\"\"\n",
+    "    \n",
+    "    \n",
+    "    tokenizer = AutoTokenizer.from_pretrained(\"DeepChem/ChemBERTa-77M-MTR\")\n",
+    "    config = BertConfig(\n",
+    "        vocab_size=tokenizer.vocab_size,\n",
+    "        hidden_size=768,\n",
+    "        num_hidden_layers=4,\n",
+    "        num_attention_heads=12,\n",
+    "        intermediate_size=2048,\n",
+    "        max_position_embeddings=512,\n",
+    "    )\n",
+    "    model = SimSonEncoder(config=config, max_len=512).cuda()\n",
+    "    return model, tokenizer\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8a3adaff-da65-46b4-b9ee-95851d786a67",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "\n",
+    "\n",
+    "class MolecularContrastiveDataset(Dataset):\n",
+    "    def __init__(self, data_list, tokenizer, positive_threshold=0.9, cache_path=None, split_type='train'):\n",
+    "        \"\"\"\n",
+    "        Dataset that only contains positive pairs for NT-Xent contrastive learning\n",
+    "        \"\"\"\n",
+    "        self.data_list = data_list\n",
+    "        self.tokenizer = tokenizer\n",
+    "        self.positive_threshold = positive_threshold\n",
+    "        self.cache_path = cache_path\n",
+    "        self.split_type = split_type\n",
+    "\n",
+    "        # Load or compute pairs\n",
+    "        if cache_path and os.path.exists(cache_path) and os.path.getsize(cache_path) > 0:\n",
+    "            print(f\"Loading cached pairs from {cache_path}\")\n",
+    "            self._load_pairs()\n",
+    "        else:\n",
+    "            print(\"Computing positive pairs only...\")\n",
+    "            self._compute_positive_pairs()\n",
+    "            if cache_path:\n",
+    "                self._save_pairs()\n",
+    "    \n",
+    "    def _compute_positive_pairs(self):\n",
+    "        \"\"\"\n",
+    "        Compute ONLY positive pairs based on descriptor similarity\n",
+    "        \"\"\"\n",
+    "        # --- 1. Cosine-similarity matrix ---------------------------------------\n",
+    "        prop_vectors = torch.stack(\n",
+    "            [item['property_tensor'] for item in self.data_list]\n",
+    "        ).numpy()\n",
+    "        sim_matrix = cosine_similarity(prop_vectors)\n",
+    "\n",
+    "        n = len(self.data_list)\n",
+    "        positive_pairs = []\n",
+    "        pairs_per_molecule = 1 # STRICTLY ONE FOR CREATING PROPER NEGATIVE PAIRS\n",
+    "        current_pairs_per_molecule = 0\n",
+    "        # --- 2. Collect only positive pairs ------------------------------------\n",
+    "        print(f'Collecting positive pairs with similarity threshold {self.positive_threshold}')\n",
+    "        for i in tqdm(range(n)):\n",
+    "            for j in range(i + 1, n):\n",
+    "                sim = sim_matrix[i, j]\n",
+    "                if sim > self.positive_threshold:\n",
+    "                    positive_pairs.append((i, j, sim))\n",
+    "                    current_pairs_per_molecule += 1\n",
+    "                if current_pairs_per_molecule > pairs_per_molecule:\n",
+    "                    current_pairs_per_molecule = 0\n",
+    "                    break\n",
+    "\n",
+    "        # --- 3. Store only positive pairs --------------------------------------\n",
+    "        if len(positive_pairs) == 0:\n",
+    "            raise ValueError(\"No positive pairs found – lower the positive_threshold.\")\n",
+    "\n",
+    "        # No shuffling - we want consistent positive pairs\n",
+    "        self.pairs = [(i, j) for i, j, _ in positive_pairs]\n",
+    "        self.descriptor_similarities = [sim for _, _, sim in positive_pairs]\n",
+    "\n",
+    "        print(f\"Generated {len(self.pairs)} positive pairs\")\n",
+    "\n",
+    "    def _save_pairs(self):\n",
+    "        \"\"\"Save computed pairs to cache file\"\"\"\n",
+    "        cache_data = {\n",
+    "            'pairs': self.pairs,\n",
+    "            'descriptor_similarities': self.descriptor_similarities\n",
+    "        }\n",
+    "        with open(self.cache_path, 'wb') as f:\n",
+    "            pickle.dump(cache_data, f)\n",
+    "        print(f\"Cached pairs saved to {self.cache_path}\")\n",
+    "    \n",
+    "    def _load_pairs(self):\n",
+    "        \"\"\"Load pairs from cache file\"\"\"\n",
+    "        with open(self.cache_path, 'rb') as f:\n",
+    "            cache_data = pickle.load(f)\n",
+    "        \n",
+    "        self.pairs = cache_data['pairs']\n",
+    "        self.descriptor_similarities = cache_data['descriptor_similarities']\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.pairs)\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        i, j = self.pairs[idx]\n",
+    "        desc_sim = self.descriptor_similarities[idx]\n",
+    "        \n",
+    "        # Get SMILES for both molecules\n",
+    "        smiles_i = self.data_list[i]['Smiles']\n",
+    "        smiles_j = self.data_list[j]['Smiles']\n",
+    "        if self.split_type == 'val':\n",
+    "            print(f'POSITIVE PAIR SMILES: \\n{smiles_i} \\n {smiles_j}')\n",
+    "        # Tokenize SMILES\n",
+    "        tokens_i = self.tokenizer(\n",
+    "            smiles_i, \n",
+    "            return_tensors='pt', \n",
+    "            padding='max_length', \n",
+    "            truncation=True, \n",
+    "            max_length=256\n",
+    "        )\n",
+    "        tokens_j = self.tokenizer(\n",
+    "            smiles_j, \n",
+    "            return_tensors='pt', \n",
+    "            padding='max_length', \n",
+    "            truncation=True, \n",
+    "            max_length=256\n",
+    "        )\n",
+    "        \n",
+    "        # Remove batch dimension\n",
+    "        tokens_i = {key: val.squeeze(0) for key, val in tokens_i.items()}\n",
+    "        tokens_j = {key: val.squeeze(0) for key, val in tokens_j.items()}\n",
+    "        \n",
+    "        # Get property vectors\n",
+    "        prop_vec_i = self.data_list[i]['property_tensor']\n",
+    "        prop_vec_j = self.data_list[j]['property_tensor']\n",
+    "        \n",
+    "        return {\n",
+    "            'tokens_i': tokens_i,\n",
+    "            'tokens_j': tokens_j,\n",
+    "            'descriptor_similarity': torch.tensor(desc_sim, dtype=torch.float32),\n",
+    "            'property_tensor_i': prop_vec_i,\n",
+    "            'property_tensor_j': prop_vec_j\n",
+    "        }\n",
+    "\n",
+    "\n",
+    "def contrastive_collate_fn(batch):\n",
+    "    \"\"\"\n",
+    "    Collate function that creates proper NT-Xent batches:\n",
+    "    - Element 0 and 1 are positive pairs\n",
+    "    - Element 2 and 3 are positive pairs  \n",
+    "    - etc.\n",
+    "    \"\"\"\n",
+    "    batch_size = len(batch)\n",
+    "    \n",
+    "    # Ensure even batch size for proper pairing\n",
+    "    if batch_size % 2 != 0:\n",
+    "        batch = batch[:-1]  # Drop last element if odd\n",
+    "        batch_size = len(batch)\n",
+    "    \n",
+    "    # Interleave: [sample1_i, sample1_j, sample2_i, sample2_j, ...]\n",
+    "    tokens_list = []\n",
+    "    desc_similarities = []\n",
+    "    \n",
+    "    for i in range(0, batch_size, 1):\n",
+    "        # Add first molecule of pair i\n",
+    "        tokens_list.append(batch[i]['tokens_i'])\n",
+    "        desc_similarities.append(batch[i]['descriptor_similarity'])\n",
+    "        \n",
+    "        # Add second molecule of pair i (positive pair)\n",
+    "        tokens_list.append(batch[i]['tokens_j'])\n",
+    "        desc_similarities.append(batch[i]['descriptor_similarity'])  # Same similarity for both elements in pair\n",
+    "    \n",
+    "    # Stack all tokens\n",
+    "    tokens = {}\n",
+    "    for key in tokens_list[0].keys():\n",
+    "        tokens[key] = torch.stack([item[key] for item in tokens_list])\n",
+    "    \n",
+    "    desc_similarities_tensor = torch.stack(desc_similarities)\n",
+    "    \n",
+    "    return {\n",
+    "        'tokens': tokens,\n",
+    "        'descriptor_similarities': desc_similarities_tensor,\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "def create_dataloaders(train_list, val_list, tokenizer, batch_size=32, \n",
+    "                      positive_threshold=0.85, cache_dir=\"cache\"):\n",
+    "    \"\"\"Create train and validation dataloaders for NT-Xent\"\"\"\n",
+    "    os.makedirs(cache_dir, exist_ok=True)\n",
+    "    \n",
+    "    # Ensure even batch size for proper pairing\n",
+    "    if batch_size % 2 != 0:\n",
+    "        batch_size += 1\n",
+    "        print(f\"Adjusted batch_size to {batch_size} (must be even for NT-Xent)\")\n",
+    "    \n",
+    "    train_cache = os.path.join(cache_dir, 'train_positive_pairs.pkl')\n",
+    "    val_cache = os.path.join(cache_dir, 'val_positive_pairs.pkl')\n",
+    "    \n",
+    "    train_dataset = MolecularContrastiveDataset(\n",
+    "        train_list, tokenizer, positive_threshold=positive_threshold, cache_path=train_cache\n",
+    "    )\n",
+    "    val_dataset = MolecularContrastiveDataset(\n",
+    "        val_list, tokenizer, positive_threshold=positive_threshold, cache_path=val_cache, split_type='val',\n",
+    "    )\n",
+    "    \n",
+    "    train_loader = DataLoader(\n",
+    "        train_dataset, batch_size=batch_size, shuffle=True, collate_fn=contrastive_collate_fn, drop_last=True, pin_memory=True\n",
+    "    )\n",
+    "    val_loader = DataLoader(\n",
+    "        val_dataset, batch_size=batch_size, shuffle=False, collate_fn=contrastive_collate_fn, drop_last=True, pin_memory=True\n",
+    "    )\n",
+    "    \n",
+    "    return train_loader, val_loader\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "f956a50b-85a5-49df-b7c6-6e40dce160e1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model initialized with 23,299,840 trainable parameters\n"
+     ]
+    }
+   ],
+   "source": [
+    "def nt_xent_loss_with_temp_scaling(embeddings1, embeddings2, descriptor_similarity, base_temp=0.02):\n",
+    "    batch_size = embeddings1.shape[0]\n",
+    "    device = embeddings1.device\n",
+    "    #individual_temperatures = sigmoid_temp_scaling(descriptor_similarity, base_temp)\n",
+    "    #temperature = individual_temperatures.mean() # Single temperature for the whole batch\n",
+    "    temperature = base_temp\n",
+    "    # Normalize projections\n",
+    "    z_i = F.normalize(embeddings1, p=2, dim=1)\n",
+    "    z_j = F.normalize(embeddings2, p=2, dim=1)\n",
+    "    \n",
+    "    # Concatenate for similarity matrix calculation\n",
+    "    representations = torch.cat([z_i, z_j], dim=0)\n",
+    "    # Calculate cosine similarity between all pairs\n",
+    "    similarity_matrix = F.cosine_similarity(representations.unsqueeze(1), representations.unsqueeze(0), dim=2)\n",
+    "    #similarity_matrix = torch.clamp(similarity_matrix, min=-0.999, max=0.999)\n",
+    "    sim_ij = torch.diag(similarity_matrix, batch_size)\n",
+    "    sim_ji = torch.diag(similarity_matrix, -batch_size)\n",
+    "    positives = torch.cat([sim_ij, sim_ji], dim=0)\n",
+    "    \n",
+    "    # Create a mask to exclude self-comparisons\n",
+    "    nominator = torch.exp(positives / temperature)\n",
+    "    mask = (~torch.eye(batch_size * 2, batch_size * 2, dtype=torch.bool, device=device)).float()\n",
+    "    denominator = mask * torch.exp(similarity_matrix / temperature)\n",
+    "    \n",
+    "    # Calculate the final loss\n",
+    "    loss = -torch.log(nominator / torch.sum(denominator, dim=1))\n",
+    "    if torch.isnan(loss).any():\n",
+    "        print(similarity_matrix)\n",
+    "        print(f\"Temperature: {temperature}\")\n",
+    "        print(f\"Nominator range: {nominator.min().item():.6f} to {nominator.max().item():.6f}\")\n",
+    "        \n",
+    "    return torch.sum(loss) / (2 * batch_size)\n",
+    "\n",
+    "\n",
+    "def sigmoid_temp_scaling(descriptor_similarity, base_temp=0.05, steepness=10.0, midpoint=0.5):\n",
+    "    \"\"\"Smooth sigmoid-based temperature scaling\"\"\"\n",
+    "    sigmoid_factor = torch.sigmoid(steepness * (descriptor_similarity - midpoint))\n",
+    "    temperature = base_temp * (2.0 - sigmoid_factor)\n",
+    "    return temperature\n",
+    "\n",
+    "\n",
+    "def train_step(batch, model, optimizer, device, scheduler, base_temp=0.1):\n",
+    "    \"\"\"Single training step for NT-Xent\"\"\"\n",
+    "    model.train()\n",
+    "    optimizer.zero_grad()\n",
+    "    \n",
+    "    # Move batch to device\n",
+    "    tokens = {k: v.to(device) for k, v in batch['tokens'].items()}\n",
+    "    desc_similarities = batch['descriptor_similarities'].to(device)\n",
+    "    \n",
+    "    # Forward pass - get embeddings for all samples\n",
+    "    outputs = model(**tokens) # i1, j1, i2, j2 ...\n",
+    "    embeddings = outputs\n",
+    "    \n",
+    "    # Split embeddings: even indices are embeddings1, odd indices are embeddings2\n",
+    "    embeddings1 = embeddings[::2]  # [0, 2, 4, ...]\n",
+    "    embeddings2 = embeddings[1::2] # [1, 3, 5, ...]\n",
+    "    \n",
+    "    # Get descriptor similarities for each pair (take every other one since they're duplicated)\n",
+    "    pair_desc_similarities = desc_similarities[::2]\n",
+    "    #print(f'FIRST TRAIN EMBED: {embeddings1}')\n",
+    "    #print(f'SECOND TRAIN EMBED: {embeddings2}')\n",
+    "    #print(f'COSINE SIM BETWEEN THEM TRAIN: {F.cosine_similarity(embeddings1, embeddings2, dim=1)}')\n",
+    "    # Calculate NT-Xent loss\n",
+    "    loss = nt_xent_loss_with_temp_scaling(embeddings1, embeddings2, pair_desc_similarities, base_temp=base_temp)\n",
+    "    \n",
+    "    # Backward pass\n",
+    "    loss.backward()\n",
+    "    optimizer.step()\n",
+    "    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
+    "    scheduler.step()\n",
+    "    return loss.item()\n",
+    "\n",
+    "def val_step(batch, model, device, base_temp=0.1):\n",
+    "    \"\"\"Single validation step for NT-Xent\"\"\"\n",
+    "    model.eval()\n",
+    "    with torch.no_grad():\n",
+    "        # Move batch to device\n",
+    "        tokens = {k: v.to(device) for k, v in batch['tokens'].items()}\n",
+    "        desc_similarities = batch['descriptor_similarities'].to(device)\n",
+    "        \n",
+    "        # Forward pass\n",
+    "        outputs = model(**tokens)\n",
+    "        embeddings = outputs\n",
+    "        \n",
+    "        # Split embeddings\n",
+    "        embeddings1 = embeddings[::2]\n",
+    "        embeddings2 = embeddings[1::2]\n",
+    "        \n",
+    "        # Get descriptor similarities for pairs\n",
+    "        pair_desc_similarities = desc_similarities[::2]\n",
+    "        \n",
+    "        print(f'FIRST VAL EMBED: {embeddings1}')\n",
+    "        print(f'SECOND VAL EMBED: {embeddings2}')\n",
+    "        print(f'COSINE SIM BETWEEN THEM: {F.cosine_similarity(embeddings1, embeddings2, dim=1)}')\n",
+    "        #print(f'SECOND VAL EMBED: {embeddings2}')\n",
+    "        loss = nt_xent_loss_with_temp_scaling(embeddings1, embeddings2, pair_desc_similarities, base_temp=base_temp)\n",
+    "        print(f'VAL LOSS: {loss}')\n",
+    "    \n",
+    "    return loss.item()\n",
+    "\n",
+    "def train_epoch(train_loader, model, optimizer, scheduler, base_temp=0.01):\n",
+    "    \"\"\"Train for one epoch\"\"\"\n",
+    "    total_loss = 0\n",
+    "    num_batches = 0\n",
+    "    \n",
+    "    progress_bar = tqdm(train_loader, desc=\"Training\")\n",
+    "    \n",
+    "    for batch in progress_bar:\n",
+    "        loss = train_step(batch, model, optimizer, 'cuda', scheduler, base_temp=base_temp)\n",
+    "        total_loss += loss\n",
+    "        num_batches += 1\n",
+    "        \n",
+    "        # Calculate running average loss\n",
+    "        avg_loss = total_loss / num_batches\n",
+    "        \n",
+    "        # Update progress bar with current loss info\n",
+    "        progress_bar.set_postfix({\n",
+    "            'Loss': f'{loss:.4f}',\n",
+    "            'Avg Loss': f'{avg_loss:.4f}'\n",
+    "        })\n",
+    "    \n",
+    "    return total_loss / num_batches if num_batches > 0 else 0\n",
+    "\n",
+    "\n",
+    "def validate_epoch(val_loader, model, base_temp=0.01):\n",
+    "    \"\"\"Validate for one epoch\"\"\"\n",
+    "    total_loss = 0\n",
+    "    num_batches = 0\n",
+    "    print('nah twin')\n",
+    "    return 0\n",
+    "    for batch in val_loader:\n",
+    "        loss = val_step(batch, model, 'cuda', base_temp=base_temp)\n",
+    "        total_loss += loss\n",
+    "        num_batches += 1\n",
+    "    \n",
+    "    return total_loss / num_batches if num_batches > 0 else 0\n",
+    "\n",
+    "def training_loop(train_loader, val_loader, model, tokenizer, epochs=50, patience=5, lr=1e-4, base_temp=0.02,\n",
+    "                 device_name='cuda', save_path='best_model.pt'):\n",
+    "    \"\"\"Main training loop with early stopping\"\"\"\n",
+    "    device = torch.device(device_name if torch.cuda.is_available() else 'cpu')\n",
+    "    print(f\"Using device: {device}\")\n",
+    "    \n",
+    "    # Initialize model and optimizer\n",
+    "    optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
+    "    optimizer.zero_grad()\n",
+    "\n",
+    "    total_steps = epochs * len(train_loader)\n",
+    "    scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_mult=1, T_0=total_steps)\n",
+    "    # Early stopping variables\n",
+    "    best_val_loss = float('inf')\n",
+    "    no_improve_epochs = 0\n",
+    "    \n",
+    "    print(\"Starting training...\")\n",
+    "    \n",
+    "    for epoch in range(epochs):\n",
+    "        # Training\n",
+    "        with torch.autocast(dtype=torch.float16, device_type='cuda'):\n",
+    "            train_loss = train_epoch(train_loader, model, optimizer, scheduler, base_temp=base_temp)\n",
+    "            print('END TRAIN')\n",
+    "            # Validation\n",
+    "            val_loss = validate_epoch(val_loader, model)\n",
+    "        \n",
+    "        print(f\"Epoch {epoch + 1}/{epochs}: Train Loss = {train_loss:.4f}, Val Loss = {val_loss:.4f}\")\n",
+    "        \n",
+    "        # Early stopping check\n",
+    "        if val_loss < best_val_loss:\n",
+    "            best_val_loss = val_loss\n",
+    "            no_improve_epochs = 0\n",
+    "            # Save best model\n",
+    "            torch.save(model.state_dict(), save_path)\n",
+    "            print(f\"New best model saved with val loss: {val_loss:.4f}\")\n",
+    "        else:\n",
+    "            no_improve_epochs += 1\n",
+    "            print(f\"No improvement for {no_improve_epochs} epochs\")\n",
+    "        \n",
+    "        if no_improve_epochs >= patience:\n",
+    "            print(f\"Early stopping triggered after {epoch + 1} epochs\")\n",
+    "            break\n",
+    "    \n",
+    "    # Load best model\n",
+    "    print(f\"Loading best model from {save_path}\")\n",
+    "    model.load_state_dict(torch.load(save_path))\n",
+    "    model.eval()\n",
+    "    \n",
+    "    print(f\"Training completed. Best validation loss: {best_val_loss:.4f}\")\n",
+    "\n",
+    "\n",
+    "model, tokenizer = initialize_model_and_tokenizer()\n",
+    "#model.load_state_dict(torch.load('/home/jovyan/simson_training_bolgov/regression/actual_encoder_state.pkl', weights_only=False))\n",
+    "print(f\"Model initialized with {sum(p.numel() for p in model.parameters() if p.requires_grad):,} trainable parameters\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "c73e2bba-59c1-4b41-b2ff-235526dd2912",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!rm -rf cache"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0072c8f5-c5e9-4590-9544-c73cf1fac1e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computing positive pairs only...\n",
+      "Collecting positive pairs with similarity threshold 0.8\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████| 6378/6378 [00:00<00:00, 54740.22it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generated 12534 positive pairs\n",
+      "Cached pairs saved to cache/train_positive_pairs.pkl\n",
+      "Computing positive pairs only...\n",
+      "Collecting positive pairs with similarity threshold 0.8\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████| 100/100 [00:00<00:00, 200780.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generated 138 positive pairs\n",
+      "Cached pairs saved to cache/val_positive_pairs.pkl\n",
+      "Using device: cuda\n",
+      "Starting training...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|█| 1566/1566 [00:31<00:00, 50.05it/s, Loss=1.1129, Avg Loss=1.528\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "END TRAIN\n",
+      "nah twin\n",
+      "Epoch 1/10: Train Loss = 1.5288, Val Loss = 0.0000\n",
+      "New best model saved with val loss: 0.0000\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|█| 1566/1566 [00:30<00:00, 50.76it/s, Loss=2.1831, Avg Loss=2.190\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "END TRAIN\n",
+      "nah twin\n",
+      "Epoch 2/10: Train Loss = 2.1905, Val Loss = 0.0000\n",
+      "No improvement for 1 epochs\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|█| 1566/1566 [00:30<00:00, 50.69it/s, Loss=2.7081, Avg Loss=2.708\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "END TRAIN\n",
+      "nah twin\n",
+      "Epoch 3/10: Train Loss = 2.7081, Val Loss = 0.0000\n",
+      "No improvement for 2 epochs\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|█| 1566/1566 [00:31<00:00, 50.37it/s, Loss=2.7081, Avg Loss=2.708\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "END TRAIN\n",
+      "nah twin\n",
+      "Epoch 4/10: Train Loss = 2.7081, Val Loss = 0.0000\n",
+      "No improvement for 3 epochs\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|█| 1566/1566 [00:31<00:00, 50.40it/s, Loss=2.7081, Avg Loss=2.708\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "END TRAIN\n",
+      "nah twin\n",
+      "Epoch 5/10: Train Loss = 2.7081, Val Loss = 0.0000\n",
+      "No improvement for 4 epochs\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training:  13%|▏| 198/1566 [00:04<00:27, 50.58it/s, Loss=2.7081, Avg Loss=2.7081"
+     ]
+    }
+   ],
+   "source": [
+    "train_loader, val_loader = create_dataloaders(\n",
+    "    train_list, val_list[:100], tokenizer, \n",
+    "    batch_size=8, positive_threshold=0.8\n",
+    ")\n",
+    "\n",
+    "training_loop(\n",
+    "    train_loader, val_loader, model, tokenizer,\n",
+    "    epochs=10, patience=5, lr=1e-5, \n",
+    "    device_name='cuda', base_temp=0.1\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "58343b16-1bdb-4476-ac61-e797fbc661d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(train_list[:5], '\\n\\n', val_list[:5])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47561022-5f57-4b7b-b903-ef1f8773f903",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5fcef978-3630-4201-9301-6963a8560517",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:.mlspace-bolgov_simson_training]",
+   "language": "python",
+   "name": "conda-env-.mlspace-bolgov_simson_training-py"
+  },
+  "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.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

simson_modeling/.ipynb_checkpoints/simson_ddp_train-checkpoint.py

@@ -0,0 +1,545 @@
+# ==============================================================================
+# 1. IMPORTS
+# ==============================================================================
+import os
+import warnings
+import wandb
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, Dataset
+import numpy as np
+from tqdm import tqdm
+from rdkit import Chem, RDLogger
+from datasets import load_dataset, load_from_disk
+from transformers import AutoTokenizer, BertModel, BertConfig
+import pandas as pd
+
+# ==============================================================================
+# 2. INITIAL SETUP
+# ==============================================================================
+# Suppress RDKit console output
+RDLogger.DisableLog('rdApp.*')
+# Ignore warnings for cleaner output
+warnings.filterwarnings("ignore")
+
+# ==============================================================================
+# 3. MODEL AND LOSS FUNCTION
+# ==============================================================================
+def global_average_pooling(x):
+    """Global Average Pooling: from [B, max_len, hid_dim] to [B, hid_dim]"""
+    return torch.mean(x, dim=1)
+
+class SimSonEncoder(nn.Module):
+    """The main encoder model based on BERT."""
+    def __init__(self, config: BertConfig, max_len: int, dropout: float = 0.1):
+        super(SimSonEncoder, self).__init__()
+        self.bert = BertModel(config, add_pooling_layer=False)
+        self.linear = nn.Linear(config.hidden_size, max_len)
+        self.dropout = nn.Dropout(dropout)
+        
+    def forward(self, input_ids, attention_mask=None):
+        if attention_mask is None:
+            attention_mask = input_ids.ne(self.bert.config.pad_token_id)
+            
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        hidden_states = self.dropout(outputs.last_hidden_state)
+        pooled_output = global_average_pooling(hidden_states)
+        return self.linear(pooled_output)
+
+class ContrastiveLoss(nn.Module):
+    """Calculates the contrastive loss for the SimSon model."""
+    def __init__(self, temperature=0.2):
+        super(ContrastiveLoss, self).__init__()
+        self.temperature = temperature
+        self.similarity_fn = F.cosine_similarity
+
+    def forward(self, proj_1, proj_2):
+        batch_size = proj_1.shape[0]
+        device = proj_1.device
+        
+        # Normalize projections
+        z_i = F.normalize(proj_1, p=2, dim=1)
+        z_j = F.normalize(proj_2, p=2, dim=1)
+        
+        # Concatenate for similarity matrix calculation
+        representations = torch.cat([z_i, z_j], dim=0)
+        
+        # Calculate cosine similarity between all pairs
+        similarity_matrix = self.similarity_fn(representations.unsqueeze(1), representations.unsqueeze(0), dim=2)
+        
+        # Identify positive pairs (original and its augmentation)
+        sim_ij = torch.diag(similarity_matrix, batch_size)
+        sim_ji = torch.diag(similarity_matrix, -batch_size)
+        positives = torch.cat([sim_ij, sim_ji], dim=0)
+        
+        # Create a mask to exclude self-comparisons
+        nominator = torch.exp(positives / self.temperature)
+        mask = (~torch.eye(batch_size * 2, batch_size * 2, dtype=torch.bool, device=device)).float()
+        denominator = mask * torch.exp(similarity_matrix / self.temperature)
+        
+        # Calculate the final loss
+        loss = -torch.log(nominator / torch.sum(denominator, dim=1))
+        return torch.sum(loss) / (2 * batch_size)
+
+# ==============================================================================
+# 4. DATA HANDLING (Keeping your existing classes unchanged)
+# ==============================================================================
+class SmilesEnumerator:
+    """Generates randomized SMILES strings for data augmentation."""
+    def randomize_smiles(self, smiles):
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            return Chem.MolToSmiles(mol, doRandom=True, canonical=False) if mol else smiles
+        except:
+            return smiles
+
+class ContrastiveSmilesDataset(Dataset):
+    """Dataset for creating pairs of augmented SMILES for contrastive learning."""
+    def __init__(self, smiles_list, tokenizer, max_length=512):
+        self.smiles_list = smiles_list
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        self.enumerator = SmilesEnumerator()
+
+    def __len__(self):
+        return len(self.smiles_list)
+
+    def __getitem__(self, idx):
+        original_smiles = self.smiles_list[idx]
+        
+        # Create two different augmentations of the same SMILES
+        smiles_1 = self.enumerator.randomize_smiles(original_smiles)
+        smiles_2 = self.enumerator.randomize_smiles(original_smiles)
+        
+        # Tokenize and do pad. Padding will be handled by the collate_fn.
+        tokens_1 = self.tokenizer(smiles_1, max_length=self.max_length, truncation=True, padding='max_length')
+        tokens_2 = self.tokenizer(smiles_2, max_length=self.max_length, truncation=True, padding='max_length')
+        
+        return {
+            'input_ids_1': torch.tensor(tokens_1['input_ids']),
+            'attention_mask_1': torch.tensor(tokens_1['attention_mask']),
+            'input_ids_2': torch.tensor(tokens_2['input_ids']),
+            'attention_mask_2': torch.tensor(tokens_2['attention_mask']),
+        }
+
+class PrecomputedContrastiveSmilesDataset(Dataset):
+    """
+    A Dataset class that reads pre-augmented SMILES pairs from a Parquet file.
+    This is significantly faster as it offloads the expensive SMILES randomization
+    to a one-time preprocessing step.
+    """
+    def __init__(self, tokenizer, file_path: str, max_length: int = 512):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        
+        # Load the entire dataset from the Parquet file into memory.
+        # This is fast and efficient for subsequent access.
+        print(f"Loading pre-computed data from {file_path}...")
+        self.data = pd.read_parquet(file_path)
+        print("Data loaded successfully.")
+
+    def __len__(self):
+        """Returns the total number of pairs in the dataset."""
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        """
+        Retrieves a pre-augmented pair, tokenizes it, and returns it
+        in the format expected by the DataCollator.
+        """
+        # Retrieve the pre-augmented pair from the DataFrame
+        row = self.data.iloc[idx]
+        smiles_1 = row['smiles_1']
+        smiles_2 = row['smiles_2']
+        
+        # Tokenize the pair. This operation is fast and remains in the data loader.
+        tokens_1 = self.tokenizer(smiles_1, max_length=self.max_length, truncation=True, padding='max_length')
+        tokens_2 = self.tokenizer(smiles_2, max_length=self.max_length, truncation=True, padding='max_length')
+        
+        return {
+            'input_ids_1': torch.tensor(tokens_1['input_ids']),
+            'attention_mask_1': torch.tensor(tokens_1['attention_mask']),
+            'input_ids_2': torch.tensor(tokens_2['input_ids']),
+            'attention_mask_2': torch.tensor(tokens_2['attention_mask']),
+        }
+
+class PreTokenizedSmilesDataset(Dataset):
+    """
+    A Dataset that loads a pre-tokenized and pre-padded dataset created
+    by the preprocessing script. It uses memory-mapping for instant loads
+    and high efficiency.
+    """
+    def __init__(self, dataset_path: str):
+        # Load the dataset from disk. This is very fast due to memory-mapping.
+        self.dataset = load_from_disk(dataset_path)
+        # Set the format to PyTorch tensors for direct use in the model
+        self.dataset.set_format(type='torch', columns=[
+            'input_ids_1', 'attention_mask_1', 'input_ids_2', 'attention_mask_2'
+        ])
+        print(f"Successfully loaded pre-tokenized dataset from {dataset_path}.")
+
+    def __len__(self):
+        """Returns the total number of items in the dataset."""
+        return len(self.dataset)
+
+    def __getitem__(self, idx):
+        """Retrieves a single pre-processed item."""
+        return self.dataset[idx]
+
+class DataCollatorWithPadding:
+    """
+    A collate function that dynamically pads inputs to the longest sequence
+    across both augmented views in the batch, ensuring consistent tensor shapes.
+    """
+    def __init__(self, tokenizer):
+        self.tokenizer = tokenizer
+
+    def __call__(self, features):
+        # Create a combined list of features for both views to find the global max length
+        combined_features = []
+        for feature in features:
+            combined_features.append({'input_ids': feature['input_ids_1'], 'attention_mask': feature['attention_mask_1']})
+            combined_features.append({'input_ids': feature['input_ids_2'], 'attention_mask': feature['attention_mask_2']})
+
+        # Pad the combined batch. This ensures all sequences are padded to the same length.
+        padded_combined = self.tokenizer.pad(combined_features, padding='longest', return_tensors='pt')
+
+        # Split the padded tensors back into two views
+        batch_size = len(features)
+        input_ids_1, input_ids_2 = torch.split(padded_combined['input_ids'], batch_size, dim=0)
+        attention_mask_1, attention_mask_2 = torch.split(padded_combined['attention_mask'], batch_size, dim=0)
+        
+        return {
+            'input_ids_1': input_ids_1,
+            'attention_mask_1': attention_mask_1,
+            'input_ids_2': input_ids_2,
+            'attention_mask_2': attention_mask_2,
+        }
+
+# ==============================================================================
+# 5. CHECKPOINT UTILITIES
+# ==============================================================================
+def save_checkpoint(model, optimizer, scheduler, global_step, save_path):
+    """Save complete checkpoint with model, optimizer, scheduler states and step count."""
+    checkpoint = {
+        'model_state_dict': model.state_dict(),
+        'optimizer_state_dict': optimizer.state_dict(),
+        'scheduler_state_dict': scheduler.state_dict(),
+        'global_step': global_step,
+    }
+    torch.save(checkpoint, save_path)
+    print(f"Full checkpoint saved at step {global_step}")
+
+def load_checkpoint(checkpoint_path, model, optimizer, scheduler):
+    """Load checkpoint and return the global step to resume from."""
+    checkpoint = torch.load(checkpoint_path, map_location='cpu')
+    model.load_state_dict(checkpoint['model_state_dict'])
+    optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
+    global_step = checkpoint['global_step']
+    print(f"Checkpoint loaded from step {global_step}")
+    return global_step
+
+# ==============================================================================
+# 6. TRAINING AND EVALUATION LOOPS - MODIFIED
+# ==============================================================================
+def evaluation_step(model, batch, criterion, device):
+    """Performs a single evaluation step on a batch of data."""
+    input_ids_1 = batch['input_ids_1'].to(device)
+    attention_mask_1 = batch['attention_mask_1'].to(device)
+    input_ids_2 = batch['input_ids_2'].to(device)
+    attention_mask_2 = batch['attention_mask_2'].to(device)
+    
+    combined_input_ids = torch.cat([input_ids_1, input_ids_2], dim=0)
+    combined_attention_mask = torch.cat([attention_mask_1, attention_mask_2], dim=0)
+    
+    with torch.no_grad():
+        combined_proj = model(combined_input_ids, combined_attention_mask)
+        
+    batch_size = input_ids_1.size(0)
+    proj_1, proj_2 = torch.split(combined_proj, batch_size, dim=0)
+    
+    loss = criterion(proj_1, proj_2)
+    return proj_1, proj_2, loss
+
+def train_with_step_based_validation(model, train_loader, val_loader, optimizer, criterion, device, 
+                                   scheduler, checkpoint_path, save_steps, validation_steps, 
+                                   start_step=0, max_steps=None):
+    """
+    Modified training function with step-based validation and checkpointing.
+    """
+    model.train()
+    global_step = start_step
+    best_val_loss = float('inf')
+    
+    # Calculate total steps if max_steps is not provided
+    if max_steps is None:
+        max_steps = len(train_loader)
+    
+    progress_bar = tqdm(total=max_steps - start_step, desc="Training Steps", initial=start_step)
+    
+    # Create iterator that can be resumed from any point
+    train_iterator = iter(train_loader)
+    
+    # Skip batches if resuming from checkpoint
+    if start_step > 0:
+        batches_to_skip = start_step % len(train_loader)
+        for _ in range(batches_to_skip):
+            try:
+                next(train_iterator)
+            except StopIteration:
+                train_iterator = iter(train_loader)
+    
+    while global_step < max_steps:
+        try:
+            batch = next(train_iterator)
+        except StopIteration:
+            train_iterator = iter(train_loader)
+            batch = next(train_iterator)
+        
+        # Training step
+        input_ids_1 = batch['input_ids_1'].to(device)
+        attention_mask_1 = batch['attention_mask_1'].to(device)
+        input_ids_2 = batch['input_ids_2'].to(device)
+        attention_mask_2 = batch['attention_mask_2'].to(device)
+        
+        optimizer.zero_grad()
+        with torch.autocast(dtype=torch.float16, device_type="cuda"):
+            combined_input_ids = torch.cat([input_ids_1, input_ids_2], dim=0)
+            combined_attention_mask = torch.cat([attention_mask_1, attention_mask_2], dim=0)
+        
+            combined_proj = model(combined_input_ids, combined_attention_mask)
+        
+            batch_size = input_ids_1.size(0)
+            proj_1, proj_2 = torch.split(combined_proj, batch_size, dim=0)
+        
+            loss = criterion(proj_1, proj_2)
+
+        loss.backward()
+        optimizer.step()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        scheduler.step()
+        
+        global_step += 1
+        
+        progress_bar.update(1)
+        progress_bar.set_postfix(loss=f"{loss.item():.4f}", step=global_step)
+        
+        wandb.log({
+            "train_batch_loss": loss.item(),
+            "learning_rate": scheduler.get_last_lr()[0],
+            "global_step": global_step
+        })
+        
+        # Step-based validation
+        if global_step % validation_steps == 0:
+            val_loss = validate_epoch(model, val_loader, criterion, device)
+            wandb.log({
+                "val_loss": val_loss,
+                "global_step": global_step
+            })
+            
+            # Save best model (model state only for best checkpoint)
+            if val_loss < best_val_loss:
+                best_val_loss = val_loss
+                model_save_path = checkpoint_path.replace('.pt', '_best_model.bin')
+                torch.save(model.state_dict(), model_save_path)
+                progress_bar.write(f"Step {global_step}: New best model saved with val loss {val_loss:.4f}")
+            
+            model.train()  # Resume training mode after validation
+        
+        # Step-based checkpointing (full checkpoint)
+        if global_step % save_steps == 0:
+            save_checkpoint(model, optimizer, scheduler, global_step, checkpoint_path)
+    
+    progress_bar.close()
+    return global_step
+
+def validate_epoch(model, val_loader, criterion, device):
+    """Validation function - unchanged from original."""
+    model.eval()
+    total_loss = 0
+    progress_bar = tqdm(val_loader, desc="Validating", leave=False)
+
+    for batch in progress_bar:
+        _, _, loss = evaluation_step(model, batch, criterion, device)
+        total_loss += loss.item()
+    
+    avg_loss = total_loss / len(val_loader)
+    print(f'Validation loss: {avg_loss:.4f}')            
+    return avg_loss
+
+def test_model(model, test_loader, criterion, device):
+    """Test function - unchanged from original."""
+    model.eval()
+    total_loss = 0
+    all_similarities = []
+    progress_bar = tqdm(test_loader, desc="Testing", leave=False)
+
+    for batch in progress_bar:
+        proj_1, proj_2, loss = evaluation_step(model, batch, criterion, device)
+        total_loss += loss.item()
+        
+        proj_1_norm = F.normalize(proj_1, p=2, dim=1)
+        proj_2_norm = F.normalize(proj_2, p=2, dim=1)
+        batch_similarities = F.cosine_similarity(proj_1_norm, proj_2_norm, dim=1)
+        all_similarities.extend(batch_similarities.cpu().numpy())
+
+    avg_loss = total_loss / len(test_loader)
+    avg_sim = np.mean(all_similarities)
+    std_sim = np.std(all_similarities)
+    
+    return avg_loss, avg_sim, std_sim
+
+# ==============================================================================
+# 7. MODIFIED SINGLE-GPU TRAINING
+# ==============================================================================
+def run_training(model_config, hparams, data_splits):
+    """The main function to run the training and evaluation process with step-based validation."""
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Using device: {device}")
+    
+    wandb_key = os.getenv("WANDB_API_KEY")
+    if wandb_key:
+        wandb.login(key=wandb_key)
+    wandb.init(
+        #project="simson-contrastive-learning-single-gpu",
+        #name=f"run-{wandb.util.generate_id()}",
+        #config=hparams
+    )
+    
+    train_smiles, val_smiles, test_smiles = data_splits    
+
+    tokenizer = AutoTokenizer.from_pretrained('DeepChem/ChemBERTa-77M-MTR')
+
+    precomputed_train_path = '/home/jovyan/simson_training_bolgov/data/pubchem_119m_splits/train.parquet'
+    precomputed_test_path = '/home/jovyan/simson_training_bolgov/data/pubchem_119m_splits/test.parquet'
+    precomputed_val_path = '/home/jovyan/simson_training_bolgov/data/pubchem_119m_splits/validation.parquet'
+ 
+    train_dataset = PrecomputedContrastiveSmilesDataset(tokenizer, file_path=precomputed_train_path, max_length=hparams['max_length'])
+    test_dataset = PrecomputedContrastiveSmilesDataset(tokenizer, file_path=precomputed_test_path, max_length=hparams['max_length'])
+    val_dataset = PrecomputedContrastiveSmilesDataset(tokenizer, file_path=precomputed_val_path, max_length=hparams['max_length'])
+        
+    train_loader = DataLoader(train_dataset, batch_size=hparams['batch_size'], shuffle=True, num_workers=8, prefetch_factor=128, pin_memory=True)
+    val_loader = DataLoader(val_dataset, batch_size=hparams['batch_size'], shuffle=False, num_workers=2, pin_memory=True)
+    test_loader = DataLoader(test_dataset, batch_size=hparams['batch_size'], shuffle=False, num_workers=2, pin_memory=True)
+    
+    print('Initialized all data. Compiling the model...')
+    model = SimSonEncoder(config=model_config, max_len=hparams['max_embeddings']).to(device)
+    model = torch.compile(model)
+    model.load_state_dict(torch.load('/home/jovyan/simson_training_bolgov/simson_checkpoints/checkpoint_best_model.bin'))
+    print(model)
+
+    total_params = sum(p.numel() for p in model.parameters())
+
+    print(f"Total number of parameters: {total_params // 1_000_000} M")
+    wandb.config.update({"total_params_M": total_params // 1_000_000})
+
+    criterion = ContrastiveLoss(temperature=hparams['temperature']).to(device)
+    optimizer = optim.AdamW(model.parameters(), lr=hparams['lr'], weight_decay=1e-5, fused=True)
+    
+    total_steps = hparams['epochs'] * len(train_loader)
+    scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_mult=1, T_0=total_steps)
+    
+    print("Starting training...")
+    wandb.watch(model, log='all', log_freq=5000)
+    
+    start_step = 0
+    checkpoint_path = hparams['checkpoint_path']
+    
+    # Resume from checkpoint if provided
+    if hparams.get('resume_checkpoint') and os.path.exists(hparams['resume_checkpoint']):
+        print(f"Resuming from checkpoint: {hparams['resume_checkpoint']}")
+        start_step = load_checkpoint(hparams['resume_checkpoint'], model, optimizer, scheduler)
+    
+    # Train with step-based validation
+    final_step = train_with_step_based_validation(
+        model, train_loader, val_loader, optimizer, criterion, device, 
+        scheduler, checkpoint_path, hparams['save_steps'], hparams['validation_steps'],
+        start_step=start_step, max_steps=total_steps
+    )
+    
+    print("Training complete. Starting final testing...")
+    
+    # Load the best model for testing (model state only)
+    best_model_path = checkpoint_path.replace('.pt', '_best_model.bin')
+    if os.path.exists(best_model_path):
+        model.load_state_dict(torch.load(best_model_path))
+        print("Loaded best model for testing")
+    
+    test_loss, avg_sim, std_sim = test_model(model, test_loader, criterion, device)
+    
+    print("\n--- Test Results ---")
+    print(f"Test Loss: {test_loss:.4f}")
+    print(f"Average Cosine Similarity: {avg_sim:.4f} ± {std_sim:.4f}")
+    print("--------------------")
+    
+    wandb.log({
+        "test_loss": test_loss,
+        "avg_cosine_similarity": avg_sim,
+        "std_cosine_similarity": std_sim
+    })
+    
+    # Save final model state only
+    final_model_path = hparams['save_path']
+    torch.save(model.state_dict(), final_model_path)
+    print(f"Final model saved to {final_model_path}")
+    
+    wandb.finish()
+
+# ==============================================================================
+# 8. MAIN EXECUTION
+# ==============================================================================
+def main():
+    """Main function to configure and run the training process."""
+    hparams = {
+        'epochs': 2,
+        'lr': 6e-6,
+        'temperature': 0.05,
+        'batch_size': 64,
+        'max_length': 256,
+        'save_path': "simson_checkpoints_more_epochs/simson_model_single_gpu.bin",
+        'checkpoint_path': "simson_checkpoints_more_epochs/checkpoint.pt",  # Full checkpoint
+        'save_steps': 50000,  # Save checkpoint every 10k steps
+        'validation_steps': 5000,  # Validate every 5k steps
+        'max_embeddings': 512,
+        'resume_checkpoint': None,  # Set to checkpoint path to resume
+    }
+
+    dataset = load_dataset('HoangHa/SMILES-250M')['train']
+    smiles_column_name = 'SMILES'
+    
+    total_size = len(dataset)
+    test_size = int(0.1 * total_size)
+    val_size = int(0.1 * (total_size - test_size))
+
+    test_smiles = dataset.select(range(test_size))[smiles_column_name]
+    val_smiles = dataset.select(range(test_size, test_size + val_size))[smiles_column_name]
+    train_smiles = dataset.select(range(test_size + val_size, total_size))[smiles_column_name]
+    data_splits = (train_smiles, val_smiles, test_smiles)
+    
+    tokenizer = AutoTokenizer.from_pretrained('DeepChem/ChemBERTa-77M-MTR')
+    model_config = BertConfig(
+        vocab_size=tokenizer.vocab_size,
+        hidden_size=768,
+        num_hidden_layers=4,
+        num_attention_heads=12,
+        intermediate_size=2048,
+        max_position_embeddings=512
+    )
+    
+    # Create directories
+    save_dir = os.path.dirname(hparams['save_path'])
+    checkpoint_dir = os.path.dirname(hparams['checkpoint_path'])
+    for directory in [save_dir, checkpoint_dir]:
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+
+    # Directly call the training function for a single-GPU run
+    run_training(model_config, hparams, data_splits)
+
+if __name__ == '__main__':
+    main()

simson_modeling/.ipynb_checkpoints/upload_state_to_hf-checkpoint.py

@@ -0,0 +1,23 @@
+from huggingface_hub import HfApi 
+
+state_path = '/home/jovyan/simson_training_bolgov/simson_checkpoints_1M/checkpoint_best_model.bin'
+
+from huggingface_hub import HfApi
+api = HfApi()
+upload_folder = True
+if not upload_folder:
+
+    api.upload_file(
+        path_or_fileobj=state_path,
+        path_in_repo="polymer_1M_weights.bin",
+        repo_id="Defetya/simson_base",
+        repo_type="model",
+    )
+else:
+
+    api.upload_folder(
+        folder_path="/home/jovyan/simson_training_bolgov",
+        repo_id="Defetya/simson_base",
+        path_in_repo="simson_modeling",
+        repo_type="model",
+    )

simson_modeling/create_augmented_dataset.py

@@ -0,0 +1,83 @@
+import pandas as pd
+from tqdm import tqdm
+from rdkit import Chem, RDLogger
+from datasets import load_dataset
+from multiprocessing import Pool, cpu_count
+import os
+
+# Suppress RDKit console output for cleaner logs
+RDLogger.DisableLog('rdApp.*')
+
+class SmilesEnumerator:
+    """
+    A simple class to encapsulate the SMILES randomization logic.
+    Needed for multiprocessing to work correctly with instance methods.
+    """
+    def randomize_smiles(self, smiles):
+        """Generates a randomized SMILES string."""
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            # Return a randomized, non-canonical SMILES string
+            return Chem.MolToSmiles(mol, doRandom=True, canonical=False) if mol else smiles
+        except:
+            # If RDKit fails, return the original smiles string
+            return smiles
+
+def create_augmented_pair(smiles_string):
+    """
+    Worker function: takes one SMILES string and returns a tuple
+    containing two different randomized versions of it.
+    """
+    enumerator = SmilesEnumerator()
+    smiles_1 = enumerator.randomize_smiles(smiles_string)
+    smiles_2 = enumerator.randomize_smiles(smiles_string)
+    return smiles_1, smiles_2
+
+def main():
+    """
+    Main function to run the parallel data preprocessing.
+    """
+    # --- Configuration ---
+    # Load your desired dataset from Hugging Face
+    dataset_name = 'jablonkagroup/pubchem-smiles-molecular-formula'
+    # Specify the column containing the SMILES strings
+    smiles_column_name = 'smiles'
+    # Set the output file path
+    output_path = 'data/pubchem_2_epoch_50M'
+
+    # --- Data Loading ---
+    print(f"Loading dataset '{dataset_name}'...")
+    # Use streaming to avoid downloading the whole dataset if you only need a subset
+    #dataset = pd.read_csv('/home/jovyan/simson_training_bolgov/data/PI1M_v2.csv')
+    dataset = load_dataset(dataset_name)['train'].select(range(50_000_000))
+    # Take the desired number of samples
+    smiles_list = dataset[smiles_column_name]
+    print(f"Successfully fetched {len(smiles_list)} SMILES strings.")
+
+    # --- Parallel Processing ---
+    # Use all available CPU cores for maximum speed
+    num_workers = cpu_count()
+    print(f"Starting SMILES augmentation with {num_workers} worker processes...")
+
+    # A Pool of processes will run the `create_augmented_pair` function in parallel
+    with Pool(num_workers) as p:
+        # Use tqdm to create a progress bar for the mapping operation
+        results = list(tqdm(p.imap(create_augmented_pair, smiles_list), total=len(smiles_list), desc="Augmenting Pairs"))
+
+    # --- Saving Data ---
+    print("Processing complete. Converting to DataFrame...")
+    # Convert the list of tuples into a pandas DataFrame
+    df = pd.DataFrame(results, columns=['smiles_1', 'smiles_2'])
+
+    # Ensure the output directory exists
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+    print(f"Saving augmented pairs to '{output_path}'...")
+    # Save the DataFrame to a Parquet file for efficient storage and loading
+    df.to_parquet(output_path)
+    
+    print("All done. Your pre-computed dataset is ready!")
+
+if __name__ == '__main__':
+    main()
+

simson_modeling/create_augmented_dataset.py.save

@@ -0,0 +1,83 @@
+import pandas as pd
+from tqdm import tqdm
+from rdkit import Chem, RDLogger
+from datasets import load_dataset
+from multiprocessing import Pool, cpu_count
+import os
+
+# Suppress RDKit console output for cleaner logs
+RDLogger.DisableLog('rdApp.*')
+
+class SmilesEnumerator:
+    """
+    A simple class to encapsulate the SMILES randomization logic.
+    Needed for multiprocessing to work correctly with instance methods.
+    """
+    def randomize_smiles(self, smiles):
+        """Generates a randomized SMILES string."""
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            # Return a randomized, non-canonical SMILES string
+            return Chem.MolToSmiles(mol, doRandom=True, canonical=False) if mol else smiles
+        except:
+            # If RDKit fails, return the original smiles string
+            return smiles
+
+def create_augmented_pair(smiles_string):
+    """
+    Worker function: takes one SMILES string and returns a tuple
+    containing two different randomized versions of it.
+    """
+    enumerator = SmilesEnumerator()
+    smiles_1 = enumerator.randomize_smiles(smiles_string)
+    smiles_2 = enumerator.randomize_smiles(smiles_string)
+    return smiles_1, smiles_2
+
+def main():
+    """
+    Main function to run the parallel data preprocessing.
+    """
+    # --- Configuration ---
+    # Load your desired dataset from Hugging Face
+    dataset_name = 'jablonkagroup/pubchem-smiles-molecular-formula'
+    # Specify the column containing the SMILES strings
+    smiles_column_name = 'smiles'
+    # Set the output file path
+    output_path = 'data/pubchem_computed_110_end_M.parquet'
+
+    # --- Data Loading ---
+    print(f"Loading dataset '{dataset_name}'...")
+    # Use streaming to avoid downloading the whole dataset if you only need a subset
+    dataset = load_dataset(dataset_name, split='train').select(range(110_000_000, ))
+    
+    # Take the desired number of samples
+    smiles_list = dataset[smiles_column_name]
+    print(f"Successfully fetched {len(smiles_list)} SMILES strings.")
+
+    # --- Parallel Processing ---
+    # Use all available CPU cores for maximum speed
+    num_workers = cpu_count()
+    print(f"Starting SMILES augmentation with {num_workers} worker processes...")
+
+    # A Pool of processes will run the `create_augmented_pair` function in parallel
+    with Pool(num_workers) as p:
+        # Use tqdm to create a progress bar for the mapping operation
+        results = list(tqdm(p.imap(create_augmented_pair, smiles_list), total=len(smiles_list), desc="Augmenting Pairs"))
+
+    # --- Saving Data ---
+    print("Processing complete. Converting to DataFrame...")
+    # Convert the list of tuples into a pandas DataFrame
+    df = pd.DataFrame(results, columns=['smiles_1', 'smiles_2'])
+
+    # Ensure the output directory exists
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+    print(f"Saving augmented pairs to '{output_path}'...")
+    # Save the DataFrame to a Parquet file for efficient storage and loading
+    df.to_parquet(output_path)
+    
+    print("All done. Your pre-computed dataset is ready!")
+
+if __name__ == '__main__':
+    main()
+

simson_modeling/create_splits.py

@@ -0,0 +1,200 @@
+import os
+import pandas as pd
+from pathlib import Path
+import numpy as np
+from sklearn.model_selection import train_test_split
+
+def concatenate_and_split_parquet(
+    input_dir: str, 
+    output_dir: str, 
+    val_size: int = 10000, 
+    test_size: int = 5000,
+    random_state: int = 42
+):
+    """
+    Concatenate all parquet files in a directory and split into train/val/test sets.
+    
+    Args:
+        input_dir: Path to directory containing parquet files
+        output_dir: Path to directory where split files will be saved
+        val_size: Number of samples for validation set (default: 10000)
+        test_size: Number of samples for test set (default: 5000)
+        random_state: Random seed for reproducibility
+    """
+    
+    # Create output directory if it doesn't exist
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    
+    # Find all parquet files in the input directory
+    input_path = Path(input_dir)
+    parquet_files = list(input_path.glob("*.parquet"))
+    
+    if not parquet_files:
+        raise ValueError(f"No parquet files found in {input_dir}")
+    
+    print(f"Found {len(parquet_files)} parquet files")
+    
+    # Read and concatenate all parquet files
+    print("Reading and concatenating parquet files...")
+    dataframes = []
+    
+    for file_path in parquet_files:
+        print(f"Reading {file_path.name}...")
+        df = pd.read_parquet(file_path)
+        dataframes.append(df)
+    
+    # Concatenate all dataframes
+    combined_df = pd.concat(dataframes, ignore_index=True)
+    print(f"Combined dataset shape: {combined_df.shape}")
+    
+    # Check if we have enough samples
+    total_samples = len(combined_df)
+    required_samples = val_size + test_size
+    
+    if total_samples < required_samples:
+        raise ValueError(
+            f"Not enough samples. Required: {required_samples}, Available: {total_samples}"
+        )
+    
+    # Shuffle the data
+    combined_df = combined_df.sample(frac=1, random_state=random_state).reset_index(drop=True)
+    
+    # Split the data
+    print("Splitting data...")
+    
+    # First split: separate test set
+    temp_df, test_df = train_test_split(
+        combined_df, 
+        test_size=test_size, 
+        random_state=random_state
+    )
+    
+    # Second split: separate validation from remaining data
+    train_df, val_df = train_test_split(
+        temp_df, 
+        test_size=val_size, 
+        random_state=random_state
+    )
+    
+    print(f"Training set shape: {train_df.shape}")
+    print(f"Validation set shape: {val_df.shape}")
+    print(f"Test set shape: {test_df.shape}")
+    
+    # Save the splits as parquet files
+    output_path = Path(output_dir)
+    
+    train_path = output_path / "train.parquet"
+    val_path = output_path / "validation.parquet"
+    test_path = output_path / "test.parquet"
+    
+    print("Saving split datasets...")
+    train_df.to_parquet(train_path, index=False)
+    val_df.to_parquet(val_path, index=False)
+    test_df.to_parquet(test_path, index=False)
+    
+    print(f"Files saved to:")
+    print(f"  Training: {train_path}")
+    print(f"  Validation: {val_path}")
+    print(f"  Test: {test_path}")
+    
+    return train_df, val_df, test_df
+
+# Alternative version using PyArrow for better performance with large files
+def concatenate_and_split_parquet_arrow(
+    input_dir: str, 
+    output_dir: str, 
+    val_size: int = 10000, 
+    test_size: int = 5000,
+    random_state: int = 42
+):
+    """
+    Same functionality as above but using PyArrow for better performance.
+    """
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    
+    # Create output directory if it doesn't exist
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    
+    # Find all parquet files
+    input_path = Path(input_dir)
+    parquet_files = list(input_path.glob("*.parquet"))
+    
+    if not parquet_files:
+        raise ValueError(f"No parquet files found in {input_dir}")
+    
+    print(f"Found {len(parquet_files)} parquet files")
+    
+    # Read and concatenate using PyArrow
+    print("Reading and concatenating parquet files...")
+    tables = []
+    
+    for file_path in parquet_files:
+        print(f"Reading {file_path.name}...")
+        table = pq.read_table(file_path)
+        tables.append(table)
+    
+    # Concatenate tables
+    combined_table = pa.concat_tables(tables)
+    combined_df = combined_table.to_pandas()
+    
+    print(f"Combined dataset shape: {combined_df.shape}")
+    
+    # Rest of the function is the same as above
+    total_samples = len(combined_df)
+    required_samples = val_size + test_size
+    
+    if total_samples < required_samples:
+        raise ValueError(
+            f"Not enough samples. Required: {required_samples}, Available: {total_samples}"
+        )
+    
+    # Shuffle and split
+    combined_df = combined_df.sample(frac=1, random_state=random_state).reset_index(drop=True)
+    
+    temp_df, test_df = train_test_split(
+        combined_df, test_size=test_size, random_state=random_state
+    )
+    
+    train_df, val_df = train_test_split(
+        temp_df, test_size=val_size, random_state=random_state
+    )
+    
+    print(f"Training set shape: {train_df.shape}")
+    print(f"Validation set shape: {val_df.shape}")
+    print(f"Test set shape: {test_df.shape}")
+    
+    # Save using PyArrow
+    output_path = Path(output_dir)
+    
+    pq.write_table(pa.Table.from_pandas(train_df), output_path / "train.parquet")
+    pq.write_table(pa.Table.from_pandas(val_df), output_path / "validation.parquet")
+    pq.write_table(pa.Table.from_pandas(test_df), output_path / "test.parquet")
+    
+    print(f"Files saved to {output_dir}")
+    
+    return train_df, val_df, test_df
+
+# Example usage
+if __name__ == "__main__":
+    # Example usage
+    input_directory = "data"
+    output_directory = "data/polymer_splits"
+    
+    # Using pandas version
+    train_df, val_df, test_df = concatenate_and_split_parquet(
+        input_dir=input_directory,
+        output_dir=output_directory,
+        val_size=10000,
+        test_size=5000,
+        random_state=42
+    )
+    
+    # Or using PyArrow version for better performance
+    # train_df, val_df, test_df = concatenate_and_split_parquet_arrow(
+    #     input_dir=input_directory,
+    #     output_dir=output_directory,
+    #     val_size=10000,
+    #     test_size=5000,
+    #     random_state=42
+    # )

simson_modeling/data/polymer_1M.parquet

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

simson_modeling/data/polymer_splits/test.parquet

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

simson_modeling/data/polymer_splits/train.parquet

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

simson_modeling/data/polymer_splits/validation.parquet

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

simson_modeling/data/pubchem_119m_splits/test.parquet

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

simson_modeling/data/pubchem_119m_splits/train.parquet

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

simson_modeling/data/pubchem_119m_splits/validation.parquet

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

simson_modeling/data/pubchem_2_epoch_50M

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

simson_modeling/data/splits/test.parquet

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

simson_modeling/data/splits/train.parquet

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

simson_modeling/data/splits/validation.parquet

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

simson_modeling/kaggle_comp/.ipynb_checkpoints/simson-fine-tune-checkpoint.ipynb

@@ -0,0 +1,1608 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import PreTrainedModel, AutoConfig, BertModel, BertTokenizerFast, BertConfig, AutoModel, AutoTokenizer\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "import os\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from tqdm import tqdm\n",
+    "import joblib\n",
+    "\n",
+    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('/home/jovyan/simson_training_bolgov/kaggle_comp/train.csv')\n",
+    "\n",
+    "targets = ['Tg', 'FFV', 'Tc', 'Density', 'Rg']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>id</th>\n",
+       "      <th>SMILES</th>\n",
+       "      <th>Tg</th>\n",
+       "      <th>FFV</th>\n",
+       "      <th>Tc</th>\n",
+       "      <th>Density</th>\n",
+       "      <th>Rg</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*/C=C/C1CC(*)C(C#N)(CCC)C1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*CCCCCCCCCCCCNC(=O)c1ccc(C(=O)N*)cc1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*c1ccc(Oc2ccc(C3(c4ccc(Oc5ccc(N6C(=O)c7ccc(Oc8...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1.522414e+09</td>\n",
+       "      <td>*CC(*)c1cc(C(=O)OCCCC)ccc1-c1ccc(OCCCCCCCC)cc1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.385500</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*Oc1ccc(C(c2ccc(Oc3ccc(C(=O)c4c(C(=O)c5ccc(*)c...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16958</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*/C=C/c1ccc2c(c1)Sc1cc(*)ccc1N2c1ccc(OCCCCCCCC...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16959</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*Cc1ccc(CSSS*)cc1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16960</th>\n",
+       "      <td>1.595107e+09</td>\n",
+       "      <td>*Oc1ccc(C2(c3ccc(Oc4nc(*)nc(OC)n4)cc3)CCCCC2)cc1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.363540</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16961</th>\n",
+       "      <td>8.406988e+08</td>\n",
+       "      <td>*CC(*)C(=O)OCC(C)CC</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.372858</td>\n",
+       "      <td>0.221</td>\n",
+       "      <td>0.919641</td>\n",
+       "      <td>13.549867</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16962</th>\n",
+       "      <td>1.563977e+08</td>\n",
+       "      <td>*c1cc(*)cc(-c2nc3ccccc3o2)c1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.390044</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>16963 rows × 7 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 id                                             SMILES  Tg  \\\n",
+       "0               NaN                         */C=C/C1CC(*)C(C#N)(CCC)C1 NaN   \n",
+       "1               NaN               *CCCCCCCCCCCCNC(=O)c1ccc(C(=O)N*)cc1 NaN   \n",
+       "2               NaN  *c1ccc(Oc2ccc(C3(c4ccc(Oc5ccc(N6C(=O)c7ccc(Oc8... NaN   \n",
+       "3      1.522414e+09     *CC(*)c1cc(C(=O)OCCCC)ccc1-c1ccc(OCCCCCCCC)cc1 NaN   \n",
+       "4               NaN  *Oc1ccc(C(c2ccc(Oc3ccc(C(=O)c4c(C(=O)c5ccc(*)c... NaN   \n",
+       "...             ...                                                ...  ..   \n",
+       "16958           NaN  */C=C/c1ccc2c(c1)Sc1cc(*)ccc1N2c1ccc(OCCCCCCCC... NaN   \n",
+       "16959           NaN                                  *Cc1ccc(CSSS*)cc1 NaN   \n",
+       "16960  1.595107e+09   *Oc1ccc(C2(c3ccc(Oc4nc(*)nc(OC)n4)cc3)CCCCC2)cc1 NaN   \n",
+       "16961  8.406988e+08                                *CC(*)C(=O)OCC(C)CC NaN   \n",
+       "16962  1.563977e+08                       *c1cc(*)cc(-c2nc3ccccc3o2)c1 NaN   \n",
+       "\n",
+       "            FFV     Tc   Density         Rg  \n",
+       "0           NaN    NaN       NaN        NaN  \n",
+       "1           NaN    NaN       NaN        NaN  \n",
+       "2           NaN    NaN       NaN        NaN  \n",
+       "3      0.385500    NaN       NaN        NaN  \n",
+       "4           NaN    NaN       NaN        NaN  \n",
+       "...         ...    ...       ...        ...  \n",
+       "16958       NaN    NaN       NaN        NaN  \n",
+       "16959       NaN    NaN       NaN        NaN  \n",
+       "16960  0.363540    NaN       NaN        NaN  \n",
+       "16961  0.372858  0.221  0.919641  13.549867  \n",
+       "16962  0.390044    NaN       NaN        NaN  \n",
+       "\n",
+       "[16963 rows x 7 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "for i in range(1, 5):\n",
+    "    supplement_path = f'/home/jovyan/simson_training_bolgov/kaggle_comp/train_supplement/dataset{i}.csv'\n",
+    "    supplement_ds = pd.read_csv(supplement_path)\n",
+    "\n",
+    "    if 'TC_mean' in supplement_ds.columns:\n",
+    "        supplement_ds = supplement_ds.rename(columns = {'TC_mean': 'Tc'})\n",
+    "\n",
+    "    df = pd.concat([df, supplement_ds], axis=0)\n",
+    "\n",
+    "df = df.sample(frac=1).reset_index(drop=True)\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from rdkit import Chem\n",
+    "import random\n",
+    "from typing import Optional, List, Union\n",
+    "\n",
+    "def augment_smiles_dataset(df: pd.DataFrame,\n",
+    "                               smiles_column: str = 'SMILES',\n",
+    "                               augmentation_strategies: List[str] = ['enumeration', 'kekulize', 'stereo_enum'],\n",
+    "                               n_augmentations: int = 10,\n",
+    "                               preserve_original: bool = True,\n",
+    "                               random_seed: Optional[int] = None) -> pd.DataFrame:\n",
+    "    \"\"\"\n",
+    "    Advanced SMILES augmentation with multiple strategies.\n",
+    "    \n",
+    "    Parameters:\n",
+    "    -----------\n",
+    "    augmentation_strategies : List[str]\n",
+    "        List of augmentation strategies: 'enumeration', 'kekulize', 'stereo_enum'\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    if random_seed is not None:\n",
+    "        random.seed(random_seed)\n",
+    "        np.random.seed(random_seed)\n",
+    "    \n",
+    "    def apply_augmentation_strategy(smiles: str, strategy: str) -> List[str]:\n",
+    "        \"\"\"Apply specific augmentation strategy\"\"\"\n",
+    "        try:\n",
+    "            mol = Chem.MolFromSmiles(smiles)\n",
+    "            if mol is None:\n",
+    "                return [smiles]\n",
+    "            \n",
+    "            augmented = []\n",
+    "            \n",
+    "            if strategy == 'enumeration':\n",
+    "                # Standard SMILES enumeration\n",
+    "                for _ in range(n_augmentations):\n",
+    "                    enum_smiles = Chem.MolToSmiles(mol, \n",
+    "                                                 canonical=False, \n",
+    "                                                 doRandom=True,\n",
+    "                                                 isomericSmiles=True)\n",
+    "                    augmented.append(enum_smiles)\n",
+    "            \n",
+    "            elif strategy == 'kekulize':\n",
+    "                # Kekulization variants\n",
+    "                try:\n",
+    "                    Chem.Kekulize(mol)\n",
+    "                    kek_smiles = Chem.MolToSmiles(mol, kekuleSmiles=True)\n",
+    "                    augmented.append(kek_smiles)\n",
+    "                except:\n",
+    "                    pass\n",
+    "            \n",
+    "            elif strategy == 'stereo_enum':\n",
+    "                # Stereochemistry enumeration\n",
+    "                for _ in range(n_augmentations // 2):\n",
+    "                    # Remove stereochemistry\n",
+    "                    Chem.RemoveStereochemistry(mol)\n",
+    "                    no_stereo = Chem.MolToSmiles(mol)\n",
+    "                    augmented.append(no_stereo)\n",
+    "            \n",
+    "            return list(set(augmented))  # Remove duplicates\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            print(f\"Error in {strategy} for {smiles}: {e}\")\n",
+    "            return [smiles]\n",
+    "    \n",
+    "    augmented_rows = []\n",
+    "    \n",
+    "    for idx, row in tqdm(df.iterrows(), total=len(df)):\n",
+    "        original_smiles = row[smiles_column]\n",
+    "        \n",
+    "        # Add original if requested\n",
+    "        if preserve_original:\n",
+    "            original_row = row.to_dict()\n",
+    "            original_row['augmentation_strategy'] = 'original'\n",
+    "            original_row['is_augmented'] = False\n",
+    "            augmented_rows.append(original_row)\n",
+    "        \n",
+    "        # Apply each augmentation strategy\n",
+    "        for strategy in augmentation_strategies:\n",
+    "            strategy_smiles = apply_augmentation_strategy(original_smiles, strategy)\n",
+    "            \n",
+    "            for aug_smiles in strategy_smiles:\n",
+    "                if aug_smiles != original_smiles:  # Avoid duplicating original\n",
+    "                    new_row = row.to_dict().copy()\n",
+    "                    new_row[smiles_column] = aug_smiles\n",
+    "                    new_row['augmentation_strategy'] = strategy\n",
+    "                    new_row['is_augmented'] = True\n",
+    "                    augmented_rows.append(new_row)\n",
+    "    \n",
+    "    augmented_df = pd.DataFrame(augmented_rows)\n",
+    "    augmented_df = augmented_df.reset_index(drop=True)\n",
+    "    \n",
+    "    print(f\"Advanced augmentation completed:\")\n",
+    "    print(f\"Original size: {len(df)}, Augmented size: {len(augmented_df)}\")\n",
+    "    print(f\"Augmentation factor: {len(augmented_df) / len(df):.2f}x\")\n",
+    "    \n",
+    "    return augmented_df.reset_index(drop=True)\n",
+    "\n",
+    "def create_splits(df):\n",
+    "    length = len(df)\n",
+    "    train_length = int(0.85 * length)\n",
+    "    train = df.loc[:train_length]\n",
+    "    test = df.loc[train_length:]\n",
+    "    return train, test\n",
+    "\n",
+    "train, test = create_splits(df)\n",
+    "\n",
+    "train = train.reset_index(drop=True)\n",
+    "test = test.reset_index(drop=True)\n",
+    "#train = augment_smiles_dataset(train)\n",
+    "#test = augment_smiles_dataset(test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scalers = []\n",
+    "\n",
+    "for target in targets:\n",
+    "    target_scaler = StandardScaler()\n",
+    "    train[target] = target_scaler.fit_transform(train[target].to_numpy().reshape(-1, 1))\n",
+    "    test[target] = target_scaler.transform(test[target].to_numpy().reshape(-1, 1))\n",
+    "    \n",
+    "    scalers.append(target_scaler)\n",
+    "\n",
+    "smiles_train = train['SMILES']\n",
+    "smiles_test = test['SMILES']\n",
+    "\n",
+    "labels_train = train[targets].values\n",
+    "labels_test = test[targets].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['target_scalers.pkl']"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "joblib.dump(scalers, 'target_scalers.pkl')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_273264/2507782815.py:68: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+      "  simson_params = torch.load('/home/jovyan/simson_training_bolgov/kaggle_comp/simson_polymer_1m_uncompiled.pth')\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import mean_absolute_error\n",
+    "from transformers import AutoTokenizer, BertModel\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from transformers.activations import ACT2FN\n",
+    "\n",
+    "def global_ap(x):\n",
+    "    return torch.mean(x.view(x.size(0), x.size(1), -1), dim=1)\n",
+    "\n",
+    "class SimSonEncoder(nn.Module):\n",
+    "    def __init__(self, config: BertConfig, max_len: int, dropout: float = 0.1):\n",
+    "        super(SimSonEncoder, self).__init__()\n",
+    "        self.config = config\n",
+    "        self.max_len = max_len\n",
+    "\n",
+    "        self.bert = BertModel(config, add_pooling_layer=False)\n",
+    "\n",
+    "        self.linear = nn.Linear(config.hidden_size, max_len)\n",
+    "        self.dropout = nn.Dropout(dropout)\n",
+    "\n",
+    "    def forward(self, input_ids, attention_mask=None):\n",
+    "        if attention_mask is None:\n",
+    "            attention_mask = input_ids.ne(0)\n",
+    "            \n",
+    "        outputs = self.bert(\n",
+    "            input_ids=input_ids,\n",
+    "            attention_mask=attention_mask\n",
+    "        )\n",
+    "\n",
+    "        hidden_states = outputs.last_hidden_state\n",
+    "        \n",
+    "        hidden_states = self.dropout(hidden_states)\n",
+    "        \n",
+    "        pooled = global_ap(hidden_states)\n",
+    "        \n",
+    "        out = self.linear(pooled)\n",
+    "        \n",
+    "        return out\n",
+    "\n",
+    "\n",
+    "class SimSonClassifier(nn.Module):\n",
+    "    def __init__(self, encoder: SimSonEncoder, num_labels: int, dropout=0.1):\n",
+    "        super(SimSonClassifier, self).__init__()\n",
+    "        self.encoder = encoder\n",
+    "        self.clf = nn.Linear(encoder.max_len, num_labels)\n",
+    "        self.relu = nn.ReLU()\n",
+    "        self.dropout = nn.Dropout(dropout)\n",
+    "\n",
+    "    def forward(self, input_ids, attention_mask=None, labels=None):\n",
+    "        x = self.encoder(input_ids, attention_mask)\n",
+    "        x = self.relu(self.dropout(x))\n",
+    "        x = self.clf(x)\n",
+    "        return x\n",
+    "\n",
+    "tokenizer_path = 'DeepChem/ChemBERTa-77M-MTR'\n",
+    "tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)\n",
+    "\n",
+    "# Only the hidden size is slightly larger, everything else is the same\n",
+    "config = BertConfig(\n",
+    "        vocab_size=tokenizer.vocab_size,\n",
+    "        hidden_size=768,\n",
+    "        num_hidden_layers=4,\n",
+    "        num_attention_heads=12,\n",
+    "        intermediate_size=2048,\n",
+    "        max_position_embeddings=512\n",
+    "    )\n",
+    "\n",
+    "simson_params = torch.load('/home/jovyan/simson_training_bolgov/kaggle_comp/simson_polymer_1m_uncompiled.pth')\n",
+    "\n",
+    "backbone = SimSonEncoder(config=config, max_len=512)\n",
+    "backbone.load_state_dict(simson_params)\n",
+    "\n",
+    "model = SimSonClassifier(encoder=backbone, num_labels=len(targets))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "from torch.utils.data import Dataset\n",
+    "\n",
+    "\n",
+    "class SMILESDataset(Dataset):\n",
+    "    def __init__(self, smiles_list, labels, tokenizer, max_length=256):\n",
+    "        self.smiles_list = smiles_list\n",
+    "        self.labels = labels  # Shape: (num_samples, 5) - already scaled\n",
+    "        self.tokenizer = tokenizer\n",
+    "        self.max_length = max_length\n",
+    "        \n",
+    "        # Create mask for valid (non-NaN) labels\n",
+    "        self.label_masks = ~np.isnan(self.labels)  # True where label is valid\n",
+    "        \n",
+    "        # Replace NaNs with 0 for safe tensor conversion (mask will handle exclusion)\n",
+    "        self.labels = np.nan_to_num(self.labels, nan=0.0)\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.smiles_list)\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        smiles = self.tokenizer.cls_token + self.smiles_list[idx]\n",
+    "        \n",
+    "        # Tokenize the SMILES string\n",
+    "        encoding = self.tokenizer(\n",
+    "            smiles,\n",
+    "            truncation=True,\n",
+    "            padding='max_length',\n",
+    "            max_length=self.max_length,\n",
+    "            return_tensors='pt'\n",
+    "        )\n",
+    "        \n",
+    "        return {\n",
+    "            'input_ids': encoding['input_ids'].flatten(),\n",
+    "            'attention_mask': encoding['attention_mask'].flatten(),\n",
+    "            'labels': torch.tensor(self.labels[idx], dtype=torch.float32),\n",
+    "            'label_mask': torch.tensor(self.label_masks[idx], dtype=torch.float32)\n",
+    "        }\n",
+    "    \n",
+    "    def get_label_statistics(self):\n",
+    "        \"\"\"Return statistics about label availability for 5 labels\"\"\"\n",
+    "        label_counts = self.label_masks.sum(axis=0)\n",
+    "        total_samples = len(self.smiles_list)\n",
+    "        \n",
+    "        stats = {\n",
+    "            'total_samples': total_samples,\n",
+    "            'label_0_count': label_counts[0],\n",
+    "            'label_1_count': label_counts[1],\n",
+    "            'label_2_count': label_counts[2],\n",
+    "            'label_3_count': label_counts[3],\n",
+    "            'label_4_count': label_counts[4],\n",
+    "            'label_0_ratio': label_counts[0] / total_samples,\n",
+    "            'label_1_ratio': label_counts[1] / total_samples,\n",
+    "            'label_2_ratio': label_counts[2] / total_samples,\n",
+    "            'label_3_ratio': label_counts[3] / total_samples,\n",
+    "            'label_4_ratio': label_counts[4] / total_samples,\n",
+    "            'all_labels_count': (self.label_masks.sum(axis=1) == 5).sum(),\n",
+    "            'partial_labels_count': ((self.label_masks.sum(axis=1) > 0) & (self.label_masks.sum(axis=1) < 5)).sum(),\n",
+    "            'no_labels_count': (self.label_masks.sum(axis=1) == 0).sum()\n",
+    "        }\n",
+    "        \n",
+    "        return stats\n",
+    "\n",
+    "def calculate_weighted_loss(predictions, labels, label_mask, label_weights):\n",
+    "    \"\"\"\n",
+    "    Calculate weighted loss for five labels with masking\n",
+    "    \n",
+    "    Args:\n",
+    "        predictions: Model outputs (batch_size, 5)\n",
+    "        labels: Ground truth labels (batch_size, 5)\n",
+    "        label_mask: Mask for valid labels (batch_size, 5)\n",
+    "        label_weights: Weights for each label (5,)\n",
+    "    \"\"\"\n",
+    "    loss_fn = nn.MSELoss(reduction='none')\n",
+    "    \n",
+    "    # Calculate per-sample, per-label losses\n",
+    "    losses = loss_fn(predictions, labels)  # Shape: (batch_size, 5)\n",
+    "    \n",
+    "    # Apply masking to exclude NaN labels\n",
+    "    valid_mask = label_mask.bool()\n",
+    "    masked_losses = losses * valid_mask.float()\n",
+    "    \n",
+    "    # Apply label-specific weights\n",
+    "    weighted_losses = masked_losses * label_weights.unsqueeze(0)  # Broadcast weights\n",
+    "    \n",
+    "    # Calculate final loss (only over valid predictions)\n",
+    "    total_loss = weighted_losses.sum()\n",
+    "    total_valid = valid_mask.sum()\n",
+    "    \n",
+    "    return total_loss / total_valid if total_valid > 0 else torch.tensor(0.0, device=predictions.device, requires_grad=True)\n",
+    "\n",
+    "def compute_label_weights(dataset):\n",
+    "    \"\"\"\n",
+    "    Compute inverse frequency weights based on label availability\n",
+    "    \n",
+    "    Args:\n",
+    "        dataset: SMILESDataset instance\n",
+    "    \n",
+    "    Returns:\n",
+    "        torch.Tensor: Normalized weights for each label\n",
+    "    \"\"\"\n",
+    "    # Get label counts from dataset\n",
+    "    label_counts = dataset.label_masks.sum(axis=0)  # Count valid samples per label\n",
+    "    total_samples = len(dataset)\n",
+    "    \n",
+    "    # Inverse frequency weighting\n",
+    "    weights = total_samples / (5 * label_counts)  # 5 is the number of labels\n",
+    "    \n",
+    "    # Normalize weights so they sum to number of labels (5)\n",
+    "    weights = weights / weights.sum() * 5\n",
+    "    \n",
+    "    return torch.tensor(weights, dtype=torch.float32)\n",
+    "\n",
+    "def calculate_true_loss(predictions, labels, label_mask, scalers=None):\n",
+    "    \"\"\"\n",
+    "    Calculate unscaled MAE loss for monitoring using separate scalers for each label\n",
+    "    \n",
+    "    Args:\n",
+    "        predictions (torch.Tensor): Model outputs of shape (batch_size, 5).\n",
+    "        labels (torch.Tensor): Ground truth labels of shape (batch_size, 5).\n",
+    "        label_mask (torch.Tensor): Boolean mask for valid labels of shape (batch_size, 5).\n",
+    "        scalers: List of scaler objects, one for each label\n",
+    "    \n",
+    "    Returns:\n",
+    "        float: Average MAE across all valid samples\n",
+    "    \"\"\"\n",
+    "    # Detach tensors from the computation graph and move to CPU\n",
+    "    predictions_np = predictions.cpu().detach().numpy()\n",
+    "    labels_np = labels.cpu().numpy()\n",
+    "    label_mask_np = label_mask.cpu().numpy().astype(bool)\n",
+    "    \n",
+    "    total_mae = 0\n",
+    "    total_samples = 0\n",
+    "    \n",
+    "    for label_idx in range(5):\n",
+    "        # Get valid samples for this label\n",
+    "        valid_mask = label_mask_np[:, label_idx]\n",
+    "        \n",
+    "        if valid_mask.any():\n",
+    "            valid_preds = predictions_np[valid_mask, label_idx].reshape(-1, 1)\n",
+    "            valid_labels = labels_np[valid_mask, label_idx].reshape(-1, 1)\n",
+    "            \n",
+    "            if scalers is not None:\n",
+    "                # Unscale using the corresponding scaler for this label\n",
+    "                unscaled_preds = scalers[label_idx].inverse_transform(valid_preds).flatten()\n",
+    "                unscaled_labels = scalers[label_idx].inverse_transform(valid_labels).flatten()\n",
+    "            else:\n",
+    "                unscaled_preds = valid_preds.flatten()\n",
+    "                unscaled_labels = valid_labels.flatten()\n",
+    "            \n",
+    "            # Calculate MAE for this label\n",
+    "            mae = np.mean(np.abs(unscaled_preds - unscaled_labels))\n",
+    "            total_mae += mae * len(unscaled_preds)\n",
+    "            total_samples += len(unscaled_preds)\n",
+    "    \n",
+    "    return total_mae / total_samples if total_samples > 0 else 0.0\n",
+    "\n",
+    "def calculate_individual_label_losses(predictions, labels, label_mask, scalers=None):\n",
+    "    \"\"\"\n",
+    "    Calculate unscaled MAE loss for each individual label\n",
+    "    \n",
+    "    Args:\n",
+    "        predictions (torch.Tensor): Model outputs of shape (batch_size, 5).\n",
+    "        labels (torch.Tensor): Ground truth labels of shape (batch_size, 5).\n",
+    "        label_mask (torch.Tensor): Boolean mask for valid labels of shape (batch_size, 5).\n",
+    "        scalers: List of scaler objects, one for each label\n",
+    "    \n",
+    "    Returns:\n",
+    "        dict: Dictionary with MAE for each label\n",
+    "    \"\"\"\n",
+    "    # Detach tensors from the computation graph and move to CPU\n",
+    "    predictions_np = predictions.cpu().detach().numpy()\n",
+    "    labels_np = labels.cpu().numpy()\n",
+    "    label_mask_np = label_mask.cpu().numpy().astype(bool)\n",
+    "    \n",
+    "    individual_losses = {}\n",
+    "    \n",
+    "    for label_idx in range(5):\n",
+    "        # Get valid samples for this label\n",
+    "        valid_mask = label_mask_np[:, label_idx]\n",
+    "        \n",
+    "        if valid_mask.any():\n",
+    "            valid_preds = predictions_np[valid_mask, label_idx].reshape(-1, 1)\n",
+    "            valid_labels = labels_np[valid_mask, label_idx].reshape(-1, 1)\n",
+    "            \n",
+    "            if scalers is not None:\n",
+    "                # Unscale using the corresponding scaler for this label\n",
+    "                unscaled_preds = scalers[label_idx].inverse_transform(valid_preds).flatten()\n",
+    "                unscaled_labels = scalers[label_idx].inverse_transform(valid_labels).flatten()\n",
+    "            else:\n",
+    "                unscaled_preds = valid_preds.flatten()\n",
+    "                unscaled_labels = valid_labels.flatten()\n",
+    "            \n",
+    "            # Calculate MAE for this label\n",
+    "            mae = np.mean(np.abs(unscaled_preds - unscaled_labels))\n",
+    "            individual_losses[f'label_{label_idx}'] = mae\n",
+    "        else:\n",
+    "            individual_losses[f'label_{label_idx}'] = None  # No valid samples for this label\n",
+    "    \n",
+    "    return individual_losses\n",
+    "\n",
+    "\n",
+    "def train_model(model, train_dataloader, val_dataloader, label_weights, \n",
+    "                scalers=None, num_epochs=10, learning_rate=2e-5, device='cuda', \n",
+    "                patience=3, validation_steps=500):\n",
+    "    \"\"\"\n",
+    "    Train model with weighted loss for five labels with step-based validation\n",
+    "    \n",
+    "    Args:\n",
+    "        model: CustomModel instance (should output 5 labels)\n",
+    "        train_dataloader: Training data loader\n",
+    "        val_dataloader: Validation data loader  \n",
+    "        label_weights: Tensor with weights for each label\n",
+    "        scalers: List of scalers for unscaled loss monitoring\n",
+    "        num_epochs: Number of training epochs\n",
+    "        learning_rate: Learning rate\n",
+    "        device: Training device\n",
+    "        patience: Early stopping patience (in validation steps)\n",
+    "        validation_steps: Perform validation every N training steps\n",
+    "    \"\"\"\n",
+    "    model.to(device)\n",
+    "    label_weights = label_weights.to(device)\n",
+    "    \n",
+    "    optimizer = AdamW(model.parameters(), lr=learning_rate, weight_decay=0.01)\n",
+    "    total_steps = len(train_dataloader) * num_epochs\n",
+    "    scheduler = LinearLR(optimizer, start_factor=1.0, end_factor=0.1, total_iters=total_steps)\n",
+    "    \n",
+    "    train_losses = []\n",
+    "    val_losses = []\n",
+    "    \n",
+    "    # Early stopping initialization\n",
+    "    best_val_loss = float('inf')\n",
+    "    steps_no_improve = 0\n",
+    "    best_model_state = None\n",
+    "    \n",
+    "    # Training tracking\n",
+    "    global_step = 0\n",
+    "    running_train_loss = 0\n",
+    "    running_true_train_loss = 0\n",
+    "    train_steps_count = 0\n",
+    "    \n",
+    "    print(f\"Label weights: {label_weights.cpu().numpy()}\")\n",
+    "    print(f\"Validation will be performed every {validation_steps} steps\")\n",
+    "    \n",
+    "    model.train()\n",
+    "    \n",
+    "    for epoch in range(num_epochs):\n",
+    "        print(f\"\\nEpoch {epoch + 1}/{num_epochs}\")\n",
+    "        \n",
+    "        train_progress = tqdm(train_dataloader, desc=\"Training\", leave=False)\n",
+    "        \n",
+    "        for batch_idx, batch in enumerate(train_progress):\n",
+    "            with torch.autocast(dtype=torch.float16, device_type=\"cuda\"):\n",
+    "                input_ids = batch['input_ids'].to(device)\n",
+    "                attention_mask = batch['attention_mask'].to(device)\n",
+    "                labels = batch['labels'].to(device)\n",
+    "                label_mask = batch['label_mask'].to(device)\n",
+    "                \n",
+    "                optimizer.zero_grad()\n",
+    "                \n",
+    "                # Model forward pass\n",
+    "                outputs = model(\n",
+    "                    input_ids=input_ids,\n",
+    "                    attention_mask=attention_mask,\n",
+    "                )\n",
+    "                \n",
+    "                # Calculate weighted loss\n",
+    "                loss = calculate_weighted_loss(outputs, labels, label_mask, label_weights)\n",
+    "                \n",
+    "                # Calculate true loss for monitoring\n",
+    "                true_loss = calculate_true_loss(outputs, labels, label_mask, scalers)\n",
+    "            \n",
+    "            # Accumulate losses for averaging\n",
+    "            running_train_loss += loss.item()\n",
+    "            running_true_train_loss += true_loss\n",
+    "            train_steps_count += 1\n",
+    "            \n",
+    "            loss.backward()\n",
+    "            \n",
+    "            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
+    "            \n",
+    "            optimizer.step()\n",
+    "            scheduler.step()\n",
+    "            \n",
+    "            global_step += 1\n",
+    "            \n",
+    "            train_progress.set_postfix({\n",
+    "                'step': global_step,\n",
+    "                'loss': f'{loss.item():.4f}',\n",
+    "                'true_loss': f'{true_loss:.4f}',\n",
+    "                'lr': f'{scheduler.get_last_lr()[0]:.2e}'\n",
+    "            })\n",
+    "            \n",
+    "            # Perform validation every validation_steps\n",
+    "            if global_step % validation_steps == 0:\n",
+    "                # Calculate average training losses since last validation\n",
+    "                avg_train_loss = running_train_loss / train_steps_count\n",
+    "                avg_true_train_loss = running_true_train_loss / train_steps_count\n",
+    "                \n",
+    "                train_losses.append(avg_train_loss)\n",
+    "                \n",
+    "                # Reset running averages\n",
+    "                running_train_loss = 0\n",
+    "                running_true_train_loss = 0\n",
+    "                train_steps_count = 0\n",
+    "                \n",
+    "                # Validation\n",
+    "                model.eval()\n",
+    "                total_val_loss = 0\n",
+    "                total_true_val_loss = 0\n",
+    "                val_batches = 0\n",
+    "                \n",
+    "                # Track individual label losses across all validation batches\n",
+    "                accumulated_individual_losses = {f'label_{i}': [] for i in range(5)}\n",
+    "\n",
+    "                with torch.no_grad():\n",
+    "                    for val_batch in val_dataloader:\n",
+    "                        with torch.autocast(dtype=torch.float16, device_type=\"cuda\"):\n",
+    "                            input_ids = val_batch['input_ids'].to(device)\n",
+    "                            attention_mask = val_batch['attention_mask'].to(device)\n",
+    "                            labels = val_batch['labels'].to(device)\n",
+    "                            label_mask = val_batch['label_mask'].to(device)\n",
+    "                            \n",
+    "                            outputs = model(\n",
+    "                                input_ids=input_ids,\n",
+    "                                attention_mask=attention_mask,\n",
+    "                            )\n",
+    "                            \n",
+    "                            val_loss = calculate_weighted_loss(outputs, labels, label_mask, label_weights)\n",
+    "                            val_true_loss = calculate_true_loss(outputs, labels, label_mask, scalers)\n",
+    "                            \n",
+    "                            # Calculate individual label losses for this batch\n",
+    "                            individual_losses = calculate_individual_label_losses(outputs, labels, label_mask, scalers)\n",
+    "                            \n",
+    "                            # Accumulate individual losses\n",
+    "                            for label_key, loss_value in individual_losses.items():\n",
+    "                                if loss_value is not None:\n",
+    "                                    accumulated_individual_losses[label_key].append(loss_value)\n",
+    "\n",
+    "                        total_val_loss += val_loss.item()\n",
+    "                        total_true_val_loss += val_true_loss\n",
+    "                        val_batches += 1\n",
+    "                    \n",
+    "                avg_val_loss = total_val_loss / val_batches\n",
+    "                avg_val_true_loss = total_true_val_loss / val_batches\n",
+    "                val_losses.append(avg_val_loss)\n",
+    "                \n",
+    "                # Calculate average individual label losses\n",
+    "                avg_individual_losses = {}\n",
+    "                for label_key, losses in accumulated_individual_losses.items():\n",
+    "                    if losses:\n",
+    "                        avg_individual_losses[label_key] = np.mean(losses)\n",
+    "                    else:\n",
+    "                        avg_individual_losses[label_key] = None\n",
+    "                \n",
+    "                # Print validation results with individual label losses\n",
+    "                print(f\"\\nStep {global_step} | Train Loss: {avg_train_loss:.4f} | Val Loss: {avg_val_loss:.4f} | True train loss: {avg_true_train_loss:.4f} | True val loss: {avg_val_true_loss:.4f}\")\n",
+    "                print(\"Individual label losses (unscaled):\")\n",
+    "                for i in range(5):\n",
+    "                    label_key = f'label_{i}'\n",
+    "                    if avg_individual_losses[label_key] is not None:\n",
+    "                        print(f\"  Label {i}: {avg_individual_losses[label_key]:.4f}\")\n",
+    "                    else:\n",
+    "                        print(f\"  Label {i}: No valid samples\")\n",
+    "                \n",
+    "                # Early stopping check and best model saving\n",
+    "                if avg_val_loss < best_val_loss:\n",
+    "                    best_val_loss = avg_val_loss\n",
+    "                    steps_no_improve = 0\n",
+    "                    best_model_state = model.state_dict().copy()\n",
+    "                    print(f\"New best validation loss: {best_val_loss:.4f}\")\n",
+    "                else:\n",
+    "                    steps_no_improve += 1\n",
+    "                    if steps_no_improve >= patience:\n",
+    "                        print(f\"Early stopping triggered after {global_step} steps ({steps_no_improve} validation steps without improvement).\")\n",
+    "                        # Load best model and return\n",
+    "                        if best_model_state is not None:\n",
+    "                            model.load_state_dict(best_model_state)\n",
+    "                            print(f\"Loaded best model with validation loss: {best_val_loss:.4f}\")\n",
+    "                        return train_losses, val_losses, best_val_loss\n",
+    "                \n",
+    "                model.train()\n",
+    "    \n",
+    "    # Handle any remaining training loss that hasn't been validated\n",
+    "    if train_steps_count > 0:\n",
+    "        avg_train_loss = running_train_loss / train_steps_count\n",
+    "        train_losses.append(avg_train_loss)\n",
+    "    \n",
+    "    # Load the best model state before returning\n",
+    "    if best_model_state is not None:\n",
+    "        model.load_state_dict(best_model_state)\n",
+    "        print(f\"Loaded best model with validation loss: {best_val_loss:.4f}\")\n",
+    "    \n",
+    "    return train_losses, val_losses, best_val_loss\n",
+    "\n",
+    "def run_training(smiles_train, smiles_test, labels_train, labels_test, \n",
+    "                model, tokenizer, scalers, num_epochs=5, learning_rate=1e-5, \n",
+    "                batch_size=256, validation_steps=500):\n",
+    "    \"\"\"\n",
+    "    Complete training pipeline for five labels with step-based validation\n",
+    "    \n",
+    "    Args:\n",
+    "        smiles_train, smiles_test: Lists of SMILES strings\n",
+    "        labels_train, labels_test: numpy arrays of shape (num_samples, 5) - ALREADY SCALED\n",
+    "        model: CustomModel instance (configured for 5 outputs)\n",
+    "        tokenizer: Tokenizer instance\n",
+    "        scalers: List of 5 scalers, one for each label (for inverse transform only)\n",
+    "        num_epochs: Number of training epochs\n",
+    "        learning_rate: Learning rate\n",
+    "        batch_size: Batch size for training\n",
+    "        validation_steps: Perform validation every N training steps\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    print(\"Setting up datasets for five-label training (labels assumed pre-scaled)\")\n",
+    "    \n",
+    "    # Create datasets - no scaling performed here\n",
+    "    train_dataset = SMILESDataset(smiles_train, labels_train, tokenizer)\n",
+    "    val_dataset = SMILESDataset(smiles_test, labels_test, tokenizer)\n",
+    "    \n",
+    "    # Print dataset statistics\n",
+    "    train_stats = train_dataset.get_label_statistics()\n",
+    "    val_stats = val_dataset.get_label_statistics()\n",
+    "    \n",
+    "    print(\"Training dataset statistics:\")\n",
+    "    for key, value in train_stats.items():\n",
+    "        print(f\"  {key}: {value}\")\n",
+    "    \n",
+    "    print(\"Validation dataset statistics:\")\n",
+    "    for key, value in val_stats.items():\n",
+    "        print(f\"  {key}: {value}\")\n",
+    "    \n",
+    "    # Compute label weights based on training data\n",
+    "    label_weights = compute_label_weights(train_dataset)\n",
+    "    print(f\"Computed label weights: {label_weights.numpy()}\")\n",
+    "    \n",
+    "    # Create data loaders\n",
+    "    train_dataloader = DataLoader(\n",
+    "        train_dataset,\n",
+    "        batch_size=batch_size,\n",
+    "        shuffle=True,\n",
+    "        num_workers=4,\n",
+    "        pin_memory=True\n",
+    "    )\n",
+    "    \n",
+    "    val_dataloader = DataLoader(\n",
+    "        val_dataset,\n",
+    "        batch_size=batch_size,\n",
+    "        shuffle=False,\n",
+    "        num_workers=4,\n",
+    "        pin_memory=True\n",
+    "    )\n",
+    "    \n",
+    "    # Set device\n",
+    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "    print(f\"Using device: {device}\")\n",
+    "    print(f\"Training steps per epoch: {len(train_dataloader)}\")\n",
+    "    print(f\"Total training steps: {len(train_dataloader) * num_epochs}\")\n",
+    "    \n",
+    "    # Train the model\n",
+    "    train_losses, val_losses, best_val_loss = train_model(\n",
+    "        model=model,\n",
+    "        train_dataloader=train_dataloader,\n",
+    "        val_dataloader=val_dataloader,\n",
+    "        label_weights=label_weights,\n",
+    "        scalers=scalers,  # Still pass scalers for true loss calculation\n",
+    "        num_epochs=num_epochs,\n",
+    "        learning_rate=learning_rate,\n",
+    "        device=device,\n",
+    "        patience=10,\n",
+    "        validation_steps=validation_steps,\n",
+    "    )\n",
+    "    \n",
+    "    print('Training completed.')\n",
+    "    print(f'Number of validation checkpoints: {len(val_losses)}')\n",
+    "    print(f'Final training losses: {train_losses[-5:] if len(train_losses) >= 5 else train_losses}')\n",
+    "    print(f'Best validation loss: {best_val_loss:.4f}')\n",
+    "    \n",
+    "    # Save model\n",
+    "    torch.save(model.state_dict(), '/home/jovyan/simson_training_bolgov/kaggle_comp/checkpoints/simson_clf_kaggle.bin')\n",
+    "    print(\"Model saved successfully!\")\n",
+    "    \n",
+    "    return train_losses, val_losses, best_val_loss\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting up datasets for five-label training (labels assumed pre-scaled)\n",
+      "Training dataset statistics:\n",
+      "  total_samples: 14419\n",
+      "  label_0_count: 472\n",
+      "  label_1_count: 6700\n",
+      "  label_2_count: 1368\n",
+      "  label_3_count: 517\n",
+      "  label_4_count: 519\n",
+      "  label_0_ratio: 0.03273458630973022\n",
+      "  label_1_ratio: 0.46466467854913657\n",
+      "  label_2_ratio: 0.09487481794854012\n",
+      "  label_3_ratio: 0.03585546847909009\n",
+      "  label_4_ratio: 0.035994174353283864\n",
+      "  all_labels_count: 0\n",
+      "  partial_labels_count: 8286\n",
+      "  no_labels_count: 6133\n",
+      "Validation dataset statistics:\n",
+      "  total_samples: 2545\n",
+      "  label_0_count: 86\n",
+      "  label_1_count: 1192\n",
+      "  label_2_count: 243\n",
+      "  label_3_count: 96\n",
+      "  label_4_count: 95\n",
+      "  label_0_ratio: 0.03379174852652259\n",
+      "  label_1_ratio: 0.46836935166994104\n",
+      "  label_2_ratio: 0.09548133595284872\n",
+      "  label_3_ratio: 0.037721021611001965\n",
+      "  label_4_ratio: 0.03732809430255403\n",
+      "  all_labels_count: 0\n",
+      "  partial_labels_count: 1470\n",
+      "  no_labels_count: 1075\n",
+      "Computed label weights: [1.5442214  0.10878694 0.53280157 1.4098115  1.4043787 ]\n",
+      "Using device: cuda\n",
+      "Training steps per epoch: 113\n",
+      "Total training steps: 2260\n",
+      "Label weights: [1.5442214  0.10878694 0.53280157 1.4098115  1.4043787 ]\n",
+      "Validation will be performed every 113 steps\n",
+      "\n",
+      "Epoch 1/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 113 | Train Loss: 0.2634 | Val Loss: 0.2308 | True train loss: 3.6083 | True val loss: 3.8929\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 74.8777\n",
+      "  Label 1: 0.0177\n",
+      "  Label 2: 0.0347\n",
+      "  Label 3: 0.0917\n",
+      "  Label 4: 2.2249\n",
+      "New best validation loss: 0.2308\n",
+      "\n",
+      "Epoch 2/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 226 | Train Loss: 0.2031 | Val Loss: 0.1903 | True train loss: 2.9943 | True val loss: 3.2239\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 60.3146\n",
+      "  Label 1: 0.0170\n",
+      "  Label 2: 0.0394\n",
+      "  Label 3: 0.0517\n",
+      "  Label 4: 2.7417\n",
+      "New best validation loss: 0.1903\n",
+      "\n",
+      "Epoch 3/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 339 | Train Loss: 0.1796 | Val Loss: 0.1766 | True train loss: 2.8803 | True val loss: 3.3839\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 63.8170\n",
+      "  Label 1: 0.0136\n",
+      "  Label 2: 0.0362\n",
+      "  Label 3: 0.0785\n",
+      "  Label 4: 1.9163\n",
+      "New best validation loss: 0.1766\n",
+      "\n",
+      "Epoch 4/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 452 | Train Loss: 0.1538 | Val Loss: 0.1525 | True train loss: 2.6186 | True val loss: 3.2207\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.0257\n",
+      "  Label 1: 0.0142\n",
+      "  Label 2: 0.0347\n",
+      "  Label 3: 0.0523\n",
+      "  Label 4: 2.1894\n",
+      "New best validation loss: 0.1525\n",
+      "\n",
+      "Epoch 5/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 565 | Train Loss: 0.1461 | Val Loss: 0.1432 | True train loss: 2.6254 | True val loss: 3.1313\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 57.6456\n",
+      "  Label 1: 0.0131\n",
+      "  Label 2: 0.0318\n",
+      "  Label 3: 0.0394\n",
+      "  Label 4: 1.9632\n",
+      "New best validation loss: 0.1432\n",
+      "\n",
+      "Epoch 6/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 678 | Train Loss: 0.1344 | Val Loss: 0.1506 | True train loss: 2.4023 | True val loss: 3.0162\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 55.6189\n",
+      "  Label 1: 0.0154\n",
+      "  Label 2: 0.0315\n",
+      "  Label 3: 0.0464\n",
+      "  Label 4: 1.7522\n",
+      "\n",
+      "Epoch 7/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 791 | Train Loss: 0.1240 | Val Loss: 0.1399 | True train loss: 2.2227 | True val loss: 3.3619\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 63.3619\n",
+      "  Label 1: 0.0119\n",
+      "  Label 2: 0.0301\n",
+      "  Label 3: 0.0426\n",
+      "  Label 4: 1.8000\n",
+      "New best validation loss: 0.1399\n",
+      "\n",
+      "Epoch 8/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 904 | Train Loss: 0.1149 | Val Loss: 0.1359 | True train loss: 2.2502 | True val loss: 3.2314\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.6004\n",
+      "  Label 1: 0.0121\n",
+      "  Label 2: 0.0311\n",
+      "  Label 3: 0.0403\n",
+      "  Label 4: 1.7468\n",
+      "New best validation loss: 0.1359\n",
+      "\n",
+      "Epoch 9/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1017 | Train Loss: 0.1094 | Val Loss: 0.1506 | True train loss: 2.2638 | True val loss: 3.4009\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 63.4786\n",
+      "  Label 1: 0.0127\n",
+      "  Label 2: 0.0280\n",
+      "  Label 3: 0.0495\n",
+      "  Label 4: 2.0883\n",
+      "\n",
+      "Epoch 10/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1130 | Train Loss: 0.0963 | Val Loss: 0.1467 | True train loss: 1.9351 | True val loss: 3.3818\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 62.9852\n",
+      "  Label 1: 0.0127\n",
+      "  Label 2: 0.0298\n",
+      "  Label 3: 0.0511\n",
+      "  Label 4: 1.9974\n",
+      "\n",
+      "Epoch 11/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1243 | Train Loss: 0.0957 | Val Loss: 0.1321 | True train loss: 1.9361 | True val loss: 2.9691\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 55.0661\n",
+      "  Label 1: 0.0117\n",
+      "  Label 2: 0.0284\n",
+      "  Label 3: 0.0351\n",
+      "  Label 4: 2.0390\n",
+      "New best validation loss: 0.1321\n",
+      "\n",
+      "Epoch 12/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1356 | Train Loss: 0.0823 | Val Loss: 0.1424 | True train loss: 1.8204 | True val loss: 3.5836\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 67.2052\n",
+      "  Label 1: 0.0123\n",
+      "  Label 2: 0.0262\n",
+      "  Label 3: 0.0391\n",
+      "  Label 4: 1.9690\n",
+      "\n",
+      "Epoch 13/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1469 | Train Loss: 0.0797 | Val Loss: 0.1382 | True train loss: 1.7223 | True val loss: 3.2234\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 59.5507\n",
+      "  Label 1: 0.0118\n",
+      "  Label 2: 0.0282\n",
+      "  Label 3: 0.0381\n",
+      "  Label 4: 1.9066\n",
+      "\n",
+      "Epoch 14/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1582 | Train Loss: 0.0728 | Val Loss: 0.1321 | True train loss: 1.5747 | True val loss: 3.3817\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 63.2403\n",
+      "  Label 1: 0.0115\n",
+      "  Label 2: 0.0262\n",
+      "  Label 3: 0.0339\n",
+      "  Label 4: 1.7621\n",
+      "New best validation loss: 0.1321\n",
+      "\n",
+      "Epoch 15/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1695 | Train Loss: 0.0676 | Val Loss: 0.1437 | True train loss: 1.5251 | True val loss: 3.4306\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 63.7060\n",
+      "  Label 1: 0.0121\n",
+      "  Label 2: 0.0274\n",
+      "  Label 3: 0.0442\n",
+      "  Label 4: 1.9844\n",
+      "\n",
+      "Epoch 16/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1808 | Train Loss: 0.0617 | Val Loss: 0.1494 | True train loss: 1.3651 | True val loss: 3.3514\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.4547\n",
+      "  Label 1: 0.0118\n",
+      "  Label 2: 0.0260\n",
+      "  Label 3: 0.0504\n",
+      "  Label 4: 2.0026\n",
+      "\n",
+      "Epoch 17/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1921 | Train Loss: 0.0580 | Val Loss: 0.1424 | True train loss: 1.3237 | True val loss: 3.3568\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.8486\n",
+      "  Label 1: 0.0116\n",
+      "  Label 2: 0.0252\n",
+      "  Label 3: 0.0430\n",
+      "  Label 4: 1.9207\n",
+      "\n",
+      "Epoch 18/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 2034 | Train Loss: 0.0534 | Val Loss: 0.1376 | True train loss: 1.2378 | True val loss: 3.3407\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.5502\n",
+      "  Label 1: 0.0115\n",
+      "  Label 2: 0.0247\n",
+      "  Label 3: 0.0433\n",
+      "  Label 4: 1.7560\n",
+      "\n",
+      "Epoch 19/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 2147 | Train Loss: 0.0497 | Val Loss: 0.1416 | True train loss: 1.1018 | True val loss: 3.2781\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 59.6542\n",
+      "  Label 1: 0.0115\n",
+      "  Label 2: 0.0251\n",
+      "  Label 3: 0.0438\n",
+      "  Label 4: 1.8405\n",
+      "\n",
+      "Epoch 20/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 2260 | Train Loss: 0.0484 | Val Loss: 0.1329 | True train loss: 1.1016 | True val loss: 3.3233\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.2343\n",
+      "  Label 1: 0.0114\n",
+      "  Label 2: 0.0243\n",
+      "  Label 3: 0.0402\n",
+      "  Label 4: 1.7624\n",
+      "Loaded best model with validation loss: 0.1321\n",
+      "Training completed.\n",
+      "Number of validation checkpoints: 20\n",
+      "Final training losses: [0.061716757780682724, 0.05798421218266002, 0.05344583738628214, 0.04969686268111773, 0.04844354389779336]\n",
+      "Best validation loss: 0.1321\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r"
+     ]
+    },
+    {
+     "ename": "RuntimeError",
+     "evalue": "File /home/jovyan/simson_training_bolgov/kaggle_comp/checkpoints cannot be opened.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mRuntimeError\u001b[39m                              Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[12]\u001b[39m\u001b[32m, line 8\u001b[39m\n\u001b[32m      5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorch\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mutils\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mdata\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m DataLoader\n\u001b[32m      6\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtqdm\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m tqdm\n\u001b[32m----> \u001b[39m\u001b[32m8\u001b[39m train_losses, val_losses, best_loss = \u001b[43mrun_training\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m      9\u001b[39m \u001b[43m     \u001b[49m\u001b[43msmiles_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msmiles_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m     10\u001b[39m \u001b[43m     \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtokenizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscalers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_epochs\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m20\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlearning_rate\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m1e-4\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m128\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalidation_steps\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m113\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m     11\u001b[39m \u001b[43m)\u001b[49m\n",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 480\u001b[39m, in \u001b[36mrun_training\u001b[39m\u001b[34m(smiles_train, smiles_test, labels_train, labels_test, model, tokenizer, scalers, num_epochs, learning_rate, batch_size, validation_steps)\u001b[39m\n\u001b[32m    477\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[33mBest validation loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mbest_val_loss\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m)\n\u001b[32m    479\u001b[39m \u001b[38;5;66;03m# Save model\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m480\u001b[39m \u001b[43mtorch\u001b[49m\u001b[43m.\u001b[49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m.\u001b[49m\u001b[43mstate_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m/home/jovyan/simson_training_bolgov/kaggle_comp/checkpoints\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m    481\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mModel saved successfully!\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m    483\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m train_losses, val_losses, best_val_loss\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/.mlspace/envs/bolgov_simson_training/lib/python3.12/site-packages/torch/serialization.py:849\u001b[39m, in \u001b[36msave\u001b[39m\u001b[34m(obj, f, pickle_module, pickle_protocol, _use_new_zipfile_serialization, _disable_byteorder_record)\u001b[39m\n\u001b[32m    846\u001b[39m _check_save_filelike(f)\n\u001b[32m    848\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m _use_new_zipfile_serialization:\n\u001b[32m--> \u001b[39m\u001b[32m849\u001b[39m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43m_open_zipfile_writer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m opened_zipfile:\n\u001b[32m    850\u001b[39m         _save(\n\u001b[32m    851\u001b[39m             obj,\n\u001b[32m    852\u001b[39m             opened_zipfile,\n\u001b[32m   (...)\u001b[39m\u001b[32m    855\u001b[39m             _disable_byteorder_record,\n\u001b[32m    856\u001b[39m         )\n\u001b[32m    857\u001b[39m         \u001b[38;5;28;01mreturn\u001b[39;00m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/.mlspace/envs/bolgov_simson_training/lib/python3.12/site-packages/torch/serialization.py:716\u001b[39m, in \u001b[36m_open_zipfile_writer\u001b[39m\u001b[34m(name_or_buffer)\u001b[39m\n\u001b[32m    714\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m    715\u001b[39m     container = _open_zipfile_writer_buffer\n\u001b[32m--> \u001b[39m\u001b[32m716\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcontainer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname_or_buffer\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/.mlspace/envs/bolgov_simson_training/lib/python3.12/site-packages/torch/serialization.py:687\u001b[39m, in \u001b[36m_open_zipfile_writer_file.__init__\u001b[39m\u001b[34m(self, name)\u001b[39m\n\u001b[32m    685\u001b[39m     \u001b[38;5;28msuper\u001b[39m().\u001b[34m__init__\u001b[39m(torch._C.PyTorchFileWriter(\u001b[38;5;28mself\u001b[39m.file_stream))\n\u001b[32m    686\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m687\u001b[39m     \u001b[38;5;28msuper\u001b[39m().\u001b[34m__init__\u001b[39m(\u001b[43mtorch\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_C\u001b[49m\u001b[43m.\u001b[49m\u001b[43mPyTorchFileWriter\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m)\n",
+      "\u001b[31mRuntimeError\u001b[39m: File /home/jovyan/simson_training_bolgov/kaggle_comp/checkpoints cannot be opened."
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.optim.lr_scheduler import LinearLR\n",
+    "from torch.utils.data import DataLoader\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "train_losses, val_losses, best_loss = run_training(\n",
+    "     smiles_train, smiles_test, labels_train, labels_test, \n",
+    "     model, tokenizer, scalers, num_epochs=20, learning_rate=1e-4, batch_size=128, validation_steps=113,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kaggle": {
+   "accelerator": "gpu",
+   "dataSources": [
+    {
+     "databundleVersionId": 12966160,
+     "sourceId": 74608,
+     "sourceType": "competition"
+    },
+    {
+     "datasetId": 7678100,
+     "sourceId": 12189904,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7690162,
+     "sourceId": 12207625,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7716502,
+     "sourceId": 12322957,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7801155,
+     "sourceId": 12372847,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7809006,
+     "sourceId": 12525286,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7912957,
+     "sourceId": 12668147,
+     "sourceType": "datasetVersion"
+    }
+   ],
+   "dockerImageVersionId": 31041,
+   "isGpuEnabled": true,
+   "isInternetEnabled": true,
+   "language": "python",
+   "sourceType": "notebook"
+  },
+  "kernelspec": {
+   "display_name": "Python [conda env:.mlspace-bolgov_simson_training]",
+   "language": "python",
+   "name": "conda-env-.mlspace-bolgov_simson_training-py"
+  },
+  "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.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

simson_modeling/kaggle_comp/checkpoints/clf_kaggle.bin

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

simson_modeling/kaggle_comp/sample_submission.csv

@@ -0,0 +1,4 @@
+id,Tg,FFV,Tc,Density,Rg
+1109053969,0,0,0,0,0
+1422188626,0,0,0,0,0
+2032016830,0,0,0,0,0

simson_modeling/kaggle_comp/simson-fine-tune.ipynb

@@ -0,0 +1,1742 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import PreTrainedModel, AutoConfig, BertModel, BertTokenizerFast, BertConfig, AutoModel, AutoTokenizer\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "import os\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from tqdm import tqdm\n",
+    "import joblib\n",
+    "\n",
+    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('/home/jovyan/simson_training_bolgov/kaggle_comp/train.csv')\n",
+    "\n",
+    "targets = ['Tg', 'FFV', 'Tc', 'Density', 'Rg']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>id</th>\n",
+       "      <th>SMILES</th>\n",
+       "      <th>Tg</th>\n",
+       "      <th>FFV</th>\n",
+       "      <th>Tc</th>\n",
+       "      <th>Density</th>\n",
+       "      <th>Rg</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>4.215886e+08</td>\n",
+       "      <td>*C(=O)c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(Oc4ccc(N5...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.376767</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>7.984549e+08</td>\n",
+       "      <td>*c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(N4C(=O)c5ccc(C...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.346993</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*CC/C=C(/*)C</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*CC(*)(C)C(=O)OCCN(CC)c1ccc(/N=N/c2ccc(OC)cc2)...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*Oc1cc(OC(=O)c2ccc(OCC)cc2)c(OC(=O)CCCC(*)=O)c...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16958</th>\n",
+       "      <td>2.389975e+08</td>\n",
+       "      <td>*OC(=O)Oc1ccc(S(=O)(=O)c2ccc(OC(=O)OC3CC4CC(*)...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.339596</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16959</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*c1ccc(Oc2ccc(S(=O)(=O)c3ccc(Oc4ccc(N5C(=O)c6c...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16960</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*OC(F)(F)COC(=O)c1cc(OCCCCC)cc(C(=O)OCC(*)(F)F)c1</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16961</th>\n",
+       "      <td>1.973417e+09</td>\n",
+       "      <td>*C=CC1CC(*)C2C(=O)N(c3ccc(F)cc3)C(=O)C12</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>0.374710</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16962</th>\n",
+       "      <td>NaN</td>\n",
+       "      <td>*/C=C/[Ge](/C=C/[Si](*)(c1ccccc1)c1ccccc1)(c1c...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>16963 rows × 7 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 id                                             SMILES  Tg  \\\n",
+       "0      4.215886e+08  *C(=O)c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(Oc4ccc(N5... NaN   \n",
+       "1      7.984549e+08  *c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(N4C(=O)c5ccc(C... NaN   \n",
+       "2               NaN                                       *CC/C=C(/*)C NaN   \n",
+       "3               NaN  *CC(*)(C)C(=O)OCCN(CC)c1ccc(/N=N/c2ccc(OC)cc2)... NaN   \n",
+       "4               NaN  *Oc1cc(OC(=O)c2ccc(OCC)cc2)c(OC(=O)CCCC(*)=O)c... NaN   \n",
+       "...             ...                                                ...  ..   \n",
+       "16958  2.389975e+08  *OC(=O)Oc1ccc(S(=O)(=O)c2ccc(OC(=O)OC3CC4CC(*)... NaN   \n",
+       "16959           NaN  *c1ccc(Oc2ccc(S(=O)(=O)c3ccc(Oc4ccc(N5C(=O)c6c... NaN   \n",
+       "16960           NaN  *OC(F)(F)COC(=O)c1cc(OCCCCC)cc(C(=O)OCC(*)(F)F)c1 NaN   \n",
+       "16961  1.973417e+09           *C=CC1CC(*)C2C(=O)N(c3ccc(F)cc3)C(=O)C12 NaN   \n",
+       "16962           NaN  */C=C/[Ge](/C=C/[Si](*)(c1ccccc1)c1ccccc1)(c1c... NaN   \n",
+       "\n",
+       "            FFV  Tc  Density  Rg  \n",
+       "0      0.376767 NaN      NaN NaN  \n",
+       "1      0.346993 NaN      NaN NaN  \n",
+       "2           NaN NaN      NaN NaN  \n",
+       "3           NaN NaN      NaN NaN  \n",
+       "4           NaN NaN      NaN NaN  \n",
+       "...         ...  ..      ...  ..  \n",
+       "16958  0.339596 NaN      NaN NaN  \n",
+       "16959       NaN NaN      NaN NaN  \n",
+       "16960       NaN NaN      NaN NaN  \n",
+       "16961  0.374710 NaN      NaN NaN  \n",
+       "16962       NaN NaN      NaN NaN  \n",
+       "\n",
+       "[16963 rows x 7 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "for i in range(1, 5):\n",
+    "    supplement_path = f'/home/jovyan/simson_training_bolgov/kaggle_comp/train_supplement/dataset{i}.csv'\n",
+    "    supplement_ds = pd.read_csv(supplement_path)\n",
+    "\n",
+    "    if 'TC_mean' in supplement_ds.columns:\n",
+    "        supplement_ds = supplement_ds.rename(columns = {'TC_mean': 'Tc'})\n",
+    "\n",
+    "    df = pd.concat([df, supplement_ds], axis=0)\n",
+    "\n",
+    "df = df.sample(frac=1).reset_index(drop=True)\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████| 14419/14419 [00:43<00:00, 328.78it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Advanced augmentation completed:\n",
+      "Original size: 14419, Augmented size: 168551\n",
+      "Augmentation factor: 11.69x\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████████████████████████████████| 2545/2545 [00:07<00:00, 333.57it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Advanced augmentation completed:\n",
+      "Original size: 2545, Augmented size: 29716\n",
+      "Augmentation factor: 11.68x\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from rdkit import Chem\n",
+    "import random\n",
+    "from typing import Optional, List, Union\n",
+    "\n",
+    "def augment_smiles_dataset(df: pd.DataFrame,\n",
+    "                               smiles_column: str = 'SMILES',\n",
+    "                               augmentation_strategies: List[str] = ['enumeration', 'kekulize', 'stereo_enum'],\n",
+    "                               n_augmentations: int = 10,\n",
+    "                               preserve_original: bool = True,\n",
+    "                               random_seed: Optional[int] = None) -> pd.DataFrame:\n",
+    "    \"\"\"\n",
+    "    Advanced SMILES augmentation with multiple strategies.\n",
+    "    \n",
+    "    Parameters:\n",
+    "    -----------\n",
+    "    augmentation_strategies : List[str]\n",
+    "        List of augmentation strategies: 'enumeration', 'kekulize', 'stereo_enum'\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    if random_seed is not None:\n",
+    "        random.seed(random_seed)\n",
+    "        np.random.seed(random_seed)\n",
+    "    \n",
+    "    def apply_augmentation_strategy(smiles: str, strategy: str) -> List[str]:\n",
+    "        \"\"\"Apply specific augmentation strategy\"\"\"\n",
+    "        try:\n",
+    "            mol = Chem.MolFromSmiles(smiles)\n",
+    "            if mol is None:\n",
+    "                return [smiles]\n",
+    "            \n",
+    "            augmented = []\n",
+    "            \n",
+    "            if strategy == 'enumeration':\n",
+    "                # Standard SMILES enumeration\n",
+    "                for _ in range(n_augmentations):\n",
+    "                    enum_smiles = Chem.MolToSmiles(mol, \n",
+    "                                                 canonical=False, \n",
+    "                                                 doRandom=True,\n",
+    "                                                 isomericSmiles=True)\n",
+    "                    augmented.append(enum_smiles)\n",
+    "            \n",
+    "            elif strategy == 'kekulize':\n",
+    "                # Kekulization variants\n",
+    "                try:\n",
+    "                    Chem.Kekulize(mol)\n",
+    "                    kek_smiles = Chem.MolToSmiles(mol, kekuleSmiles=True)\n",
+    "                    augmented.append(kek_smiles)\n",
+    "                except:\n",
+    "                    pass\n",
+    "            \n",
+    "            elif strategy == 'stereo_enum':\n",
+    "                # Stereochemistry enumeration\n",
+    "                for _ in range(n_augmentations // 2):\n",
+    "                    # Remove stereochemistry\n",
+    "                    Chem.RemoveStereochemistry(mol)\n",
+    "                    no_stereo = Chem.MolToSmiles(mol)\n",
+    "                    augmented.append(no_stereo)\n",
+    "            \n",
+    "            return list(set(augmented))  # Remove duplicates\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            print(f\"Error in {strategy} for {smiles}: {e}\")\n",
+    "            return [smiles]\n",
+    "    \n",
+    "    augmented_rows = []\n",
+    "    \n",
+    "    for idx, row in tqdm(df.iterrows(), total=len(df)):\n",
+    "        original_smiles = row[smiles_column]\n",
+    "        \n",
+    "        # Add original if requested\n",
+    "        if preserve_original:\n",
+    "            original_row = row.to_dict()\n",
+    "            original_row['augmentation_strategy'] = 'original'\n",
+    "            original_row['is_augmented'] = False\n",
+    "            augmented_rows.append(original_row)\n",
+    "        \n",
+    "        # Apply each augmentation strategy\n",
+    "        for strategy in augmentation_strategies:\n",
+    "            strategy_smiles = apply_augmentation_strategy(original_smiles, strategy)\n",
+    "            \n",
+    "            for aug_smiles in strategy_smiles:\n",
+    "                if aug_smiles != original_smiles:  # Avoid duplicating original\n",
+    "                    new_row = row.to_dict().copy()\n",
+    "                    new_row[smiles_column] = aug_smiles\n",
+    "                    new_row['augmentation_strategy'] = strategy\n",
+    "                    new_row['is_augmented'] = True\n",
+    "                    augmented_rows.append(new_row)\n",
+    "    \n",
+    "    augmented_df = pd.DataFrame(augmented_rows)\n",
+    "    augmented_df = augmented_df.reset_index(drop=True)\n",
+    "    \n",
+    "    print(f\"Advanced augmentation completed:\")\n",
+    "    print(f\"Original size: {len(df)}, Augmented size: {len(augmented_df)}\")\n",
+    "    print(f\"Augmentation factor: {len(augmented_df) / len(df):.2f}x\")\n",
+    "    \n",
+    "    return augmented_df.reset_index(drop=True)\n",
+    "\n",
+    "def create_splits(df):\n",
+    "    length = len(df)\n",
+    "    train_length = int(0.85 * length)\n",
+    "    train = df.loc[:train_length]\n",
+    "    test = df.loc[train_length:]\n",
+    "    return train, test\n",
+    "\n",
+    "train, test = create_splits(df)\n",
+    "\n",
+    "train = train.reset_index(drop=True)\n",
+    "test = test.reset_index(drop=True)\n",
+    "\n",
+    "train = augment_smiles_dataset(train)\n",
+    "test = augment_smiles_dataset(test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scalers = []\n",
+    "\n",
+    "for target in targets:\n",
+    "    target_scaler = StandardScaler()\n",
+    "    train[target] = target_scaler.fit_transform(train[target].to_numpy().reshape(-1, 1))\n",
+    "    test[target] = target_scaler.transform(test[target].to_numpy().reshape(-1, 1))\n",
+    "    \n",
+    "    scalers.append(target_scaler)\n",
+    "\n",
+    "smiles_train = train['SMILES']\n",
+    "smiles_test = test['SMILES']\n",
+    "\n",
+    "labels_train = train[targets].values\n",
+    "labels_test = test[targets].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['target_scalers.pkl']"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "joblib.dump(scalers, 'target_scalers.pkl')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_279009/2507782815.py:68: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+      "  simson_params = torch.load('/home/jovyan/simson_training_bolgov/kaggle_comp/simson_polymer_1m_uncompiled.pth')\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import mean_absolute_error\n",
+    "from transformers import AutoTokenizer, BertModel\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from transformers.activations import ACT2FN\n",
+    "\n",
+    "def global_ap(x):\n",
+    "    return torch.mean(x.view(x.size(0), x.size(1), -1), dim=1)\n",
+    "\n",
+    "class SimSonEncoder(nn.Module):\n",
+    "    def __init__(self, config: BertConfig, max_len: int, dropout: float = 0.1):\n",
+    "        super(SimSonEncoder, self).__init__()\n",
+    "        self.config = config\n",
+    "        self.max_len = max_len\n",
+    "\n",
+    "        self.bert = BertModel(config, add_pooling_layer=False)\n",
+    "\n",
+    "        self.linear = nn.Linear(config.hidden_size, max_len)\n",
+    "        self.dropout = nn.Dropout(dropout)\n",
+    "\n",
+    "    def forward(self, input_ids, attention_mask=None):\n",
+    "        if attention_mask is None:\n",
+    "            attention_mask = input_ids.ne(0)\n",
+    "            \n",
+    "        outputs = self.bert(\n",
+    "            input_ids=input_ids,\n",
+    "            attention_mask=attention_mask\n",
+    "        )\n",
+    "\n",
+    "        hidden_states = outputs.last_hidden_state\n",
+    "        \n",
+    "        hidden_states = self.dropout(hidden_states)\n",
+    "        \n",
+    "        pooled = global_ap(hidden_states)\n",
+    "        \n",
+    "        out = self.linear(pooled)\n",
+    "        \n",
+    "        return out\n",
+    "\n",
+    "\n",
+    "class SimSonClassifier(nn.Module):\n",
+    "    def __init__(self, encoder: SimSonEncoder, num_labels: int, dropout=0.1):\n",
+    "        super(SimSonClassifier, self).__init__()\n",
+    "        self.encoder = encoder\n",
+    "        self.clf = nn.Linear(encoder.max_len, num_labels)\n",
+    "        self.relu = nn.ReLU()\n",
+    "        self.dropout = nn.Dropout(dropout)\n",
+    "\n",
+    "    def forward(self, input_ids, attention_mask=None, labels=None):\n",
+    "        x = self.encoder(input_ids, attention_mask)\n",
+    "        x = self.relu(self.dropout(x))\n",
+    "        x = self.clf(x)\n",
+    "        return x\n",
+    "\n",
+    "tokenizer_path = 'DeepChem/ChemBERTa-77M-MTR'\n",
+    "tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)\n",
+    "\n",
+    "# Only the hidden size is slightly larger, everything else is the same\n",
+    "config = BertConfig(\n",
+    "        vocab_size=tokenizer.vocab_size,\n",
+    "        hidden_size=768,\n",
+    "        num_hidden_layers=4,\n",
+    "        num_attention_heads=12,\n",
+    "        intermediate_size=2048,\n",
+    "        max_position_embeddings=512\n",
+    "    )\n",
+    "\n",
+    "simson_params = torch.load('/home/jovyan/simson_training_bolgov/kaggle_comp/simson_polymer_1m_uncompiled.pth')\n",
+    "\n",
+    "backbone = SimSonEncoder(config=config, max_len=512)\n",
+    "backbone.load_state_dict(simson_params)\n",
+    "\n",
+    "model = SimSonClassifier(encoder=backbone, num_labels=len(targets))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "from torch.utils.data import Dataset, Sampler, DataLoader\n",
+    "\n",
+    "\n",
+    "class SMILESDataset(Dataset):\n",
+    "    def __init__(self, smiles_list, labels, tokenizer, max_length=256):\n",
+    "        self.smiles_list = smiles_list\n",
+    "        self.labels = labels  # Shape: (num_samples, 5) - already scaled\n",
+    "        self.tokenizer = tokenizer\n",
+    "        self.max_length = max_length\n",
+    "        \n",
+    "        # Create mask for valid (non-NaN) labels\n",
+    "        self.label_masks = ~np.isnan(self.labels)  # True where label is valid\n",
+    "        \n",
+    "        # Replace NaNs with 0 for safe tensor conversion (mask will handle exclusion)\n",
+    "        self.labels = np.nan_to_num(self.labels, nan=0.0)\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.smiles_list)\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        smiles = self.tokenizer.cls_token + self.smiles_list[idx]\n",
+    "        \n",
+    "        # Tokenize the SMILES string\n",
+    "        encoding = self.tokenizer(\n",
+    "            smiles,\n",
+    "            truncation=True,\n",
+    "            padding='max_length',\n",
+    "            max_length=self.max_length,\n",
+    "            return_tensors='pt'\n",
+    "        )\n",
+    "        \n",
+    "        return {\n",
+    "            'input_ids': encoding['input_ids'].flatten(),\n",
+    "            'attention_mask': encoding['attention_mask'].flatten(),\n",
+    "            'labels': torch.tensor(self.labels[idx], dtype=torch.float32),\n",
+    "            'label_mask': torch.tensor(self.label_masks[idx], dtype=torch.float32)\n",
+    "        }\n",
+    "    \n",
+    "    def get_label_statistics(self):\n",
+    "        \"\"\"Return statistics about label availability for 5 labels\"\"\"\n",
+    "        label_counts = self.label_masks.sum(axis=0)\n",
+    "        total_samples = len(self.smiles_list)\n",
+    "        \n",
+    "        stats = {\n",
+    "            'total_samples': total_samples,\n",
+    "            'label_0_count': label_counts[0],\n",
+    "            'label_1_count': label_counts[1],\n",
+    "            'label_2_count': label_counts[2],\n",
+    "            'label_3_count': label_counts[3],\n",
+    "            'label_4_count': label_counts[4],\n",
+    "            'label_0_ratio': label_counts[0] / total_samples,\n",
+    "            'label_1_ratio': label_counts[1] / total_samples,\n",
+    "            'label_2_ratio': label_counts[2] / total_samples,\n",
+    "            'label_3_ratio': label_counts[3] / total_samples,\n",
+    "            'label_4_ratio': label_counts[4] / total_samples,\n",
+    "            'all_labels_count': (self.label_masks.sum(axis=1) == 5).sum(),\n",
+    "            'partial_labels_count': ((self.label_masks.sum(axis=1) > 0) & (self.label_masks.sum(axis=1) < 5)).sum(),\n",
+    "            'no_labels_count': (self.label_masks.sum(axis=1) == 0).sum()\n",
+    "        }\n",
+    "        \n",
+    "        return stats\n",
+    "\n",
+    "\n",
+    "class UnderrepresentedLabelSampler(Sampler):\n",
+    "    \"\"\"\n",
+    "    Custom sampler that gives higher sampling probability to samples containing under-represented labels.\n",
+    "    This ensures each batch contains a good mix of samples with different label availability patterns.\n",
+    "    \"\"\"\n",
+    "    def __init__(self, dataset, num_labels=5, underrep_boost=2.0):\n",
+    "        \"\"\"\n",
+    "        Args:\n",
+    "            dataset: SMILESDataset instance\n",
+    "            num_labels: Number of labels (5)\n",
+    "            underrep_boost: Multiplier to boost probability of under-represented labels\n",
+    "        \"\"\"\n",
+    "        self.dataset = dataset\n",
+    "        self.num_samples = len(dataset)\n",
+    "        self.num_labels = num_labels\n",
+    "        self.underrep_boost = underrep_boost\n",
+    "        \n",
+    "        # Calculate label frequencies\n",
+    "        label_counts = dataset.label_masks.sum(axis=0)  # Count valid samples per label\n",
+    "        total_samples = self.num_samples\n",
+    "        \n",
+    "        # Label frequencies (proportion of samples with each label)\n",
+    "        label_freq = label_counts / total_samples\n",
+    "        \n",
+    "        # Inverse frequency weights (higher for under-represented labels)\n",
+    "        # Add small epsilon to avoid division by zero\n",
+    "        self.label_weights = 1.0 / (label_freq + 1e-6)\n",
+    "        \n",
+    "        # Apply boost to under-represented labels\n",
+    "        # Labels with frequency < median get boosted\n",
+    "        median_freq = np.median(label_freq)\n",
+    "        underrep_mask = label_freq < median_freq\n",
+    "        self.label_weights[underrep_mask] *= self.underrep_boost\n",
+    "        \n",
+    "        # Calculate sample weights based on which labels are present\n",
+    "        sample_weights = []\n",
+    "        for i in range(self.num_samples):\n",
+    "            mask = dataset.label_masks[i]  # Boolean mask for present labels\n",
+    "            if mask.sum() > 0:\n",
+    "                # Weight is average of present labels' weights\n",
+    "                weights = self.label_weights[mask]\n",
+    "                sample_weight = weights.mean()\n",
+    "            else:\n",
+    "                # If no labels present, give minimal weight\n",
+    "                sample_weight = 0.1\n",
+    "            sample_weights.append(sample_weight)\n",
+    "        \n",
+    "        self.sample_weights = torch.tensor(sample_weights, dtype=torch.double)\n",
+    "        \n",
+    "        # Print sampling statistics\n",
+    "        print(f\"Label frequencies: {label_freq}\")\n",
+    "        print(f\"Label weights: {self.label_weights}\")\n",
+    "        print(f\"Under-represented labels (< median freq {median_freq:.3f}): {np.where(underrep_mask)[0]}\")\n",
+    "        print(f\"Sample weight range: [{self.sample_weights.min():.3f}, {self.sample_weights.max():.3f}]\")\n",
+    "    \n",
+    "    def __iter__(self):\n",
+    "        # Sample with replacement according to calculated weights\n",
+    "        indices = torch.multinomial(self.sample_weights, self.num_samples, replacement=True)\n",
+    "        return iter(indices.tolist())\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return self.num_samples\n",
+    "\n",
+    "\n",
+    "def calculate_unweighted_loss(predictions, labels, label_mask):\n",
+    "    \"\"\"\n",
+    "    Calculate simple unweighted MSE loss with masking (no label weights)\n",
+    "    \n",
+    "    Args:\n",
+    "        predictions: Model outputs (batch_size, 5)\n",
+    "        labels: Ground truth labels (batch_size, 5)\n",
+    "        label_mask: Mask for valid labels (batch_size, 5)\n",
+    "    \"\"\"\n",
+    "    loss_fn = nn.MSELoss(reduction='none')\n",
+    "    \n",
+    "    # Calculate per-sample, per-label losses\n",
+    "    losses = loss_fn(predictions, labels)  # Shape: (batch_size, 5)\n",
+    "    \n",
+    "    # Apply masking to exclude NaN labels\n",
+    "    valid_mask = label_mask.bool()\n",
+    "    masked_losses = losses * valid_mask.float()\n",
+    "    \n",
+    "    # Calculate final loss (only over valid predictions)\n",
+    "    total_loss = masked_losses.sum()\n",
+    "    total_valid = valid_mask.sum()\n",
+    "    \n",
+    "    return total_loss / total_valid if total_valid > 0 else torch.tensor(0.0, device=predictions.device, requires_grad=True)\n",
+    "\n",
+    "\n",
+    "def calculate_true_loss(predictions, labels, label_mask, scalers=None):\n",
+    "    \"\"\"\n",
+    "    Calculate unscaled MAE loss for monitoring using separate scalers for each label\n",
+    "    \n",
+    "    Args:\n",
+    "        predictions (torch.Tensor): Model outputs of shape (batch_size, 5).\n",
+    "        labels (torch.Tensor): Ground truth labels of shape (batch_size, 5).\n",
+    "        label_mask (torch.Tensor): Boolean mask for valid labels of shape (batch_size, 5).\n",
+    "        scalers: List of scaler objects, one for each label\n",
+    "    \n",
+    "    Returns:\n",
+    "        float: Average MAE across all valid samples\n",
+    "    \"\"\"\n",
+    "    # Detach tensors from the computation graph and move to CPU\n",
+    "    predictions_np = predictions.cpu().detach().numpy()\n",
+    "    labels_np = labels.cpu().numpy()\n",
+    "    label_mask_np = label_mask.cpu().numpy().astype(bool)\n",
+    "    \n",
+    "    total_mae = 0\n",
+    "    total_samples = 0\n",
+    "    \n",
+    "    for label_idx in range(5):\n",
+    "        # Get valid samples for this label\n",
+    "        valid_mask = label_mask_np[:, label_idx]\n",
+    "        \n",
+    "        if valid_mask.any():\n",
+    "            valid_preds = predictions_np[valid_mask, label_idx].reshape(-1, 1)\n",
+    "            valid_labels = labels_np[valid_mask, label_idx].reshape(-1, 1)\n",
+    "            \n",
+    "            if scalers is not None:\n",
+    "                # Unscale using the corresponding scaler for this label\n",
+    "                unscaled_preds = scalers[label_idx].inverse_transform(valid_preds).flatten()\n",
+    "                unscaled_labels = scalers[label_idx].inverse_transform(valid_labels).flatten()\n",
+    "            else:\n",
+    "                unscaled_preds = valid_preds.flatten()\n",
+    "                unscaled_labels = valid_labels.flatten()\n",
+    "            \n",
+    "            # Calculate MAE for this label\n",
+    "            mae = np.mean(np.abs(unscaled_preds - unscaled_labels))\n",
+    "            total_mae += mae * len(unscaled_preds)\n",
+    "            total_samples += len(unscaled_preds)\n",
+    "    \n",
+    "    return total_mae / total_samples if total_samples > 0 else 0.0\n",
+    "\n",
+    "\n",
+    "def calculate_individual_label_losses(predictions, labels, label_mask, scalers=None):\n",
+    "    \"\"\"\n",
+    "    Calculate unscaled MAE loss for each individual label\n",
+    "    \n",
+    "    Args:\n",
+    "        predictions (torch.Tensor): Model outputs of shape (batch_size, 5).\n",
+    "        labels (torch.Tensor): Ground truth labels of shape (batch_size, 5).\n",
+    "        label_mask (torch.Tensor): Boolean mask for valid labels of shape (batch_size, 5).\n",
+    "        scalers: List of scaler objects, one for each label\n",
+    "    \n",
+    "    Returns:\n",
+    "        dict: Dictionary with MAE for each label\n",
+    "    \"\"\"\n",
+    "    # Detach tensors from the computation graph and move to CPU\n",
+    "    predictions_np = predictions.cpu().detach().numpy()\n",
+    "    labels_np = labels.cpu().numpy()\n",
+    "    label_mask_np = label_mask.cpu().numpy().astype(bool)\n",
+    "    \n",
+    "    individual_losses = {}\n",
+    "    \n",
+    "    for label_idx in range(5):\n",
+    "        # Get valid samples for this label\n",
+    "        valid_mask = label_mask_np[:, label_idx]\n",
+    "        \n",
+    "        if valid_mask.any():\n",
+    "            valid_preds = predictions_np[valid_mask, label_idx].reshape(-1, 1)\n",
+    "            valid_labels = labels_np[valid_mask, label_idx].reshape(-1, 1)\n",
+    "            \n",
+    "            if scalers is not None:\n",
+    "                # Unscale using the corresponding scaler for this label\n",
+    "                unscaled_preds = scalers[label_idx].inverse_transform(valid_preds).flatten()\n",
+    "                unscaled_labels = scalers[label_idx].inverse_transform(valid_labels).flatten()\n",
+    "            else:\n",
+    "                unscaled_preds = valid_preds.flatten()\n",
+    "                unscaled_labels = valid_labels.flatten()\n",
+    "            \n",
+    "            # Calculate MAE for this label\n",
+    "            mae = np.mean(np.abs(unscaled_preds - unscaled_labels))\n",
+    "            individual_losses[f'label_{label_idx}'] = mae\n",
+    "        else:\n",
+    "            individual_losses[f'label_{label_idx}'] = None  # No valid samples for this label\n",
+    "    \n",
+    "    return individual_losses\n",
+    "\n",
+    "\n",
+    "def analyze_batch_composition(dataloader, num_batches=5):\n",
+    "    \"\"\"\n",
+    "    Analyze the composition of batches to see label distribution\n",
+    "    \"\"\"\n",
+    "    print(\"Analyzing batch composition:\")\n",
+    "    \n",
+    "    for batch_idx, batch in enumerate(dataloader):\n",
+    "        if batch_idx >= num_batches:\n",
+    "            break\n",
+    "            \n",
+    "        label_mask = batch['label_mask'].numpy()\n",
+    "        \n",
+    "        # Count samples with each label in this batch\n",
+    "        label_counts = label_mask.sum(axis=0)\n",
+    "        batch_size = label_mask.shape[0]\n",
+    "        \n",
+    "        print(f\"Batch {batch_idx + 1}: Size={batch_size}\")\n",
+    "        for i in range(5):\n",
+    "            print(f\"  Label {i}: {label_counts[i]}/{batch_size} ({label_counts[i]/batch_size:.2%})\")\n",
+    "        print()\n",
+    "\n",
+    "\n",
+    "def train_model(model, train_dataloader, val_dataloader, \n",
+    "                scalers=None, num_epochs=10, learning_rate=2e-5, device='cuda', \n",
+    "                patience=3, validation_steps=500):\n",
+    "    \"\"\"\n",
+    "    Train model with unweighted loss and custom sampler for five labels\n",
+    "    \n",
+    "    Args:\n",
+    "        model: CustomModel instance (should output 5 labels)\n",
+    "        train_dataloader: Training data loader with custom sampler\n",
+    "        val_dataloader: Validation data loader  \n",
+    "        scalers: List of scalers for unscaled loss monitoring\n",
+    "        num_epochs: Number of training epochs\n",
+    "        learning_rate: Learning rate\n",
+    "        device: Training device\n",
+    "        patience: Early stopping patience (in validation steps)\n",
+    "        validation_steps: Perform validation every N training steps\n",
+    "    \"\"\"\n",
+    "    model.to(device)\n",
+    "    \n",
+    "    optimizer = AdamW(model.parameters(), lr=learning_rate, weight_decay=0.01)\n",
+    "    total_steps = len(train_dataloader) * num_epochs\n",
+    "    scheduler = LinearLR(optimizer, start_factor=1.0, end_factor=0.1, total_iters=total_steps)\n",
+    "    \n",
+    "    train_losses = []\n",
+    "    val_losses = []\n",
+    "    \n",
+    "    # Early stopping initialization\n",
+    "    best_val_loss = float('inf')\n",
+    "    steps_no_improve = 0\n",
+    "    best_model_state = None\n",
+    "    \n",
+    "    # Training tracking\n",
+    "    global_step = 0\n",
+    "    running_train_loss = 0\n",
+    "    running_true_train_loss = 0\n",
+    "    train_steps_count = 0\n",
+    "    \n",
+    "    print(f\"Training with custom sampler (no label weights)\")\n",
+    "    print(f\"Validation will be performed every {validation_steps} steps\")\n",
+    "    \n",
+    "    model.train()\n",
+    "    \n",
+    "    for epoch in range(num_epochs):\n",
+    "        print(f\"\\nEpoch {epoch + 1}/{num_epochs}\")\n",
+    "        \n",
+    "        train_progress = tqdm(train_dataloader, desc=\"Training\", leave=False)\n",
+    "        \n",
+    "        for batch_idx, batch in enumerate(train_progress):\n",
+    "            with torch.autocast(dtype=torch.float16, device_type=\"cuda\"):\n",
+    "                input_ids = batch['input_ids'].to(device)\n",
+    "                attention_mask = batch['attention_mask'].to(device)\n",
+    "                labels = batch['labels'].to(device)\n",
+    "                label_mask = batch['label_mask'].to(device)\n",
+    "                \n",
+    "                optimizer.zero_grad()\n",
+    "                \n",
+    "                # Model forward pass\n",
+    "                outputs = model(\n",
+    "                    input_ids=input_ids,\n",
+    "                    attention_mask=attention_mask,\n",
+    "                )\n",
+    "                \n",
+    "                # Calculate unweighted loss (sampler handles the balancing)\n",
+    "                loss = calculate_unweighted_loss(outputs, labels, label_mask)\n",
+    "                \n",
+    "                # Calculate true loss for monitoring\n",
+    "                true_loss = calculate_true_loss(outputs, labels, label_mask, scalers)\n",
+    "            \n",
+    "            # Accumulate losses for averaging\n",
+    "            running_train_loss += loss.item()\n",
+    "            running_true_train_loss += true_loss\n",
+    "            train_steps_count += 1\n",
+    "            \n",
+    "            loss.backward()\n",
+    "            \n",
+    "            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
+    "            \n",
+    "            optimizer.step()\n",
+    "            scheduler.step()\n",
+    "            \n",
+    "            global_step += 1\n",
+    "            \n",
+    "            train_progress.set_postfix({\n",
+    "                'step': global_step,\n",
+    "                'loss': f'{loss.item():.4f}',\n",
+    "                'true_loss': f'{true_loss:.4f}',\n",
+    "                'lr': f'{scheduler.get_last_lr()[0]:.2e}'\n",
+    "            })\n",
+    "            \n",
+    "            # Perform validation every validation_steps\n",
+    "            if global_step % validation_steps == 0:\n",
+    "                # Calculate average training losses since last validation\n",
+    "                avg_train_loss = running_train_loss / train_steps_count\n",
+    "                avg_true_train_loss = running_true_train_loss / train_steps_count\n",
+    "                \n",
+    "                train_losses.append(avg_train_loss)\n",
+    "                \n",
+    "                # Reset running averages\n",
+    "                running_train_loss = 0\n",
+    "                running_true_train_loss = 0\n",
+    "                train_steps_count = 0\n",
+    "                \n",
+    "                # Validation\n",
+    "                model.eval()\n",
+    "                total_val_loss = 0\n",
+    "                total_true_val_loss = 0\n",
+    "                val_batches = 0\n",
+    "                \n",
+    "                # Track individual label losses across all validation batches\n",
+    "                accumulated_individual_losses = {f'label_{i}': [] for i in range(5)}\n",
+    "\n",
+    "                with torch.no_grad():\n",
+    "                    for val_batch in val_dataloader:\n",
+    "                        with torch.autocast(dtype=torch.float16, device_type=\"cuda\"):\n",
+    "                            input_ids = val_batch['input_ids'].to(device)\n",
+    "                            attention_mask = val_batch['attention_mask'].to(device)\n",
+    "                            labels = val_batch['labels'].to(device)\n",
+    "                            label_mask = val_batch['label_mask'].to(device)\n",
+    "                            \n",
+    "                            outputs = model(\n",
+    "                                input_ids=input_ids,\n",
+    "                                attention_mask=attention_mask,\n",
+    "                            )\n",
+    "                            \n",
+    "                            val_loss = calculate_unweighted_loss(outputs, labels, label_mask)\n",
+    "                            val_true_loss = calculate_true_loss(outputs, labels, label_mask, scalers)\n",
+    "                            \n",
+    "                            # Calculate individual label losses for this batch\n",
+    "                            individual_losses = calculate_individual_label_losses(outputs, labels, label_mask, scalers)\n",
+    "                            \n",
+    "                            # Accumulate individual losses\n",
+    "                            for label_key, loss_value in individual_losses.items():\n",
+    "                                if loss_value is not None:\n",
+    "                                    accumulated_individual_losses[label_key].append(loss_value)\n",
+    "\n",
+    "                        total_val_loss += val_loss.item()\n",
+    "                        total_true_val_loss += val_true_loss\n",
+    "                        val_batches += 1\n",
+    "                    \n",
+    "                avg_val_loss = total_val_loss / val_batches\n",
+    "                avg_val_true_loss = total_true_val_loss / val_batches\n",
+    "                val_losses.append(avg_val_loss)\n",
+    "                \n",
+    "                # Calculate average individual label losses\n",
+    "                avg_individual_losses = {}\n",
+    "                for label_key, losses in accumulated_individual_losses.items():\n",
+    "                    if losses:\n",
+    "                        avg_individual_losses[label_key] = np.mean(losses)\n",
+    "                    else:\n",
+    "                        avg_individual_losses[label_key] = None\n",
+    "                \n",
+    "                # Print validation results with individual label losses\n",
+    "                print(f\"\\nStep {global_step} | Train Loss: {avg_train_loss:.4f} | Val Loss: {avg_val_loss:.4f} | True train loss: {avg_true_train_loss:.4f} | True val loss: {avg_val_true_loss:.4f}\")\n",
+    "                print(\"Individual label losses (unscaled):\")\n",
+    "                for i in range(5):\n",
+    "                    label_key = f'label_{i}'\n",
+    "                    if avg_individual_losses[label_key] is not None:\n",
+    "                        print(f\"  Label {i}: {avg_individual_losses[label_key]:.4f}\")\n",
+    "                    else:\n",
+    "                        print(f\"  Label {i}: No valid samples\")\n",
+    "                \n",
+    "                # Early stopping check and best model saving\n",
+    "                if avg_val_loss < best_val_loss:\n",
+    "                    best_val_loss = avg_val_loss\n",
+    "                    steps_no_improve = 0\n",
+    "                    best_model_state = model.state_dict().copy()\n",
+    "                    print(f\"New best validation loss: {best_val_loss:.4f}\")\n",
+    "                else:\n",
+    "                    steps_no_improve += 1\n",
+    "                    if steps_no_improve >= patience:\n",
+    "                        print(f\"Early stopping triggered after {global_step} steps ({steps_no_improve} validation steps without improvement).\")\n",
+    "                        # Load best model and return\n",
+    "                        if best_model_state is not None:\n",
+    "                            model.load_state_dict(best_model_state)\n",
+    "                            print(f\"Loaded best model with validation loss: {best_val_loss:.4f}\")\n",
+    "                        return train_losses, val_losses, best_val_loss\n",
+    "                \n",
+    "                model.train()\n",
+    "    \n",
+    "    # Handle any remaining training loss that hasn't been validated\n",
+    "    if train_steps_count > 0:\n",
+    "        avg_train_loss = running_train_loss / train_steps_count\n",
+    "        train_losses.append(avg_train_loss)\n",
+    "    \n",
+    "    # Load the best model state before returning\n",
+    "    if best_model_state is not None:\n",
+    "        model.load_state_dict(best_model_state)\n",
+    "        print(f\"Loaded best model with validation loss: {best_val_loss:.4f}\")\n",
+    "    \n",
+    "    return train_losses, val_losses, best_val_loss\n",
+    "\n",
+    "\n",
+    "def run_training(smiles_train, smiles_test, labels_train, labels_test, \n",
+    "                model, tokenizer, scalers, num_epochs=5, learning_rate=1e-5, \n",
+    "                batch_size=256, validation_steps=500, underrep_boost=2.0):\n",
+    "    \"\"\"\n",
+    "    Complete training pipeline for five labels with custom sampler\n",
+    "    \n",
+    "    Args:\n",
+    "        smiles_train, smiles_test: Lists of SMILES strings\n",
+    "        labels_train, labels_test: numpy arrays of shape (num_samples, 5) - ALREADY SCALED\n",
+    "        model: CustomModel instance (configured for 5 outputs)\n",
+    "        tokenizer: Tokenizer instance\n",
+    "        scalers: List of 5 scalers, one for each label (for inverse transform only)\n",
+    "        num_epochs: Number of training epochs\n",
+    "        learning_rate: Learning rate\n",
+    "        batch_size: Batch size for training\n",
+    "        validation_steps: Perform validation every N training steps\n",
+    "        underrep_boost: Boost factor for under-represented labels in sampler\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    print(\"Setting up datasets for five-label training with custom sampler\")\n",
+    "    \n",
+    "    # Create datasets - no scaling performed here\n",
+    "    train_dataset = SMILESDataset(smiles_train, labels_train, tokenizer)\n",
+    "    val_dataset = SMILESDataset(smiles_test, labels_test, tokenizer)\n",
+    "    \n",
+    "    # Print dataset statistics\n",
+    "    train_stats = train_dataset.get_label_statistics()\n",
+    "    val_stats = val_dataset.get_label_statistics()\n",
+    "    \n",
+    "    print(\"Training dataset statistics:\")\n",
+    "    for key, value in train_stats.items():\n",
+    "        print(f\"  {key}: {value}\")\n",
+    "    \n",
+    "    print(\"Validation dataset statistics:\")\n",
+    "    for key, value in val_stats.items():\n",
+    "        print(f\"  {key}: {value}\")\n",
+    "    \n",
+    "    # Create custom sampler for balanced training\n",
+    "    train_sampler = UnderrepresentedLabelSampler(\n",
+    "        train_dataset, \n",
+    "        num_labels=5, \n",
+    "        underrep_boost=underrep_boost\n",
+    "    )\n",
+    "    \n",
+    "    # Create data loaders\n",
+    "    train_dataloader = DataLoader(\n",
+    "        train_dataset,\n",
+    "        batch_size=batch_size,\n",
+    "        sampler=None,  # Use custom sampler instead of shuffle=True\n",
+    "        num_workers=4,\n",
+    "        pin_memory=True\n",
+    "    )\n",
+    "    \n",
+    "    val_dataloader = DataLoader(\n",
+    "        val_dataset,\n",
+    "        batch_size=batch_size,\n",
+    "        shuffle=False,\n",
+    "        num_workers=4,\n",
+    "        pin_memory=True\n",
+    "    )\n",
+    "    \n",
+    "    # Analyze batch composition to verify sampler effectiveness\n",
+    "    print(\"\\n\" + \"=\"*50)\n",
+    "    #analyze_batch_composition(train_dataloader, num_batches=3)\n",
+    "    print(\"=\"*50)\n",
+    "    \n",
+    "    # Set device\n",
+    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "    print(f\"Using device: {device}\")\n",
+    "    print(f\"Training steps per epoch: {len(train_dataloader)}\")\n",
+    "    print(f\"Total training steps: {len(train_dataloader) * num_epochs}\")\n",
+    "    \n",
+    "    # Train the model\n",
+    "    train_losses, val_losses, best_val_loss = train_model(\n",
+    "        model=model,\n",
+    "        train_dataloader=train_dataloader,\n",
+    "        val_dataloader=val_dataloader,\n",
+    "        scalers=scalers,\n",
+    "        num_epochs=num_epochs,\n",
+    "        learning_rate=learning_rate,\n",
+    "        device=device,\n",
+    "        patience=10,\n",
+    "        validation_steps=validation_steps,\n",
+    "    )\n",
+    "    \n",
+    "    print('Training completed.')\n",
+    "    print(f'Number of validation checkpoints: {len(val_losses)}')\n",
+    "    print(f'Final training losses: {train_losses[-5:] if len(train_losses) >= 5 else train_losses}')\n",
+    "    print(f'Best validation loss: {best_val_loss:.4f}')\n",
+    "    \n",
+    "    # Save model\n",
+    "    torch.save(model.state_dict(), '/home/jovyan/simson_training_bolgov/kaggle_comp/checkpoints/clf_kaggle.bin')\n",
+    "    print(\"Model saved successfully!\")\n",
+    "    \n",
+    "    return train_losses, val_losses, best_val_loss\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting up datasets for five-label training with custom sampler\n",
+      "Training dataset statistics:\n",
+      "  total_samples: 168551\n",
+      "  label_0_count: 5446\n",
+      "  label_1_count: 78850\n",
+      "  label_2_count: 14846\n",
+      "  label_3_count: 5779\n",
+      "  label_4_count: 5782\n",
+      "  label_0_ratio: 0.032310695279173664\n",
+      "  label_1_ratio: 0.46781092962960763\n",
+      "  label_2_ratio: 0.08808016564719284\n",
+      "  label_3_ratio: 0.03428635843157264\n",
+      "  label_4_ratio: 0.03430415719871137\n",
+      "  all_labels_count: 0\n",
+      "  partial_labels_count: 96406\n",
+      "  no_labels_count: 72145\n",
+      "Validation dataset statistics:\n",
+      "  total_samples: 29716\n",
+      "  label_0_count: 947\n",
+      "  label_1_count: 13878\n",
+      "  label_2_count: 2764\n",
+      "  label_3_count: 957\n",
+      "  label_4_count: 955\n",
+      "  label_0_ratio: 0.03186835374882218\n",
+      "  label_1_ratio: 0.4670211333961502\n",
+      "  label_2_ratio: 0.0930138645847355\n",
+      "  label_3_ratio: 0.03220487279580024\n",
+      "  label_4_ratio: 0.03213756898640463\n",
+      "  all_labels_count: 0\n",
+      "  partial_labels_count: 17016\n",
+      "  no_labels_count: 12700\n",
+      "Label frequencies: [0.0323107  0.46781093 0.08808017 0.03428636 0.03430416]\n",
+      "Label weights: [61.89709276  2.13761116 11.35316492 58.33053614 29.15013606]\n",
+      "Under-represented labels (< median freq 0.034): [0 3]\n",
+      "Sample weight range: [0.100, 61.897]\n",
+      "\n",
+      "==================================================\n",
+      "==================================================\n",
+      "Using device: cuda\n",
+      "Training steps per epoch: 1317\n",
+      "Total training steps: 26340\n",
+      "Training with custom sampler (no label weights)\n",
+      "Validation will be performed every 1316 steps\n",
+      "\n",
+      "Epoch 1/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 1316 | Train Loss: 0.6250 | Val Loss: 0.4127 | True train loss: 3.9762 | True val loss: 3.8368\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 76.7992\n",
+      "  Label 1: 0.0127\n",
+      "  Label 2: 0.0372\n",
+      "  Label 3: 0.0987\n",
+      "  Label 4: 3.3515\n",
+      "New best validation loss: 0.4127\n",
+      "\n",
+      "Epoch 2/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 2632 | Train Loss: 0.5464 | Val Loss: 0.4244 | True train loss: 3.5447 | True val loss: 3.4895\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 68.7228\n",
+      "  Label 1: 0.0130\n",
+      "  Label 2: 0.0379\n",
+      "  Label 3: 0.0952\n",
+      "  Label 4: 3.8732\n",
+      "\n",
+      "Epoch 3/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|█| 1317/1317 [01:22<00:00,  1.88it/s, step=3951, loss=0.6545, tru"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 3948 | Train Loss: 0.5242 | Val Loss: 0.4007 | True train loss: 3.4056 | True val loss: 3.2830\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 63.8785\n",
+      "  Label 1: 0.0130\n",
+      "  Label 2: 0.0362\n",
+      "  Label 3: 0.1013\n",
+      "  Label 4: 3.4475\n",
+      "New best validation loss: 0.4007\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 4/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|▉| 1315/1317 [01:22<00:01,  1.87it/s, step=5267, loss=0.3083, tru"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 5264 | Train Loss: 0.5011 | Val Loss: 0.3770 | True train loss: 3.1835 | True val loss: 3.3785\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 66.0959\n",
+      "  Label 1: 0.0124\n",
+      "  Label 2: 0.0382\n",
+      "  Label 3: 0.0951\n",
+      "  Label 4: 3.3052\n",
+      "New best validation loss: 0.3770\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 5/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|▉| 1315/1317 [01:22<00:01,  1.87it/s, step=6583, loss=0.2640, tru"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 6580 | Train Loss: 0.4860 | Val Loss: 0.3498 | True train loss: 3.2743 | True val loss: 3.4532\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 67.9448\n",
+      "  Label 1: 0.0116\n",
+      "  Label 2: 0.0392\n",
+      "  Label 3: 0.0810\n",
+      "  Label 4: 3.3704\n",
+      "New best validation loss: 0.3498\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 6/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|▉| 1313/1317 [01:22<00:02,  1.87it/s, step=7899, loss=0.1156, tru"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 7896 | Train Loss: 0.4671 | Val Loss: 0.3422 | True train loss: 3.1278 | True val loss: 3.3296\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 63.2215\n",
+      "  Label 1: 0.0117\n",
+      "  Label 2: 0.0362\n",
+      "  Label 3: 0.0827\n",
+      "  Label 4: 3.2292\n",
+      "New best validation loss: 0.3422\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 7/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|▉| 1313/1317 [01:22<00:02,  1.86it/s, step=9215, loss=0.2901, tru"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 9212 | Train Loss: 0.4557 | Val Loss: 0.3389 | True train loss: 3.0609 | True val loss: 3.2751\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 63.4267\n",
+      "  Label 1: 0.0114\n",
+      "  Label 2: 0.0381\n",
+      "  Label 3: 0.0815\n",
+      "  Label 4: 2.8806\n",
+      "New best validation loss: 0.3389\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 8/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|▉| 1311/1317 [01:22<00:03,  1.87it/s, step=10531, loss=0.4604, tr"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 10528 | Train Loss: 0.4474 | Val Loss: 0.3379 | True train loss: 3.0718 | True val loss: 3.2051\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.2247\n",
+      "  Label 1: 0.0113\n",
+      "  Label 2: 0.0372\n",
+      "  Label 3: 0.0828\n",
+      "  Label 4: 2.9602\n",
+      "New best validation loss: 0.3379\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 9/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|▉| 1311/1317 [01:21<00:03,  1.87it/s, step=11847, loss=0.2547, tr"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 11844 | Train Loss: 0.4285 | Val Loss: 0.3416 | True train loss: 3.0075 | True val loss: 3.1697\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.3822\n",
+      "  Label 1: 0.0112\n",
+      "  Label 2: 0.0421\n",
+      "  Label 3: 0.0847\n",
+      "  Label 4: 3.3251\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 10/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training:  99%|▉| 1309/1317 [01:21<00:04,  1.87it/s, step=13163, loss=0.2791, tr"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 13160 | Train Loss: 0.4116 | Val Loss: 0.3174 | True train loss: 2.9027 | True val loss: 3.1666\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 59.6537\n",
+      "  Label 1: 0.0110\n",
+      "  Label 2: 0.0365\n",
+      "  Label 3: 0.0877\n",
+      "  Label 4: 3.1535\n",
+      "New best validation loss: 0.3174\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 11/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training:  99%|▉| 1309/1317 [01:21<00:04,  1.87it/s, step=14479, loss=0.3915, tr"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 14476 | Train Loss: 0.3983 | Val Loss: 0.3039 | True train loss: 2.8602 | True val loss: 3.1240\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 60.6528\n",
+      "  Label 1: 0.0107\n",
+      "  Label 2: 0.0371\n",
+      "  Label 3: 0.0827\n",
+      "  Label 4: 3.2043\n",
+      "New best validation loss: 0.3039\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 12/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training:  99%|▉| 1307/1317 [01:21<00:05,  1.87it/s, step=15795, loss=0.1155, tr"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 15792 | Train Loss: 0.3863 | Val Loss: 0.3050 | True train loss: 2.7796 | True val loss: 3.0697\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 59.8002\n",
+      "  Label 1: 0.0108\n",
+      "  Label 2: 0.0371\n",
+      "  Label 3: 0.0815\n",
+      "  Label 4: 3.1037\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 13/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training:  99%|▉| 1307/1317 [01:21<00:05,  1.87it/s, step=17111, loss=0.2704, tr"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 17108 | Train Loss: 0.3779 | Val Loss: 0.2881 | True train loss: 2.7442 | True val loss: 3.1636\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.2941\n",
+      "  Label 1: 0.0102\n",
+      "  Label 2: 0.0361\n",
+      "  Label 3: 0.0836\n",
+      "  Label 4: 3.1077\n",
+      "New best validation loss: 0.2881\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 14/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training:  99%|▉| 1305/1317 [01:21<00:06,  1.87it/s, step=18427, loss=0.4965, tr"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Step 18424 | Train Loss: 0.3645 | Val Loss: 0.2822 | True train loss: 2.6844 | True val loss: 3.1494\n",
+      "Individual label losses (unscaled):\n",
+      "  Label 0: 61.1663\n",
+      "  Label 1: 0.0100\n",
+      "  Label 2: 0.0365\n",
+      "  Label 3: 0.0743\n",
+      "  Label 4: 3.2309\n",
+      "New best validation loss: 0.2822\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Epoch 15/20\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "                                                                                \r"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[15]\u001b[39m\u001b[32m, line 10\u001b[39m\n\u001b[32m      6\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtqdm\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m tqdm\n\u001b[32m      8\u001b[39m BATCH_SIZE = \u001b[32m128\u001b[39m\n\u001b[32m---> \u001b[39m\u001b[32m10\u001b[39m train_losses, val_losses, best_loss = \u001b[43mrun_training\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m     11\u001b[39m \u001b[43m     \u001b[49m\u001b[43msmiles_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msmiles_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m     12\u001b[39m \u001b[43m     \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtokenizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscalers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_epochs\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m20\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlearning_rate\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m1e-4\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m=\u001b[49m\u001b[43mBATCH_SIZE\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalidation_steps\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msmiles_train\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[43m/\u001b[49m\u001b[43m/\u001b[49m\u001b[43m \u001b[49m\u001b[43mBATCH_SIZE\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m     13\u001b[39m \u001b[43m)\u001b[49m\n",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[13]\u001b[39m\u001b[32m, line 532\u001b[39m, in \u001b[36mrun_training\u001b[39m\u001b[34m(smiles_train, smiles_test, labels_train, labels_test, model, tokenizer, scalers, num_epochs, learning_rate, batch_size, validation_steps, underrep_boost)\u001b[39m\n\u001b[32m    529\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mTotal training steps: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(train_dataloader)\u001b[38;5;250m \u001b[39m*\u001b[38;5;250m \u001b[39mnum_epochs\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m    531\u001b[39m \u001b[38;5;66;03m# Train the model\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m532\u001b[39m train_losses, val_losses, best_val_loss = \u001b[43mtrain_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    533\u001b[39m \u001b[43m    \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    534\u001b[39m \u001b[43m    \u001b[49m\u001b[43mtrain_dataloader\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtrain_dataloader\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    535\u001b[39m \u001b[43m    \u001b[49m\u001b[43mval_dataloader\u001b[49m\u001b[43m=\u001b[49m\u001b[43mval_dataloader\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    536\u001b[39m \u001b[43m    \u001b[49m\u001b[43mscalers\u001b[49m\u001b[43m=\u001b[49m\u001b[43mscalers\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    537\u001b[39m \u001b[43m    \u001b[49m\u001b[43mnum_epochs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnum_epochs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    538\u001b[39m \u001b[43m    \u001b[49m\u001b[43mlearning_rate\u001b[49m\u001b[43m=\u001b[49m\u001b[43mlearning_rate\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    539\u001b[39m \u001b[43m    \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    540\u001b[39m \u001b[43m    \u001b[49m\u001b[43mpatience\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m10\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m    541\u001b[39m \u001b[43m    \u001b[49m\u001b[43mvalidation_steps\u001b[49m\u001b[43m=\u001b[49m\u001b[43mvalidation_steps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    542\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    544\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m'\u001b[39m\u001b[33mTraining completed.\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m    545\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[33mNumber of validation checkpoints: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(val_losses)\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m)\n",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[13]\u001b[39m\u001b[32m, line 351\u001b[39m, in \u001b[36mtrain_model\u001b[39m\u001b[34m(model, train_dataloader, val_dataloader, scalers, num_epochs, learning_rate, device, patience, validation_steps)\u001b[39m\n\u001b[32m    345\u001b[39m scheduler.step()\n\u001b[32m    347\u001b[39m global_step += \u001b[32m1\u001b[39m\n\u001b[32m    349\u001b[39m train_progress.set_postfix({\n\u001b[32m    350\u001b[39m     \u001b[33m'\u001b[39m\u001b[33mstep\u001b[39m\u001b[33m'\u001b[39m: global_step,\n\u001b[32m--> \u001b[39m\u001b[32m351\u001b[39m     \u001b[33m'\u001b[39m\u001b[33mloss\u001b[39m\u001b[33m'\u001b[39m: \u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[43mloss\u001b[49m\u001b[43m.\u001b[49m\u001b[43mitem\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m,\n\u001b[32m    352\u001b[39m     \u001b[33m'\u001b[39m\u001b[33mtrue_loss\u001b[39m\u001b[33m'\u001b[39m: \u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtrue_loss\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m,\n\u001b[32m    353\u001b[39m     \u001b[33m'\u001b[39m\u001b[33mlr\u001b[39m\u001b[33m'\u001b[39m: \u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mscheduler.get_last_lr()[\u001b[32m0\u001b[39m]\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.2e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m\n\u001b[32m    354\u001b[39m })\n\u001b[32m    356\u001b[39m \u001b[38;5;66;03m# Perform validation every validation_steps\u001b[39;00m\n\u001b[32m    357\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m global_step % validation_steps == \u001b[32m0\u001b[39m:\n\u001b[32m    358\u001b[39m     \u001b[38;5;66;03m# Calculate average training losses since last validation\u001b[39;00m\n",
+      "\u001b[31mKeyboardInterrupt\u001b[39m: "
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.optim.lr_scheduler import LinearLR\n",
+    "from torch.utils.data import DataLoader\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "BATCH_SIZE = 128\n",
+    "\n",
+    "train_losses, val_losses, best_loss = run_training(\n",
+    "     smiles_train, smiles_test, labels_train, labels_test, \n",
+    "     model, tokenizer, scalers, num_epochs=20, learning_rate=1e-4, batch_size=BATCH_SIZE, validation_steps=len(smiles_train) // BATCH_SIZE,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kaggle": {
+   "accelerator": "gpu",
+   "dataSources": [
+    {
+     "databundleVersionId": 12966160,
+     "sourceId": 74608,
+     "sourceType": "competition"
+    },
+    {
+     "datasetId": 7678100,
+     "sourceId": 12189904,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7690162,
+     "sourceId": 12207625,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7716502,
+     "sourceId": 12322957,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7801155,
+     "sourceId": 12372847,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7809006,
+     "sourceId": 12525286,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "datasetId": 7912957,
+     "sourceId": 12668147,
+     "sourceType": "datasetVersion"
+    }
+   ],
+   "dockerImageVersionId": 31041,
+   "isGpuEnabled": true,
+   "isInternetEnabled": true,
+   "language": "python",
+   "sourceType": "notebook"
+  },
+  "kernelspec": {
+   "display_name": "Python [conda env:.mlspace-bolgov_simson_training]",
+   "language": "python",
+   "name": "conda-env-.mlspace-bolgov_simson_training-py"
+  },
+  "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.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

simson_modeling/kaggle_comp/simson_polymer_1m_uncompiled.pth

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

simson_modeling/kaggle_comp/test.csv

@@ -0,0 +1,4 @@
+id,SMILES
+1109053969,*Oc1ccc(C=NN=Cc2ccc(Oc3ccc(C(c4ccc(*)cc4)(C(F)(F)F)C(F)(F)F)cc3)cc2)cc1
+1422188626,*Oc1ccc(C(C)(C)c2ccc(Oc3ccc(C(=O)c4cccc(C(=O)c5ccc(*)cc5)c4)cc3)cc2)cc1
+2032016830,*c1cccc(OCCCCCCCCOc2cccc(N3C(=O)c4ccc(-c5cccc6c5C(=O)N(*)C6=O)cc4C3=O)c2)c1

simson_modeling/kaggle_comp/train_supplement/dataset1.csv

@@ -0,0 +1,875 @@
+SMILES,TC_mean
+*/C(=C(\c1ccccc1)c1ccc(*)cc1)c1ccccc1,0.338
+*/C(F)=C(\F)C(F)(C(*)(F)F)C(F)(F)F,0.102
+*/C=C(/*)C#CCCCCCCCCCCCCCCCCCCCCC(=O)O,0.4105
+*/C=C(/*)CCCCCCCCCCCCCCCCCCCCC(=O)O,0.403
+*/C=C/*,0.526
+*/C=C/*,0.262
+*/C=C/C(C)C(*)C(=O)OC,0.189
+*/C=C/C(C)CCCCC*,0.2486666666666666
+*/C=C/C(C*)C(C)CC,0.203
+*/C=C/C(C*)CCC,0.218
+*/C=C/C1CCC(*)C1,0.2603333333333333
+*/C=C/CC*,0.2486666666666666
+*/C=C/CC*,0.272
+*/C=C/CC*,0.244
+*/C=C/CCC*,0.2535
+*/C=C/CCC*,0.2796
+*/C=C/CCCCC*,0.3143333333333333
+*/C=C/CCCCCC*,0.33
+*/C=C/CCCCCCC(Cl)CCCCCC*,0.3405
+*/C=C/CCCCCCCC*,0.3571666666666666
+*/C=C/CCCCCCCC*,0.3804999999999999
+*/C=C/CCCCCCCCCC(CCCCCCCCC*)COCCOCCOCCOCCOCCCCCC,0.31
+*/C=C/CCCCCCCCCC(CCCCCCCCC*)COCCOCCOCCOCCOCCCCCCCCCCCCCC,0.332
+*/C=C/CCCCCCCCCC(Cl)CCCCCCCCC*,0.3419999999999999
+*/C=C/CCCCCCCCCC*,0.4142
+*/C=C/c1cc(-c2ccc3c(c2)C(CCCCCCCC)(CCCCCCCC)c2ccccc2-3)c(*)cc1-c1ccc(F)cc1F,0.198
+*/C=C/c1cc(CCCCCCCCCCC)c(/C=C/c2ccc(*)cc2)cc1CCCCCCCCCCC,0.368
+*/C=C/c1cc(CCCCCCCCCCCC)c(*)s1,0.368
+*/C=C/c1cc(CCCCCCCCCCCC)c(/C=C/c2ccc(*)cc2)cc1CCCCCCCCCCCC,0.315
+*/C=C/c1cc(OCC(CC)CCCC)c(*)cc1-c1ccc(F)c(C(F)(F)F)c1,0.185
+*/C=C/c1cc(OCC(CC)CCCC)c(*)cc1-c1ccc(N(c2ccc(OC)cc2)c2ccc(OC)cc2)cc1,0.242
+*/C=C/c1cc(OCC2CC3CC2C2CCCC32)c(*)cc1OC,0.258
+*/C=C/c1cc(OCC2CC3CC2C2CCCC32)c(*)cc1OCC1CC2CC1C1CCCC21,0.24
+*/C=C/c1cc(OCCCCCC)c(*)cc1OC,0.524
+*/C=C/c1cc(OCCCCCCCC)c(*)cc1OC,0.31
+*/C=C/c1cc(OCCCCCCCCCCCC)c(*)cc1OC,0.251
+*/C=C/c1cc(OCCCCCCCCCCCCCCCC)c(/C=C/c2ccc(*)cc2)cc1OCCCCCCCCCCCCCCCC,0.3329999999999999
+*/C=C/c1cc(OCCc2ccccc2)c(*)cc1OC,0.285
+*/C=C/c1ccc(*)c(-c2c(OCC(CC)CCCC)ccc3cc(-c4ccccc4)ccc23)c1,0.212
+*/C=C/c1ccc(*)c(-c2c(OCC(CC)CCCC)ccc3ccccc23)c1,0.257
+*/C=C/c1ccc(*)c(-c2cc(-c3ccccc3)c(OCC(CC)CCCC)cc2OCC(CC)CCCC)c1,0.256
+*/C=C/c1ccc(*)c(-c2cc(OCC(CC)CCCC)c(-c3ccccc3)cc2OCC(CC)CCCC)c1,0.237
+*/C=C/c1ccc(*)c(-c2cc(OCC(CC)CCCC)c(OCC(CC)CCCC)cc2-c2ccccc2)c1,0.196
+*/C=C/c1ccc(*)c(-c2cc(OCCC(C)C)c(OCCC(C)C)cc2-c2ccc(C(F)(F)F)cc2)c1,0.184
+*/C=C/c1ccc(*)c(-c2cc(OCCC(C)C)c(OCCC(C)C)cc2-c2ccc(F)cc2)c1,0.334
+*/C=C/c1ccc(*)c(-c2cc(OCCC(C)C)c(OCCC(C)C)cc2-c2ccc(OC)cc2)c1,0.308
+*/C=C/c1ccc(*)c(-c2cc(OCCC(C)C)c(OCCC(C)C)cc2-c2ccccc2)c1,0.307
+*/C=C/c1ccc(*)c(-c2ccc(OCC(CC)CCCC)c3ccccc23)c1,0.219
+*/C=C/c1ccc(*)c2ccc(CCCCCC)cc12,0.339
+*/C=C/c1ccc(*)c2ccc(CCCCCCCCCCC)cc12,0.27
+*/C=C/c1sc(*)c(OCCCCCCCCCCCC)c1OCCCCCCCCCCCC,0.365
+*/C=C/c1sc(/C=C/c2cc(CCCCCCCCCCCC)c(*)s2)cc1CCCCCCCCCCCC,0.291
+*C(*)C,0.2033333333333333
+*C(*)CC,0.206
+*C(=O)N(*)CCCCCCCCCCCCCCCCCC,0.408
+*C(=O)NCCCCCCCCCCNC(=O)c1ccc(*)o1,0.217
+*C(=O)Nc1ccc(Oc2ccc(N3C(=O)c4ccc(*)cc4C3=O)cc2)cc1,0.297
+*C(=O)c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(C(=O)c4cccc(C(=O)c5ccc(Oc6ccc(N7C(=O)c8ccc(*)cc8C7=O)cc6)cc5)c4)cc3)cc1)C2=O,0.328
+*C(F)(F)C(*)(F)Cl,0.139
+*C(F)(F)C(F)(F)C1(F)C(*)(F)OC(F)(F)C1(F)F,0.1265
+*C([2H])([2H])C(*)([2H])c1c([2H])c([2H])c([2H])c([2H])c1[2H],0.199
+*C1=NC2=CC(=CC=C2N1)C1=CC2=C(NC(O2)C2=CC=C(OC3=C4C5C6=C(C=CC=C6)C(C6=C5C=CC=C6)C4=C(OC4=CC=C(*)C=C4)C4=C3C3C5=C(C=CC=C5)C4C4=C3C=CC=C4)C=C2)C=C1,0.18
+*C1=NC2=CC(=CC=C2N1)C1=CC2=C(NC(O2)C2=CC=C(OC3=CC=C(OC4=CC=C(*)C=C4)C4=C3C3C5=C(C=CC=C5)C4C4=C3C=CC=C4)C=C2)C=C1,0.252
+*C1C(=O)N(C2CCCCC2)C(=O)C1*,0.1485
+*C1C(=O)N(c2ccc(C)cc2)C(=O)C1*,0.1405
+*C1C(=O)N(c2ccccc2)C(=O)C1*,0.143
+*C1C(=O)N(c2ccccc2C(=O)OC)C(=O)C1*,0.143
+*C1C(=O)OC(=O)C1*,0.1425
+*C1C=CC(*)C1,0.2784999999999999
+*C1CCC1*,0.163
+*C1Cc2ccccc2C1*,0.13
+*CC(*)(C#N)C(=O)OC,0.161
+*CC(*)(C#N)C(=O)OCC,0.1805
+*CC(*)(C#N)C(=O)OCCCC,0.179
+*CC(*)(C#N)C(=O)OCCCCCC,0.217
+*CC(*)(C(=O)OC)c1ccccc1,0.1426666666666667
+*CC(*)(C)C,0.2125
+*CC(*)(C)C#N,0.146
+*CC(*)(C)C(=O)NC(=O)OC(C)COc1c(Br)cc(S(=O)(=O)c2cc(Br)c(OCC(C)O)c(Br)c2)cc1Br,0.15
+*CC(*)(C)C(=O)NC(=O)Oc1c(Br)cc(S(=O)(=O)c2cc(Br)c(O)c(Br)c2)cc1Br,0.109
+*CC(*)(C)C(=O)OC,0.1594999999999999
+*CC(*)(C)C(=O)OC(C(F)(F)F)(C(F)(F)F)C(F)(F)F,0.0465
+*CC(*)(C)C(=O)OC(C(F)(F)F)C(F)(F)F,0.0755
+*CC(*)(C)C(=O)OC(C)(C)C,0.1525
+*CC(*)(C)C(=O)OC(C)C(C)(C)C,0.1674999999999999
+*CC(*)(C)C(=O)OC(C)C(F)(F)F,0.1139999999999999
+*CC(*)(C)C(=O)OC(C)CC,0.182
+*CC(*)(C)C(=O)OC(F)(C(F)(F)F)C(F)(F)Cl,0.069
+*CC(*)(C)C(=O)OC(F)(C(F)(F)F)C(F)(F)F,0.069
+*CC(*)(C)C(=O)OC(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F,0.084
+*CC(*)(C)C(=O)OC12CC3CC(C)(CC(C)(C3)C1)C2,0.122
+*CC(*)(C)C(=O)OC12CC3CC(CC(C3)C1)C2,0.1245
+*CC(*)(C)C(=O)OC1CC(C)CC(C)(C)C1,0.146
+*CC(*)(C)C(=O)OC1CC2CCC1(C)C2(C)C,0.143
+*CC(*)(C)C(=O)OC1CCC(C(C)(C)C)CC1,0.153
+*CC(*)(C)C(=O)OC1CCC(C)CC1,0.1709999999999999
+*CC(*)(C)C(=O)OC1CCCC(C)C1,0.1545
+*CC(*)(C)C(=O)OC1CCCCC1,0.2239999999999999
+*CC(*)(C)C(=O)OC1CCCCC1C,0.153
+*CC(*)(C)C(=O)OCC,0.1699999999999999
+*CC(*)(C)C(=O)OCC(C)(C)C,0.1555
+*CC(*)(C)C(=O)OCC(C)(C)C1OCC(C)(C)CO1,0.1619999999999999
+*CC(*)(C)C(=O)OCC(CC)CCCC,0.1935
+*CC(*)(C)C(=O)OCC(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)F,0.09
+*CC(*)(C)C(=O)OCC(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F,0.0735
+*CC(*)(C)C(=O)OCC(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)F,0.113
+*CC(*)(C)C(=O)OCC(F)(F)C(F)(F)C(F)(F)C(F)F,0.095
+*CC(*)(C)C(=O)OCC1(C)COC(C)(C)OC1,0.1525
+*CC(*)(C)C(=O)OCC1(C)COCOC1,0.1305
+*CC(*)(C)C(=O)OCC1CCCO1,0.172
+*CC(*)(C)C(=O)OCC1CO1,0.1855
+*CC(*)(C)C(=O)OCCBr,0.128
+*CC(*)(C)C(=O)OCCC#N,0.138
+*CC(*)(C)C(=O)OCCC(C)(C)C,0.1895
+*CC(*)(C)C(=O)OCCC(C)CC(C)(C)C,0.198
+*CC(*)(C)C(=O)OCCCC,0.203
+*CC(*)(C)C(=O)OCCCCC,0.1895
+*CC(*)(C)C(=O)OCCCCCC,0.184
+*CC(*)(C)C(=O)OCCCCCCCC,0.2415
+*CC(*)(C)C(=O)OCCCCCCCCCC,0.259
+*CC(*)(C)C(=O)OCCCCCCCCCCCC,0.2665
+*CC(*)(C)C(=O)OCCCCCCCCCCCCCC,0.3115
+*CC(*)(C)C(=O)OCCCCCCCCCCCCCCCC,0.26
+*CC(*)(C)C(=O)OCCCCCCCCCCCCCCCCCC,0.317
+*CC(*)(C)C(=O)OCCCCCCOc1ccc(-c2ccc(OC)cc2)cc1,0.2175
+*CC(*)(C)C(=O)OCCCCn1c2ccccc2c2ccccc21,0.1694999999999999
+*CC(*)(C)C(=O)OCCCl,0.1325
+*CC(*)(C)C(=O)OCCF,0.1679999999999999
+*CC(*)(C)C(=O)OCCN(C)C,0.2005
+*CC(*)(C)C(=O)OCCN(CC)CC,0.2375
+*CC(*)(C)C(=O)OCCN(CC)S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F,0.1095
+*CC(*)(C)C(=O)OCCN(CC)c1ccc(/N=N/c2ccc([N+](=O)[O-])cc2)cc1,0.19
+*CC(*)(C)C(=O)OCCNC(C)(C)C,0.184
+*CC(*)(C)C(=O)OCCOC,0.1815
+*CC(*)(C)C(=O)OCCOCC,0.212
+*CC(*)(C)C(=O)OCCS(=O)CC,0.199
+*CC(*)(C)C(=O)OCC[N+](=O)[O-],0.1895
+*CC(*)(C)C(=O)OCCc1ccccc1,0.168
+*CC(*)(C)C(=O)OCc1cccc([N+](=O)[O-])c1,0.158
+*CC(*)(C)C(=O)OCc1ccccc1,0.1755
+*CC(*)(C)C(=O)OCc1ccccc1Cl,0.159
+*CC(*)(C)C(=O)OCc1ccco1,0.172
+*CC(*)(C)C(=O)Oc1c(Cl)c(Cl)c(Cl)c(Cl)c1Cl,0.0829999999999999
+*CC(*)(C)C(=O)Oc1ccc(C#N)cc1,0.1345
+*CC(*)(C)C(=O)Oc1ccc(C(C)(C)C)cc1,0.181
+*CC(*)(C)C(=O)Oc1ccc(C)cc1,0.1545
+*CC(*)(C)C(=O)Oc1ccc(C)cc1C,0.157
+*CC(*)(C)C(=O)Oc1ccc(CC#N)cc1,0.1655
+*CC(*)(C)C(=O)Oc1ccc2ccccc2c1,0.1639999999999999
+*CC(*)(C)C(=O)Oc1cccc(C)c1,0.151
+*CC(*)(C)C(=O)Oc1ccccc1,0.184
+*CC(*)(C)C(=O)Oc1ccccc1C,0.1905
+*CC(*)(C)C(C)=O,0.1669999999999999
+*CC(*)(C)C(N)=O,0.145
+*CC(*)(C)CC,0.17
+*CC(*)(C)CCC,0.174
+*CC(*)(C)c1ccc(C(C)C)cc1,0.2013333333333333
+*CC(*)(C)c1ccccc1,0.164
+*CC(*)(CC(=O)OC)C(=O)OC,0.152
+*CC(*)(CC(=O)OC1CCCCC1)C(=O)OC1CCCCC1,0.1694999999999999
+*CC(*)(CC(=O)OCC)C(=O)OCC,0.1689999999999999
+*CC(*)(CC(=O)OCC1CCCCC1)C(=O)OCC1CCCCC1,0.19
+*CC(*)(CC(=O)OCCC)C(=O)OCCC,0.1845
+*CC(*)(CC(=O)OCCC1CCCCC1)C(=O)OCCC1CCCCC1,0.213
+*CC(*)(CC(=O)OCCCC)C(=O)OCCCC,0.2249999999999999
+*CC(*)(CC(=O)OCCCC1CCCCC1)C(=O)OCCCC1CCCCC1,0.199
+*CC(*)(CC(=O)OCCCCC)C(=O)OCCCCC,0.215
+*CC(*)(CC(=O)OCCCCCC)C(=O)OCCCCCC,0.2319999999999999
+*CC(*)(CC(=O)OCCCc1ccccc1)C(=O)OCCCc1ccccc1,0.2055
+*CC(*)(CC(=O)OCCc1ccccc1)C(=O)OCCc1ccccc1,0.199
+*CC(*)(CC(=O)OCc1ccccc1)C(=O)OCc1ccccc1,0.176
+*CC(*)(CC(=O)Oc1ccc(C)cc1)C(=O)Oc1ccc(C)cc1,0.182
+*CC(*)(CC(=O)Oc1cccc(C)c1)C(=O)Oc1cccc(C)c1,0.165
+*CC(*)(CC(=O)Oc1ccccc1)C(=O)Oc1ccccc1,0.154
+*CC(*)(CC(=O)Oc1ccccc1C)C(=O)Oc1ccccc1C,0.1635
+*CC(*)(CC)C(=O)OCC,0.145
+*CC(*)(CF)C(=O)OC,0.1365
+*CC(*)(CF)C(=O)OCC,0.1684999999999999
+*CC(*)(Cl)C(=O)OC(C)C,0.1465
+*CC(*)(Cl)C(=O)OC(C)CC,0.174
+*CC(*)(Cl)C(=O)OC1CCCCC1,0.1365
+*CC(*)(Cl)C(=O)OCC,0.1985
+*CC(*)(Cl)C(=O)OCCC,0.173
+*CC(*)(Cl)C(=O)OCCCC,0.178
+*CC(*)(F)C#N,0.154
+*CC(*)(F)C(=O)OCC(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F,0.095
+*CC(*)(F)C(=O)OCC(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)F,0.108
+*CC(*)(F)C(=O)OCC(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)F,0.106
+*CC(*)(F)C(=O)OCC(F)(F)C(F)(F)C(F)(F)F,0.097
+*CC(*)(F)C(=O)OCCC(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F,0.121
+*CC(*)C,0.2445
+*CC(*)C#N,0.207
+*CC(*)C(=O)C(C)C,0.203
+*CC(*)C(=O)C1CCCCC1,0.204
+*CC(*)C(=O)N(C(C)C)C(C)C,0.1865
+*CC(*)C(=O)N(C)C,0.2125
+*CC(*)C(=O)N(C)c1ccccc1,0.1775
+*CC(*)C(=O)N(CCCC)CCCC,0.211
+*CC(*)C(=O)N1CCCCC1,0.218
+*CC(*)C(=O)N1CCOCC1,0.212
+*CC(*)C(=O)NC(C)(C)C,0.199
+*CC(*)C(=O)NC(C)C,0.203
+*CC(*)C(=O)NC(C)CC,0.2259999999999999
+*CC(*)C(=O)NCCCC,0.252
+*CC(*)C(=O)NCCCCCC(=O)O,0.2495
+*CC(*)C(=O)NCCCCCCCC/C=C/CCCCCCCC,0.3065
+*CC(*)C(=O)NCCCCCCCCCCCC,0.3435
+*CC(*)C(=O)NCCCCCCCCCCCCCC,0.3746666666666667
+*CC(*)C(=O)NCCCCCCCCCCCCCCCC,0.3105
+*CC(*)C(=O)NCCCCCCCCCCCCCCCCCC,0.383
+*CC(*)C(=O)NCCCCCCCCCCCCCCCCCCCCCC,0.3665
+*CC(*)C(=O)OC(C)CC(C)C,0.207
+*CC(*)C(=O)OC(C)CCC(CC)CCCC,0.212
+*CC(*)C(=O)OC(C)CCCCC,0.2405
+*CC(*)C(=O)OC(C)CCCCCC,0.245
+*CC(*)C(=O)OC(CC)CC,0.213
+*CC(*)C(=O)OC(CCC(CC)CCCC)CC(C)C,0.2319999999999999
+*CC(*)C(=O)OC(F)(C(F)(F)F)C(F)(F)F,0.1119999999999999
+*CC(*)C(=O)OC12CC3CC(C)(CC(C)(C3)C1)C2,0.1635
+*CC(*)C(=O)OC1CC(C)CC(C)(C)C1,0.2205
+*CC(*)C(=O)OC1CCCCC1,0.201
+*CC(*)C(=O)OCC,0.2305
+*CC(*)C(=O)OCC(C)(C)C,0.2115
+*CC(*)C(=O)OCC(C)CC,0.221
+*CC(*)C(=O)OCC(C)CCC,0.217
+*CC(*)C(=O)OCC(CC)CC,0.2095
+*CC(*)C(=O)OCC(CC)CCCC,0.2309999999999999
+*CC(*)C(=O)OCC(F)(F)C(F)(F)OC(F)(F)C(F)(F)C(F)(F)C(F)(F)F,0.086
+*CC(*)C(=O)OCCC#N,0.195
+*CC(*)C(=O)OCCC(C)C,0.224
+*CC(*)C(=O)OCCC(C)OC,0.212
+*CC(*)C(=O)OCCCC,0.2075
+*CC(*)C(=O)OCCCCCC,0.2565
+*CC(*)C(=O)OCCCCCC(=O)Oc1ccc(-c2ccc(C#N)cc2)cc1,0.2299999999999999
+*CC(*)C(=O)OCCCCCCCCC,0.281
+*CC(*)C(=O)OCCCCCCCCCCCCCC,0.3215
+*CC(*)C(=O)OCCCCCCCCCCCCCCCC,0.3626666666666667
+*CC(*)C(=O)OCCCCCCCCCCCCCCCCCC,0.3795
+*CC(*)C(=O)OCCCCCCCCCCCCCCCCCCCCCC,0.3585
+*CC(*)C(=O)OCCCCCCOc1ccc(C(=O)Oc2ccc(C#N)cc2)cc1,0.2245
+*CC(*)C(=O)OCCCCCCSCC#N,0.2175
+*CC(*)C(=O)OCCCCSC,0.2005
+*CC(*)C(=O)OCCCSC,0.211
+*CC(*)C(=O)OCCCSCC,0.2155
+*CC(*)C(=O)OCCCSCCC#N,0.219
+*CC(*)C(=O)OCCN(CC)c1ccc(/N=N/c2ccc([N+](=O)[O-])cc2)cc1,0.2135
+*CC(*)C(=O)OCCSC,0.181
+*CC(*)C(=O)OCCSCC,0.2175
+*CC(*)C(=O)OCCSCC#N,0.183
+*CC(*)C(=O)OCCSCCC#N,0.1875
+*CC(*)C(=O)OCCSCCCC#N,0.18
+*CC(*)C(=O)OCCc1ccccc1,0.196
+*CC(*)C(=O)OCc1ccc(C#N)cc1,0.182
+*CC(*)C(=O)OCc1ccccc1,0.1985
+*CC(*)C(=O)Oc1c(Cl)c(Cl)c(Cl)c(Cl)c1Cl,0.0849999999999999
+*CC(*)C(=O)Oc1ccc(-c2ccccc2)cc1,0.2055
+*CC(*)C(=O)Oc1ccc(C#N)cc1,0.1845
+*CC(*)C(=O)Oc1ccc(C(=O)OCCCC)cc1,0.2329999999999999
+*CC(*)C(=O)Oc1ccc(C(C)(C)C)cc1,0.2245
+*CC(*)C(=O)Oc1ccc(C)cc1,0.193
+*CC(*)C(=O)Oc1ccc(Cl)cc1,0.158
+*CC(*)C(=O)Oc1ccc(Cl)cc1Cl,0.119
+*CC(*)C(=O)Oc1ccc(OC)cc1,0.208
+*CC(*)C(=O)Oc1cccc(C)c1,0.2055
+*CC(*)C(=O)Oc1cccc(N(C)C)c1,0.221
+*CC(*)C(=O)Oc1cccc2ccccc12,0.1644999999999999
+*CC(*)C(=O)Oc1ccccc1,0.196
+*CC(*)C(=O)Oc1ccccc1C,0.1735
+*CC(*)C(=O)Oc1ccccc1C(C)(C)C,0.175
+*CC(*)C(=O)Oc1ccccc1Cl,0.166
+*CC(*)C(=O)c1ccc(C(C)(C)C)cc1,0.1915
+*CC(*)C(=O)c1ccc(C)cc1,0.1975
+*CC(*)C(C)(C)C,0.1363333333333333
+*CC(*)C(C)=O,0.179
+*CC(*)C(C)C,0.1868
+*CC(*)C(C)CC,0.1897499999999999
+*CC(*)C(C)c1ccccc1,0.1506666666666666
+*CC(*)C(CC)CC,0.1883333333333333
+*CC(*)C1CC1,0.2175
+*CC(*)C1CC=CCC1,0.18075
+*CC(*)C1CCC(C)CC1,0.1996666666666666
+*CC(*)C1CCC1,0.209
+*CC(*)C1CCCC(C)C1,0.1806666666666666
+*CC(*)C1CCCC1,0.2016666666666666
+*CC(*)C1CCCCC1,0.1906666666666666
+*CC(*)C=O,0.2425
+*CC(*)CC,0.2253333333333333
+*CC(*)CC(C)(C)C,0.1735
+*CC(*)CC(C)(C)CC,0.1863333333333333
+*CC(*)CC(C)C,0.2083333333333333
+*CC(*)CC(C)C(F)(F)F,0.148
+*CC(*)CC(C)CC,0.202
+*CC(*)CC(CC)CC,0.219
+*CC(*)CC1CCCC1,0.2283333333333333
+*CC(*)CC1CCCCC1,0.2256
+*CC(*)CCC,0.2463333333333333
+*CC(*)CCC(C)(C)C,0.1929999999999999
+*CC(*)CCC(C)C,0.216
+*CC(*)CCC(C)CC,0.229
+*CC(*)CCC1CCCCC1,0.2176666666666666
+*CC(*)CCCC,0.2306666666666666
+*CC(*)CCCC(C)(C)C,0.216
+*CC(*)CCCC(C)C,0.2573333333333333
+*CC(*)CCCC1CCCCC1,0.2463333333333333
+*CC(*)CCCCC,0.2583999999999999
+*CC(*)CCCCCC,0.238
+*CC(*)CCCCCCC,0.2669999999999999
+*CC(*)CCCCCCCC,0.286
+*CC(*)CCCCCCCCC,0.3193333333333333
+*CC(*)CCCCCCCCCC,0.33575
+*CC(*)CCCCCCCCCCC,0.3206666666666666
+*CC(*)CCCCCCCCCCCC,0.339
+*CC(*)CCCCCCCCCCCCC,0.3383333333333333
+*CC(*)CCCCCCCCCCCCCC,0.3409999999999999
+*CC(*)CCCCCCCCCCCCCCCC,0.375
+*CC(*)CCCCCCCCCCCCCCCCCC,0.381
+*CC(*)CCCCCCCCCCCCCCCCCCCC,0.4019999999999999
+*CC(*)CCCN(CC(C)C)CC(C)C,0.201
+*CC(*)CCc1ccccc1,0.1803333333333333
+*CC(*)CNc1ccc([N+](=O)[O-])cn1,0.192
+*CC(*)Cc1ccccc1,0.1963333333333333
+*CC(*)Cl,0.139
+*CC(*)O,0.424
+*CC(*)OC,0.2614999999999999
+*CC(*)OC(=O)C1(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C1(F)F,0.086
+*CC(*)OC(=O)CC,0.212
+*CC(*)OC(=O)CCCCCCCCCCC,0.261
+*CC(*)OC(=O)CCCCCCCCCCCCCCC,0.319
+*CC(*)OC(=O)CCCCCCCCCCCCCCCCC,0.305
+*CC(*)OC(=O)CCCCCCCCCCCCCCCCCCCCC,0.371
+*CC(*)OC(=O)c1ccc(OC(=O)CCC)cc1,0.223
+*CC(*)OC(=O)c1ccccc1,0.1669999999999999
+*CC(*)OC(C)C,0.2115
+*CC(*)OCC,0.2465
+*CC(*)OCCCCCCCCCCCCCCCCCC,0.3868
+*CC(*)O[N+](=O)[O-],0.1585
+*CC(*)c1c(C)cc(C)cc1C,0.1669999999999999
+*CC(*)c1cc(Br)ccc1OC,0.132
+*CC(*)c1cc(Br)ccc1OC(C)C,0.124
+*CC(*)c1cc(Br)ccc1OCC,0.124
+*CC(*)c1cc(Br)ccc1OCCC,0.136
+*CC(*)c1cc(Br)ccc1OCCC(C)C,0.1674999999999999
+*CC(*)c1cc(Br)ccc1OCCCC,0.1493333333333333
+*CC(*)c1cc(Br)ccc1OCCCCC,0.1545
+*CC(*)c1cc(C(C)(C)C)ccc1C,0.1636666666666666
+*CC(*)c1cc(C(C)C)ccc1C(C)C,0.1616666666666666
+*CC(*)c1cc(C)c(C)cc1C,0.2095
+*CC(*)c1cc(C)ccc1C,0.173
+*CC(*)c1cc(C)ccc1F,0.171
+*CC(*)c1cc(Cl)ccc1Cl,0.1119999999999999
+*CC(*)c1cc(F)ccc1F,0.1403333333333333
+*CC(*)c1ccc(C(=O)CCCCCCC)cc1,0.2663333333333333
+*CC(*)c1ccc(C(=O)CCN2CCCCC2)cc1,0.225
+*CC(*)c1ccc(C(=O)N(C)C)cc1,0.246
+*CC(*)c1ccc(C(=O)N(CC)CC)cc1,0.213
+*CC(*)c1ccc(C(=O)N2CCOCC2)cc1,0.24
+*CC(*)c1ccc(C(=O)O)c(C(=O)O)c1,0.171
+*CC(*)c1ccc(C(=O)OC)cc1,0.2033333333333333
+*CC(*)c1ccc(C(=O)OCCN(C)C)cc1,0.2314999999999999
+*CC(*)c1ccc(C(C)(C)C)cc1,0.184
+*CC(*)c1ccc(C(C)(C)O)cc1,0.2316666666666666
+*CC(*)c1ccc(C(C)(O)CC)cc1,0.2266666666666666
+*CC(*)c1ccc(C(C)=O)cc1,0.2296666666666666
+*CC(*)c1ccc(C(C)C)cc1C(C)C,0.1979999999999999
+*CC(*)c1ccc(C)c(C)c1,0.1905
+*CC(*)c1ccc(C)cc1,0.1873333333333333
+*CC(*)c1ccc(C)cc1C,0.1856666666666666
+*CC(*)c1ccc(CC)cc1,0.2013333333333333
+*CC(*)c1ccc(CCC)cc1,0.2345
+*CC(*)c1ccc(CCCC)cc1,0.2096666666666666
+*CC(*)c1ccc(CCCCCC)cc1,0.241
+*CC(*)c1ccc(CCCCCCCC)cc1,0.2674999999999999
+*CC(*)c1ccc(CCCCCCCCC)cc1,0.277
+*CC(*)c1ccc(CCCCCCCCCC)cc1,0.2825
+*CC(*)c1ccc(CCCCCCCCCCCC)cc1,0.3035
+*CC(*)c1ccc(CCCCCCCCCCCCCC)cc1,0.3399999999999999
+*CC(*)c1ccc(CCCCCCCCCCCCCCCC)cc1,0.3409999999999999
+*CC(*)c1ccc(CCCCCCCCCCCCCCCCCC)cc1,0.3751666666666667
+*CC(*)c1ccc(COCC(CC)CCCC)cc1,0.268
+*CC(*)c1ccc(COCCCCCC)cc1,0.252
+*CC(*)c1ccc(COCCCCCCOc2ccc(-c3ccc(OC)cc3)cc2)cc1,0.3
+*CC(*)c1ccc(COCCOCCCC)cc1,0.262
+*CC(*)c1ccc(COCCOCCCCCCCC)cc1,0.282
+*CC(*)c1ccc(Cl)c(C)c1,0.154
+*CC(*)c1ccc(Cl)c(Cl)c1,0.114
+*CC(*)c1ccc(Cl)c(F)c1,0.1275
+*CC(*)c1ccc(Cl)cc1C,0.1366666666666667
+*CC(*)c1ccc(Cl)cc1Cl,0.1006666666666666
+*CC(*)c1ccc(F)cc1C,0.1413333333333333
+*CC(*)c1ccc(O)cc1,0.2073333333333333
+*CC(*)c1ccc(OC(C)=O)cc1,0.2005
+*CC(*)c1cccc(-c2ccc(-c3ccccc3)cc2)c1,0.1956666666666666
+*CC(*)c1cccc(C)c1,0.1973333333333333
+*CC(*)c1cccc(CC)c1,0.186
+*CC(*)c1cccc(Cl)c1,0.14175
+*CC(*)c1cccc(F)c1,0.1623333333333333
+*CC(*)c1cccc2ccccc12,0.194
+*CC(*)c1ccccc1,0.2045999999999999
+*CC(*)c1ccccc1C,0.1903333333333333
+*CC(*)c1ccccc1C(=O)N(C)C,0.165
+*CC(*)c1ccccc1C(=O)NC,0.1836666666666666
+*CC(*)c1ccccc1C(=O)Nc1ccccc1,0.1636666666666666
+*CC(*)c1ccccc1C(=O)OC,0.1736666666666666
+*CC(*)c1ccccc1C(=O)OC(C)C,0.1736666666666666
+*CC(*)c1ccccc1C(=O)OCC,0.1816666666666666
+*CC(*)c1ccccc1C(=O)OCC(C)C,0.1696666666666666
+*CC(*)c1ccccc1C(=O)OCCC,0.1929999999999999
+*CC(*)c1ccccc1C(=O)OCCC(C)C,0.1929999999999999
+*CC(*)c1ccccc1C(=O)OCCCC,0.1953333333333333
+*CC(*)c1ccccc1C(=O)OCCCCC,0.1923333333333333
+*CC(*)c1ccccc1C(=O)OCCCCCC,0.2056666666666666
+*CC(*)c1ccccc1C(=O)OCCN(C)C,0.1853333333333333
+*CC(*)c1ccccc1C(=O)Oc1ccccc1,0.1693333333333333
+*CC(*)c1ccccc1CC,0.1843333333333333
+*CC(*)c1ccccc1COC,0.2066666666666666
+*CC(*)c1ccccc1COC(C)C,0.171
+*CC(*)c1ccccc1COCC,0.1846666666666666
+*CC(*)c1ccccc1COCCC,0.217
+*CC(*)c1ccccc1COCCC(C)C,0.1943333333333333
+*CC(*)c1ccccc1COCCCC,0.2096666666666666
+*CC(*)c1ccccc1COCCCCC,0.186
+*CC(*)c1ccccc1COCCc1ccccc1,0.1883333333333333
+*CC(*)c1ccccc1COCc1ccccc1,0.1913333333333333
+*CC(*)c1ccccc1Cl,0.1436666666666667
+*CC(*)c1ccccc1F,0.1746666666666666
+*CC(*)c1ccccc1OC,0.1946666666666666
+*CC(*)c1ccccn1,0.196
+*CC(*)c1cccs1,0.1995
+*CC(*)n1c2ccccc2c2ccccc21,0.147
+*CC(*)n1cc2ccccc2n1,0.2075
+*CC(=O)N*,0.277
+*CC(=O)c1ccc(Oc2ccc(C(=O)COc3ccc(/C=C4\CC/C(=C\c5ccc(O*)c(OC)c5)C4=O)cc3OC)cc2)cc1,0.228
+*CC(=O)c1ccc(Oc2ccc(C(=O)COc3ccc(/C=C4\CC/C(=C\c5ccc(O*)cc5)C4=O)cc3)cc2)cc1,0.259
+*CC(C)(C)CS(=O)(=O)CC(C)(C)COC(=O)O*,0.186
+*CC(C)(C)O*,0.1995
+*CC(C)C(*)(C)C,0.2026666666666666
+*CC(CC(*)(C#N)C(=O)OC)c1ccccc1,0.176
+*CC(CCCCCCCCCCCCCCCC)C(CCCCCCCCCCCCCCCC)COC(=O)c1ccc(C(=O)O*)cc1,0.354
+*CC(CCCCCCCCCCCCCCCC)C1C(=O)N(CCCCCCCCCCCC)C(=O)C1*,0.335
+*CC(CCl)(CCl)O*,0.1159999999999999
+*CC(F)(F)C1(F)CC(C(O)(C(F)(F)F)C(F)(F)F)CC1*,0.109
+*CC(O)COc1c(Cl)cc(C(C)(C)c2cc(Cl)c(O*)c(Cl)c2)cc1Cl,0.1485
+*CC(O)COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.198
+*CC(O*)c1ccccc1,0.181
+*CC(c1ccccn1)C(c1ccccc1)C(*)c1ccccn1,0.151
+*CC/C=C(/*)C,0.256
+*CC/C=C(/*)C,0.258
+*CC/C=C(/*)C,0.235
+*CC/C=C(/*)C(C)(C)C,0.20825
+*CC/C=C(/*)C(C)C,0.21
+*CC/C=C(/*)CCC,0.2233333333333333
+*CC/C=C(/*)CCCCCCC,0.269
+*CC1(*)CCC(C)CC1,0.164
+*CC1(*)CCCCC1,0.1443333333333333
+*CC1CCC(*)C1,0.3353333333333333
+*CC1CCC(COC(=O)CCCCCCCCCCC(=O)O*)CC1,0.279
+*CC1CCC(COC(=O)NCCSCCCCCCSCCNC(=O)O*)CC1,0.24
+*CCC(*)(C)C,0.1956666666666666
+*CCC(=O)OC(=O)CCc1ccc(*)o1,0.216
+*CCC(=O)Oc1ccc(OC(=O)CCN2CCN(*)CC2)cc1,0.224
+*CCC(C(=O)OCC)C(*)C(=O)OCC,0.2075
+*CCC(C)C(*)C,0.2329999999999999
+*CCC(C)CCC(=O)O*,0.253
+*CCC(Cl)C(*)Cl,0.1795
+*CCC/C=C(/*)c1ccc(Cl)cc1,0.184
+*CCC1CCCC1*,0.2863333333333333
+*CCCC(*)(C)C,0.236
+*CCCC(*)(C)C(=O)O,0.1985
+*CCCC(*)(C)CC,0.2339999999999999
+*CCCC(=O)NCc1ccc(CNC(=O)CCCO*)cc1,0.259
+*CCCC1CC(=O)N(*)C(=O)C1,0.23
+*CCCC1CCN(C(=O)SSCCCCSSC(=O)N2CCC(*)CC2)CC1,0.223
+*CCCCC(C)CC(=O)N*,0.254
+*CCCCCC(*)CCCCCCCCCC,0.406
+*CCCCCC(*)CCCCCCCCCCCC,0.381
+*CCCCCC(*)CCCCCCCCCCCCCC,0.403
+*CCCCCC(=O)N*,0.301
+*CCCCCCC(=O)NCCCCCCNC(=O)CCCCCCO*,0.3215
+*CCCCCCCC(*)C,0.371
+*CCCCCCCC(=O)N*,0.329
+*CCCCCCCCC(=O)NCCCCCCNC(=O)CCCCCCCCO*,0.3575
+*CCCCCCCCC(=O)NCCCCCCNC(=O)CCCCO*,0.3185
+*CCCCCCCCC(=O)NCCCCCCNC(=O)CCCO*,0.286
+*CCCCCCCCC(=O)NCCCCCOCCCCCNC(=O)CCCCO*,0.287
+*CCCCCCCCC(=O)NCCCCCOCCCCCNC(=O)CCCO*,0.289
+*CCCCCCCCCC#CC#CCCCCCCCCCOC(=O)CCCCCCCCC(=O)O*,0.307
+*CCCCCCCCCCC(=O)NCCCCCC(=O)N*,0.296
+*CCCCCCCCCCC(=O)NCCCCCCNC(=O)CCCCO*,0.3565
+*CCCCCCCCCCC(=O)NCCCCCCNC(=O)CCCO*,0.3245
+*CCCCCCCCCCC(=O)NCCCCCOCCCCCNC(=O)CCCCO*,0.3349999999999999
+*CCCCCCCCCCC(=O)NCCCCCOCCCCCNC(=O)CCCO*,0.303
+*CCCCCCCCCCC(=O)NCCc1ccc(CCNC(=O)CCCCCCCCCCS*)cc1,0.296
+*CCCCCCCCCCC(=O)NCc1ccc(CNC(=O)CCCCCCCCCCS*)cc1,0.285
+*CCCCCCCCCCC(Cl)C(*)Cl,0.316
+*CCCCCCCCCCCC(=O)N*,0.3409999999999999
+*CCCCCCCCCCCCC(=O)N*,0.33
+*CCCCCCCCCCCCCCC(*)Cl,0.3735
+*CCCCCCCCCCCCCCC(=O)N*,0.389
+*CCCCCCCCCCCCCCC(=O)O*,0.3595
+*CCCCCCCCCCCCCCCC(=O)O*,0.3954
+*CCCCCCCCCCCCCCCCC(=O)N*,0.379
+*CCCCCCCCCCCCCCCCCCCCC(*)COCCOCCOCCOCCOCCCCCC,0.39925
+*CCCCCCCCCCCCCCCCCCCCC(*)COCCOCCOCCOCCOCCCCCCCCCCCCCC,0.38425
+*CCCCCCCCCCCCCCCCCCCCC(*)Cl,0.468
+*CCCCCCCCCCCCCCCCCCCCCC(=O)N*,0.4325
+*CCCCCCCCCCCCCCCCCCCCCCOC(=O)CC(CC(=O)O*)c1ccccc1,0.354
+*CCCCCCCCCCCCCCCCCCCCCCOC(=O)CCC(=O)O*,0.387
+*CCCCCCCCCCCCCCCCCCCCCCOC(=O)CCCCC(=O)O*,0.376
+*CCCCCCCCCCCCCCCCCCCCCCOC(=O)Cc1ccccc1CC(=O)O*,0.367
+*CCCCCCCCCCCCCCCCCCCCOC(=O)C(=O)O*,0.3545
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CC(=O)O*,0.318
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCC(=O)O*,0.362
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCC(C)CC(=O)O*,0.362
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCCC(=O)O*,0.302
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCCCC(=O)O*,0.3545
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCCCCC(=O)O*,0.406
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCCCCCC(=O)O*,0.3379999999999999
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCCCCCCC(=O)O*,0.507
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCCCCCCCC(=O)O*,0.276
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCCCS(=O)(=O)CCCCC(=O)O*,0.322
+*CCCCCCCCCCCCCCCCCCCCOC(=O)CCCCSCCCCC(=O)O*,0.322
+*CCCCCCCCCCCCCCCCCCCCOC(=O)COCC(=O)O*,0.3249999999999999
+*CCCCCCCCCCCCCCCCCCCCc1nnc(*)o1,0.398
+*CCCCCCCCCCCCCCCCCCNC(=O)CCCCCCCCC(=O)N*,0.369
+*CCCCCCCCCCCCCCCCCCNC(=O)CCCCCCCCCCC(=O)N*,0.4337499999999999
+*CCCCCCCCCCCCCCCCCCNC(=O)CCCCCCCCCCCCCCCCC(=O)N*,0.4533333333333333
+*CCCCCCCCCCCCCCCCCCNC(=O)CCc1ccc(CCC(=O)N*)cc1,0.3755
+*CCCCCCCCCCCCCCCCCCNC(=O)NCCCCCCCCCCNC(=O)N*,0.39
+*CCCCCCCCCCCCCCCCCCNC(=O)NCCCCCCNC(=O)N*,0.383
+*CCCCCCCCCCCCCCCCCCOC(=O)c1ccc(C(=O)O*)cc1,0.304
+*CCCCCCCCCCCCCCCCCCOCO*,0.406
+*CCCCCCCCCCCCCCCCOC(=O)C/C=C/CC(=O)O*,0.315
+*CCCCCCCCCCCCCCCCOC(=O)CC/C=C/CCC(=O)O*,0.304
+*CCCCCCCCCCCCCCCCOC(=O)CCCCCCC(=O)O*,0.308
+*CCCCCCCCCCCCCCCCOC(=O)CCCCCCCCC(=O)O*,0.442
+*CCCCCCCCCCCCCCCCOC(=O)CCCCCCCCCCCCC(=O)O*,0.297
+*CCCCCCCCCCCCCCCCOC(=O)NCCCCCCCCCCNC(=O)O*,0.275
+*CCCCCCCCCCCCCCCCOC(=O)NCCCCCCNC(=O)O*,0.348
+*CCCCCCCCCCCCCCCC[N+](C)(C)CCCCCC[N+](*)(C)C,0.408
+*CCCCCCCCCCCCCCNC(=O)CCCCCCCCC(=O)N*,0.3944999999999999
+*CCCCCCCCCCCCCCNC(=O)CCCCCCCCCCC(=O)N*,0.346
+*CCCCCCCCCCCCCCNC(=O)CCCCCCCCCCCCCCCCC(=O)N*,0.4341428571428571
+*CCCCCCCCCCCCCCNC(=O)CCCCCCCCCCCCCCCCCCCCC(=O)N*,0.3915714285714285
+*CCCCCCCCCCCCCCNC(=O)NCCCCCCCCCCNC(=O)N*,0.344
+*CCCCCCCCCCCCCCNC(=O)NCCCCCCNC(=O)N*,0.4
+*CCCCCCCCCCCCCCOC(=O)CC/C=C/CCC(=O)O*,0.318
+*CCCCCCCCCCCCCCOC(=O)CCCCC(=O)O*,0.3555
+*CCCCCCCCCCCCCCOC(=O)CCCCCCC(=O)O*,0.3165
+*CCCCCCCCCCCCCCOC(=O)c1ccc(C(=O)NCCCCCCNC(=O)c2ccc(C(=O)O*)cc2)cc1,0.333
+*CCCCCCCCCCCCCCOC(=O)c1ccc(C(=O)NCCCCCNC(=O)c2ccc(C(=O)O*)cc2)cc1,0.258
+*CCCCCCCCCCCCCCOC(=O)c1ccc(C(=O)NCCNC(=O)c2ccc(C(=O)O*)cc2)cc1,0.274
+*CCCCCCCCCCCCCCS*,0.34125
+*CCCCCCCCCCCCCNC(=O)CCCCCCCCCCCC(=O)N*,0.3835
+*CCCCCCCCCCCCNC(=O)C(=O)N*,0.309
+*CCCCCCCCCCCCNC(=O)CCCCC(=O)N*,0.3745
+*CCCCCCCCCCCCNC(=O)CCCCCCCCC(=O)N*,0.374
+*CCCCCCCCCCCCNC(=O)CCCCCCCCCCCCC(=O)N*,0.3994999999999999
+*CCCCCCCCCCCCNC(=O)CCCCCCCCCCCCCCC(=O)N*,0.396
+*CCCCCCCCCCCCNC(=O)CCCCCCCCCCCCCCCCCCC(=O)N*,0.44
+*CCCCCCCCCCCCNC(=O)CCCCCCCCCCCCCCCCCCCCC(=O)N*,0.3944285714285714
+*CCCCCCCCCCCCNC(=O)NCCCCCCNC(=O)N*,0.3545
+*CCCCCCCCCCCCO*,0.4307499999999999
+*CCCCCCCCCCCCOC(=O)CC/C=C/CCC(=O)O*,0.274
+*CCCCCCCCCCCCOC(=O)CCCCC(=O)O*,0.292
+*CCCCCCCCCCCCOC(=O)CCCCCCC(=O)O*,0.284
+*CCCCCCCCCCCCOC(=O)CCCCCCCCCCC(=O)O*,0.297
+*CCCCCCCCCCCCOC(=O)CCCCCCCCCCCCC(=O)O*,0.294
+*CCCCCCCCCCCCOC(=O)CCCCCNC(=O)CCCCC(=O)NCCCCCC(=O)O*,0.306
+*CCCCCCCCCCCNC(=O)CCCCC(=O)N*,0.3295
+*CCCCCCCCCCCNC(=O)CCCCCCCCC(=O)N*,0.314
+*CCCCCCCCCCCNC(=O)CCCCCCCCC(=O)NCCCCCCCCCCCNC(=O)C(=O)N*,0.3195
+*CCCCCCCCCCCNC(=O)CCCCCCCCCCC(=O)N*,0.389
+*CCCCCCCCCCCNC(=O)CCCCCCCCCCCCCCCCCCC(=O)N*,0.37175
+*CCCCCCCCCCCSCCCCCCCCCCS*,0.352
+*CCCCCCCCCCCSCCCCCCS*,0.3145
+*CCCCCCCCCCN/C(C)=N/*,0.298
+*CCCCCCCCCCNC(=O)C(CCCCCCCCCCCC)C(=O)N*,0.35
+*CCCCCCCCCCNC(=O)CC/C=C/CCC(=O)N*,0.3125
+*CCCCCCCCCCNC(=O)CCCCCCC(=O)N*,0.422
+*CCCCCCCCCCNC(=O)CCCCCCCCC(=O)N*,0.408
+*CCCCCCCCCCNC(=O)CCCCCCCCC(=O)NCCCCCCCCCCNC(=O)C(=O)N*,0.4125
+*CCCCCCCCCCNC(=O)CCCCCCCCCCCC(=O)N*,0.3685
+*CCCCCCCCCCNC(=O)CCCCCCCCCCCCC(=O)N*,0.342
+*CCCCCCCCCCNC(=O)CCCCCCCCCCCCCCC(=O)N*,0.368
+*CCCCCCCCCCNC(=O)CCCCCCCCCCCCCCCCC(=O)N*,0.381
+*CCCCCCCCCCNC(=O)CCCCCCCCCCCCCCCCCCC(=O)N*,0.3873333333333333
+*CCCCCCCCCCNC(=O)CCCCCCCCCCCCCCCCCCCCC(=O)N*,0.38825
+*CCCCCCCCCCNC(=O)NCCCCCCCCNC(=O)N*,0.366
+*CCCCCCCCCCO*,0.353
+*CCCCCCCCCCOC(=O)CCC(=O)O*,0.285
+*CCCCCCCCCCOC(=O)CCCC(=O)O*,0.263
+*CCCCCCCCCCOC(=O)CCCCCCC(=O)O*,0.3445
+*CCCCCCCCCCOC(=O)CCCCCCCC(=O)O*,0.3325
+*CCCCCCCCCCOC(=O)CCCCCCCCC(=O)O*,0.281
+*CCCCCCCCCCOC(=O)CCCCCCCCCCC(=O)O*,0.319
+*CCCCCCCCCCOC(=O)CCCCCCCCCCCCCCCCC(=O)O*,0.3415
+*CCCCCCCCCCOC(=O)CCCCCNC(=O)CCCCC(=O)NCCCCCC(=O)O*,0.2955
+*CCCCCCCCCCOC(=O)CCCCS(=O)(=O)CCCCC(=O)O*,0.278
+*CCCCCCCCCCOC(=O)CCCCSCCCCC(=O)O*,0.27
+*CCCCCCCCCCOC(=O)NCCCCCCCCCCNC(=O)O*,0.316
+*CCCCCCCCCCOC(=O)c1ccc(C(=O)NCCCCCNC(=O)c2ccc(C(=O)O*)cc2)cc1,0.307
+*CCCCCCCCCCOCCCCCCCCCCOCCCCCCO*,0.269
+*CCCCCCCCCCOCCCCCCCCCCOCCCCCO*,0.38525
+*CCCCCCCCCCOCCCCCCCCCCOCCCCO*,0.329
+*CCCCCCCCCCOCCCCCCOCCCCCCO*,0.36175
+*CCCCCCCCCCOCO*,0.297
+*CCCCCCCCCCOc1ccc(OC(=O)c2ccc(OCCCCCCOc3ccc(C(=O)Oc4ccc(O*)cc4)cc3)cc2)cc1,0.344
+*CCCCCCCCCCSCCCCCCS*,0.3305
+*CCCCCCCCCCSCCCCS*,0.282
+*CCCCCCCCCCSSCCCCCCSS*,0.2295
+*CCCCCCCCCCc1ccc(-c2c(-c3ccccc3)cc(-c3cccc(-c4cc(-c5ccccc5)c(-c5ccc(*)cc5)c(-c5ccccc5)c4-c4ccccc4)c3)c(-c3ccccc3)c2-c2ccccc2)cc1,0.21
+*CCCCCCCCCNC(=O)C(CCCCCCCCCCCC)C(=O)N*,0.347
+*CCCCCCCCCNC(=O)CCCCCCCC(=O)N*,0.361
+*CCCCCCCCCNC(=O)CCCCCCCCC(=O)N*,0.3485
+*CCCCCCCCCNC(=O)CCCCCCCCC(=O)NCCCCCCCCCNC(=O)C(=O)N*,0.312
+*CCCCCCCCCNC(=O)CCCCCCCCCC(=O)N*,0.312
+*CCCCCCCCCNC(=O)CCCCCCCCCCCC(=O)N*,0.348
+*CCCCCCCCCOC(=O)CCCCCCCC(=O)O*,0.294
+*CCCCCCCCCOC(=O)c1ccc(C(=O)NCCCCCCNC(=O)c2ccc(C(=O)O*)cc2)cc1,0.259
+*CCCCCCCCCOC(=O)c1ccc(C(=O)NCCCCCNC(=O)c2ccc(C(=O)O*)cc2)cc1,0.315
+*CCCCCCCCCOCO*,0.277
+*CCCCCCCCNC(=O)C(CCCCCCCCCCCC)C(=O)N*,0.331
+*CCCCCCCCNC(=O)CCCCC(=O)N*,0.291
+*CCCCCCCCNC(=O)CCCCCCCC(=O)N*,0.308
+*CCCCCCCCNC(=O)CCCCCCCCC(=O)N*,0.392
+*CCCCCCCCNC(=O)CCCCCCCCC(=O)NCCCCCCCCNC(=O)C(=O)N*,0.3315
+*CCCCCCCCNC(=O)CCCCCCCCCCC(=O)N*,0.3463333333333334
+*CCCCCCCCNC(=O)CCCCCCCCCCCCC(=O)N*,0.381
+*CCCCCCCCNC(=O)CCCCCCCCCCCCCCC(=O)N*,0.355
+*CCCCCCCCNC(=O)CCCCCCCCCCCCCCCCC(=O)N*,0.3725
+*CCCCCCCCNC(=O)CCCCCCCCCCCCCCCCCCCCC(=O)N*,0.425
+*CCCCCCCCOC(=O)CCCCCNC(=O)CCCCC(=O)NCCCCCC(=O)O*,0.293
+*CCCCCCCCOC(=O)CCCCCNC(=O)c1ccc(C(=O)NCCCCCC(=O)O*)cc1,0.276
+*CCCCCCCCOC(=O)c1ccc(C(=O)NCCCCCCNC(=O)c2ccc(C(=O)O*)cc2)cc1,0.261
+*CCCCCCCCSSCCCCSS*,0.192
+*CCCCCCCCc1nnc(*)o1,0.324
+*CCCCCCCNC(=O)C(CCCCCCCCCCCC)C(=O)N*,0.3455
+*CCCCCCCNC(=O)CCCCC(=O)N*,0.323
+*CCCCCCCNC(=O)CCCCCC(=O)N*,0.334
+*CCCCCCCNC(=O)CCCCCCCCC(=O)N*,0.3235
+*CCCCCCCNC(=O)CCCCCCCCCC(=O)N*,0.4065
+*CCCCCCCNC(=O)CCCCCCCCCCCCCCCCCCC(=O)N*,0.4137499999999999
+*CCCCCCN(C)C(=O)CCCCCCCCCCCCCCC(=O)N(*)C,0.33
+*CCCCCCN(C)C(=O)CCCCCCCCCCCCCCCCC(=O)N(*)C,0.3525
+*CCCCCCN(CC)C(=O)CCCCCCCCCCCCCCCCC(=O)N(*)CC,0.333
+*CCCCCCNC(=O)C(CCCCCCCCCCCCC)C(=O)N*,0.2925
+*CCCCCCNC(=O)C(CCCCCCCCCCCCCC)C(=O)N*,0.319
+*CCCCCCNC(=O)C(CCCCCCCCCCCCCCC)C(=O)N*,0.3369999999999999
+*CCCCCCNC(=O)C(CCCCCCCCCCCCCCCC)C(=O)N*,0.3235
+*CCCCCCNC(=O)C(CCCCCCCCCCCCCCCCC)C(=O)N*,0.3505
+*CCCCCCNC(=O)C(CCCCCCCCCCCCCCCCCC)C(=O)N*,0.354
+*CCCCCCNC(=O)CC/C=C/CCC(=O)N*,0.278
+*CCCCCCNC(=O)CCCCCC(=O)N*,0.278
+*CCCCCCNC(=O)CCCCCCC(=O)N*,0.345
+*CCCCCCNC(=O)CCCCCCCCCCCCC(=O)N*,0.355
+*CCCCCCNC(=O)CCCCCCCCCCCCCCC(=O)N*,0.367
+*CCCCCCNC(=O)CCCCCCCCCCCCCCCCC(=O)N*,0.3955
+*CCCCCCNC(=O)CCCCCCCCCCCCCCCCCCCCC(=O)N*,0.44
+*CCCCCCNC(=O)N*,0.328
+*CCCCCCOC(=O)CCCCSCCCCC(=O)O*,0.224
+*CCCCCCOC(=O)OCCCCCCOC(=O)OCCCCCCOc1ccc(-c2ccc(O*)cc2)cc1,0.329
+*CCCCCCOCO*,0.278
+*CCCCCCSCCCCCS*,0.241
+*CCCCCCSCCS*,0.234
+*CCCCCCSSCCCCSS*,0.192
+*CCCCCNC(=O)CCCCC(=O)N*,0.327
+*CCCCCNC(=O)CCCCCCCC(=O)N*,0.301
+*CCCCCNC(=O)CCCCCCCCCCCC(=O)N*,0.3545
+*CCCCCNC(=O)CCCCCCCCCCCCC(=O)N*,0.3415
+*CCCCCNC(=O)CCCCCCCCCCCCCCCCC(=O)N*,0.4165
+*CCCCCNC(=O)CCCCCCCCCCCCCCCCCCC(=O)N*,0.3495
+*CCCCCNC(=O)CCCCCCCCOCCCCCCCCC(=O)NCCCCCO*,0.267
+*CCCCCNC(=O)CCCCCCOCCCCCCC(=O)NCCCCCO*,0.285
+*CCCCCNC(=O)O*,0.268
+*CCCCCOC(=O)CCCCCNC(=O)O*,0.317
+*CCCCCOC(=O)CCCCSCCCCC(=O)O*,0.202
+*CCCCCc1ccc(CCCCCOC(=O)c2ccc(C(=O)O*)cc2)cc1,0.276
+*CCCCNC(=O)CC/C=C/CCC(=O)N*,0.258
+*CCCCNC(=O)CCCCC(=O)N*,0.302
+*CCCCNC(=O)CCCCCCC(=O)N*,0.2915
+*CCCCNC(=O)CCCCCCCCC(=O)N*,0.355
+*CCCCNC(=O)CCCCCCCCCC(=O)N*,0.3229999999999999
+*CCCCNC(=O)CCCCCCCCCCC(=O)N*,0.332
+*CCCCNC(=O)CCCCCCCCCCCCCCC(=O)N*,0.3735
+*CCCCOC(=O)CCCCCCCC(=O)O*,0.241
+*CCCCOC(=O)CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC(=O)O*,0.49475
+*CCCCOC(=O)CCCCCNC(=O)CCCCC(=O)NCCCCCC(=O)O*,0.242
+*CCCCOC(=O)c1ccc(-c2ccc(C(=O)O*)cc2)cc1,0.248
+*CCCCOC(=O)c1cccc(-c2cccc(C(=O)O*)c2)c1,0.203
+*CCCCOC(=O)c1ccccc1-c1ccccc1C(=O)O*,0.19
+*CCCCSCCS*,0.226
+*CCCCSS*,0.175
+*CCCCSSCCCCO*,0.199
+*CCCCSSCCCCOCO*,0.196
+*CCCCSSCCCSS*,0.161
+*CCCCc1ccc(CCCCOC(=O)c2ccc(C(=O)O*)cc2)cc1,0.241
+*CCCN*,0.354
+*CCCNC(=O)CCCCCCCCCCCCCCCCCCC(=O)N*,0.407
+*CCCO*,0.296
+*CCCOC(=O)C1CCC(C(=O)O*)CC1,0.222
+*CCCOC(=O)CCCCCCCCCCCCCCCCC(=O)O*,0.364
+*CCCc1ccc(CCCOC(=O)c2ccc(C(=O)O*)cc2)cc1,0.249
+*CCN(*)C(=O)CCCCCCCCCCCCCC,0.309
+*CCN(*)C(=O)CCCCCCCCCCCCCCC,0.3359999999999999
+*CCN(*)C(=O)CCCCCCCCCCCCCCCCC,0.4005
+*CCN*,0.351
+*CCNC(=O)CCCCCCCCC(=O)N*,0.302
+*CCNC(=O)CCCCCCCCCCCCCCC(=O)N*,0.412
+*CCNC(=O)CCCCCCCCCCCCCCCCC(=O)N*,0.359
+*CCOC(=O)CCCCSCCCCC(=O)O*,0.212
+*CCOCCOC(=O)C(CCCCCCCCC)C(=O)O*,0.224
+*CCOCCOC(=O)CCCCCCCCC(=O)O*,0.229
+*CCOCCOC(=O)CCCCCCCCCCCCCCCCC(=O)O*,0.3485
+*CCOCCOCCOC(=O)CCCCCCCC(=O)O*,0.267
+*CCS*,0.223
+*CCc1c2ccccc2c(*)c2ccccc12,0.166
+*CCc1cc(*)c(C)cc1C,0.194
+*CCc1ccc(*)c(C(=O)OC)c1,0.245
+*CCc1ccc(*)c(C(C)=O)c1,0.217
+*CCc1ccc(*)o1,0.2784999999999999
+*CCc1ccc(*)s1,0.288
+*CCc1ccc(CCNC(=O)CCCCCCCCCCCCCCCC(=O)N*)cc1,0.3515
+*CCc1ccc(CCNC(=O)CCCCCCCCCCCCCCCCC(=O)N*)cc1,0.368
+*CCc1ccc(CCNC(=O)CCCCCCCCCCCCCCCCCCCCC(=O)N*)cc1,0.3195
+*CCc1ccc(CCOC(=O)CCc2ccc(CCC(=O)O*)cc2)cc1,0.319
+*CCc1ccc(CCOC(=O)c2ccc(C(=O)O*)cc2)cc1,0.23
+*CO*,0.246
+*CS*,0.172
+*Cc1ccc(*)cc1,0.267
+*Cc1ccc(CNC(=O)CCCCCCCCCCCCCCCCC(=O)N*)cc1,0.3299999999999999
+*Cc1ccc(CNC(=O)CCCCCCCCCCCCCCCCCCCCC(=O)N*)cc1,0.359
+*Cc1ccc2nc(-c3cc(-c4nc5ccc(*)cc5c(=O)o4)cc(N4C(=O)c5ccccc5C4=O)c3)oc(=O)c2c1,0.227
+*N1C(=O)C2=C(C=C(C=C2)C2=CC=C3C(=O)N(C(=O)C3=C2)C2=C3C=CC=C(*)C3=CC=C2)C1=O,0.314
+*Nc1ccc(*)cc1CCCCCCCCCCCCCCC,0.314
+*Nc1ccc(*)cc1OCCCCCCCCCCCCCCCC,0.3671666666666667
+*OC(*)C(Cl)(Cl)Cl,0.066
+*OC(*)CCC#N,0.1704999999999999
+*OC(=O)C(Cc1ccccc1)NC(=O)CCCCCCCCCCC(=O)NC(Cc1ccccc1)C(=O)OC1COC2C(*)COC12,0.222
+*OC(=O)CCCCCC(*)=O,0.237
+*OC(C)COC(=O)CCCCSCCCCC(*)=O,0.214
+*OC1CCCCC1*,0.1694999999999999
+*ON(C(F)(F)F)C(F)(F)C(*)(F)F,0.0905
+*OS(=O)(=O)c1cccc(S(=O)(=O)Oc2ccc(C3(c4ccc(*)cc4)CCCCC3)cc2)c1,0.151
+*Oc1c(C)cc(*)cc1-c1ccccc1,0.1935
+*Oc1c(Cl)cc(C2(c3cc(Cl)c(OC(*)=O)c(Cl)c3)CCCCC2)cc1Cl,0.109
+*Oc1cc(CCC)cc(OC(=O)c2cccc(C(*)=O)c2)c1,0.234
+*Oc1ccc(-c2ccc(-c3cc(-c4ccccc4)c(-c4ccc(-c5ccc(OC(=O)c6ccc(C(*)=O)cc6-c6ccccc6)cc5)cc4)c(-c4ccccc4)c3-c3ccccc3)cc2)cc1,0.315
+*Oc1ccc(/C=N/c2ccc(/N=C/c3ccc(OC(=O)CCCCC(*)=O)c(OC)c3)cc2)cc1OC,0.283
+*Oc1ccc(/C=N/c2ccc(/N=C/c3ccc(OC(=O)CCCCCCCCC(*)=O)c(OC)c3)cc2)cc1OC,0.274
+*Oc1ccc(/C=N/c2ccc(/N=C/c3ccc(OC(=O)c4cccc(C(*)=O)c4)c(OC)c3)cc2)cc1OC,0.37
+*Oc1ccc(/N=C/C=N/c2ccc(OC(=O)NC3CC(C)(C)CC(C)(CNC(*)=O)C3)cc2)cc1,0.349
+*Oc1ccc(/N=C/C=N/c2ccc(OC(=O)NCCCCCCNC(*)=O)cc2)cc1,0.325
+*Oc1ccc(/N=C/C=N/c2ccc(OC(=O)Nc3cc(NC(*)=O)ccc3C)cc2)cc1,0.297
+*Oc1ccc(/N=C/C=N/c2ccc(OC(=O)Nc3ccc(Cc4ccc(NC(*)=O)cc4)cc3)cc2)cc1,0.417
+*Oc1ccc(/N=C/CCC/C=N/c2ccc(OC(=O)NC3CC(C)(C)CC(C)(CNC(*)=O)C3)cc2)cc1,0.207
+*Oc1ccc(/N=C/CCC/C=N/c2ccc(OC(=O)NCCCCCCNC(*)=O)cc2)cc1,0.294
+*Oc1ccc(/N=C/CCC/C=N/c2ccc(OC(=O)Nc3cc(NC(*)=O)ccc3C)cc2)cc1,0.252
+*Oc1ccc(/N=C/CCC/C=N/c2ccc(OC(=O)Nc3ccc(Cc4ccc(NC(*)=O)cc4)cc3)cc2)cc1,0.326
+*Oc1ccc(C(C)(C)c2ccc(OC(*)=O)cc2)cc1,0.2385
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)CN(CC(*)=O)c3ccc(/N=N/c4ccc([N+](=O)[O-])cc4)cc3)cc2)cc1,0.244
+*Oc1ccc(C(C)(C)c2ccc(Oc3ccc(C(=O)Nc4ccc(-c5ccc(NC(=O)c6ccc(*)cc6)cc5C(F)(F)F)c(C(F)(F)F)c4)cc3)cc2)cc1,0.2685
+*Oc1ccc(C(C)(c2ccccc2)c2ccc(OC(*)=O)cc2)cc1,0.206
+*Oc1ccc(C(CCC)(CCC)c2ccc(OC(*)=O)cc2)cc1,0.219
+*Oc1ccc(C2(c3ccc(OC(*)=O)c(C)c3)CCCCC2)cc1C,0.183
+*Oc1ccc(C2(c3ccc(OC(*)=O)c(Cl)c3)CCCCC2)cc1Cl,0.165
+*Oc1ccc(C2(c3ccc(OC(*)=O)cc3)CCCC2)cc1,0.241
+*Oc1ccc(C2(c3ccc(OC(*)=O)cc3)CCCCC2)cc1,0.185
+*Oc1ccc(C2(c3ccc(OC(*)=O)cc3)c3ccccc3-c3ccccc32)cc1,0.235
+*Oc1ccc(NC(=O)CCCCCCCCCC(=O)Nc2ccc(*)cc2)cc1,0.3745
+*Oc1ccc(OC(=O)CCCCCCCCC(*)=O)cc1,0.257
+*Oc1ccc(Oc2ccc(C(=O)c3ccccc3-c3ccccc3C(=O)c3ccc(*)cc3)cc2)cc1,0.2205
+*Oc1ccc(S(=O)(=O)c2ccc(*)cc2)cc1,0.268
+*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C(C)(C)c4ccc(*)cc4)cc3)cc2)cc1,0.204
+*Oc1cccc(NC(=O)CCCCCCCCCCC(=O)Nc2ccc(*)cc2)c1,0.319
+*Oc1cccc(OC(=O)c2ccc(C(C)(C)c3ccc(C(*)=O)cc3)cc2)c1,0.222
+*Oc1cccc(Oc2ccc(C(=O)Nc3ccc(Oc4ccc(NC(=O)c5ccc(*)cc5)cc4)cc3)cc2)c1C#N,0.296
+*SC(*)(F)F,0.114
+*Sc1c(C)cc(*)cc1C,0.145
+*\N=C\c1ccc(C=Nc2c(cc(cc2-c2ccccc2)-c2ccc(cc2)-c2cc(-c3ccccc3)c(*)c(c2)-c2ccccc2)-c2ccccc2)cc1,0.219
+*c1[nH]c(*)c(CC(=O)OCCCCCCCCCCCC)c1CC(=O)OCCCCCCCCCCCC,0.2794999999999999
+*c1c(*)c2ccccc2c2ccccc12,0.091
+*c1c(-c2ccccc2)c(-c2ccccc2)c(*)c2cc(-c3ccc(C#Cc4ccccc4)c(C#Cc4ccccc4)c3)ccc12,0.224
+*c1c(-c2ccccc2)c(-c2ccccc2)c(*)c2cc(C(c3ccc(C#Cc4ccccc4)c(C#Cc4ccccc4)c3)(C(F)(F)F)C(F)(F)F)ccc12,0.103
+*c1c(-c2ccccc2)c(-c2ccccc2)c(*)c2cc(Oc3ccc(C#Cc4ccccc4)c(C#Cc4ccccc4)c3)ccc12,0.16
+*c1cc(*)c(O)c(/C=N/c2ccc(Cl)cc2)c1,0.141
+*c1cc(*)c(O)c(/C=N/c2ccc(N3CCOCC3)cc2)c1,0.266
+*c1cc(-c2sc(-c3cc(CCCCCCCCCCCCCC)c(*)s3)cc2CCCCCCCCCCCCCC)c2cccccc1-2,0.316
+*c1cc(/C=N/c2ccc(C)cc2)c(*)c(OC)c1,0.215
+*c1cc(/C=N/c2cccc(C)c2)cc(*)c1O,0.192
+*c1cc(CCCCCCCCCCCC)c(*)cc1CCCCCCCCCCCC,0.356
+*c1cc(CCCCCCCCCCCCC)c(*)s1,0.40475
+*c1cc(CCCCCCCCCCCCCC)c(*)s1,0.4182499999999999
+*c1cc(CCCCCCCCCCCCCCC)c(*)s1,0.3742499999999999
+*c1cc(CCCCCCCCCCCCCCCC)c(*)[nH]1,0.4075
+*c1cc(CCCCCCCCCCCCCCCC)c(*)s1,0.381
+*c1cc(CCCCCCCCCCCCCCCCC)c(*)s1,0.396
+*c1cc(CCCCCCCCCCCCCCCCCC)c(*)s1,0.36525
+*c1cc(CCCCCCCCCCCCCCCCCCC)c(*)s1,0.34
+*c1cc(CCCCCCCCCCCCCCCCCCCCCC)c(*)s1,0.39725
+*c1cc(O)c(O)cc1*,0.183
+*c1cc(OCCCCCCCCCC)c(*)cc1OCCCCCCCCCC,0.256
+*c1cc(OCCCCCCCCCCCC)c(*)cc1O,0.309
+*c1cc2cccccc-2c1*,0.163
+*c1ccc(*)c2ccccc12,0.571
+*c1ccc(-c2cc(-c3ccc(OCCCCCC)cc3)cc(-c3ccc(-c4ccc5c(c4)C(CCCCCC)(CCCCCC)c4cc(*)ccc4-5)cc3)c2-c2ccc(OCCCCCC)cc2)cc1,0.29
+*c1ccc(-c2ccc(-c3ccc(C(*)(CC)C(F)(F)F)cc3)cc2)cc1,0.236
+*c1ccc(-c2ccc(-c3ccc(C(*)(c4c(F)c(F)c(F)c(F)c4F)C(F)(F)F)cc3)cc2)cc1,0.172
+*c1ccc(-c2ccc(-c3ccc(C(*)(c4ccc(F)cc4)C(F)(F)F)cc3)cc2)cc1,0.22
+*c1ccc(-c2ccc(-c3ccc(C(*)(c4ccccc4)C(F)(F)F)cc3)cc2)cc1,0.278
+*c1ccc(-c2ccc(-c3ccc(C(*)c4c(F)c(F)c(F)c(F)c4F)cc3)cc2)cc1,0.291
+*c1ccc(-c2ccc(-c3sc(*)c(CCCCCCCCCCCC)c3CCCCCCCCCCCC)s2)s1,0.299
+*c1ccc(-c2ccc(C(*)(C)C(F)(F)F)cc2)cc1,0.194
+*c1ccc(-c2ccc(C(*)(C)C)cc2)cc1,0.247
+*c1ccc(-c2ccc(C(*)(c3ccc(F)cc3)C(F)(F)F)cc2)cc1,0.185
+*c1ccc(-c2ccc(C(*)(c3ccccc3)C(F)(F)F)cc2)cc1,0.233
+*c1ccc(-c2ccc(C3(*)CCCCC3)cc2)cc1,0.252
+*c1ccc(-c2ccc(C3(*)c4ccccc4-c4ccccc43)cc2)cc1,0.203
+*c1ccc(-c2ccc3c(c2)C(CCCCCC)(CCCCCC)c2cc(*)ccc2-3)cc1,0.376
+*c1ccc(-c2ccc3c(c2)C(CCCCCCBr)(CCCCCCBr)c2cc(*)ccc2-3)cc1,0.236
+*c1ccc(-c2ccc3c(c2)C(CCCCCCC#N)(CCCCCCC#N)c2cc(*)ccc2-3)cc1,0.487
+*c1ccc(-c2nc3ccc(Oc4ccc5nc(*)c(-c6ccccc6)c(-c6ccccc6)c5c4)cc3c(-c3ccccc3)c2-c2ccccc2)cc1,0.27
+*c1ccc(-c2nnc(-c3cccc(-c4nnc(*)n4-c4ccccc4)c3)n2-c2ccccc2)cc1,0.389
+*c1ccc(-c2sc(-c3cc(CCCCCCCCCCCC)c(*)s3)cc2CCCCCCCCCCCC)cc1,0.413
+*c1ccc(-c2sc(-c3cc(CCCCCCCCCCCC)c(*)s3)cc2CCCCCCCCCCCC)s1,0.34
+*c1ccc(-c2sc(-c3cc(SCCCCCCCCCCCC)c(*)s3)cc2SCCCCCCCCCCCC)cc1,0.349
+*c1ccc(C(Cl)(Cl)C(*)Cl)cc1,0.115
+*c1ccc(C(F)(F)C(*)(F)F)cc1,0.101
+*c1ccc(C2C(C#N)(C(=O)OCCC)C(*)C2(C#N)C(=O)OCCC)cc1,0.258
+*c1ccc(C2C(C(=O)Oc3ccccc3)C(*)C2C(=O)Oc2ccccc2)cc1,0.225
+*c1ccc(N2C(=O)c3ccc(-c4cccc5c4C(=O)N(*)C5=O)cc3C2=O)cc1,0.233
+*c1ccc(N2C(=O)c3ccc(C(=O)c4ccc5c(c4)C(=O)N(c4ccc(-c6nc7cc(-c8ccc9nc(-c%10ccccc%10)c(*)nc9c8)ccc7nc6-c6ccccc6)cc4)C5=O)cc3C2=O)cc1,0.224
+*c1ccc(NC(=O)Nc2ccc(NC(=O)Nc3ccc(-c4nc(-c5ccc([N+](=O)[O-])cc5)[nH]c4*)cc3)cc2)cc1,0.269
+*c1ccc(Oc2ccc(-c3csc(/N=C/c4ccc(OCCCCCCCCCCOc5ccc(/C=N/c6nc(*)cs6)cc5OC)c(OC)c4)n3)cc2)cc1,0.383
+*c1ccc(Oc2ccc(-c3csc(/N=C/c4ccc(OCCCCCCCCOc5ccc(/C=N/c6nc(*)cs6)cc5OC)c(OC)c4)n3)cc2)cc1,0.228
+*c1ccc(Oc2ccc(-c3csc(/N=C/c4ccc(OCCCCCCOc5ccc(/C=N/c6nc(*)cs6)cc5OC)c(OC)c4)n3)cc2)cc1,0.253
+*c1ccc(Oc2ccc(-c3csc(/N=C/c4ccc(OCCCCOc5ccc(/C=N/c6nc(*)cs6)cc5OC)c(OC)c4)n3)cc2)cc1,0.218
+*c1ccc(Oc2ccc(-c3csc(/N=C/c4ccc(OCCOc5ccc(/C=N/c6nc(*)cs6)cc5OC)c(OC)c4)n3)cc2)cc1,0.243
+*c1ccc(Oc2ccc(C(c3ccc(Oc4ccc(-n5c(=O)c6cc7c(=O)n(*)c(=O)c7cc6c5=O)cc4C(F)(F)F)cc3)(C(F)(F)F)C(F)(F)F)cc2)c(C(F)(F)F)c1,0.213
+*c1ccc(Oc2cccc(Oc3ccc(N4C(=O)c5cccc(Oc6cccc(Oc7cccc8c7C(=O)N(*)C8=O)c6)c5C4=O)cc3)c2)cc1,0.165
+*c1ccc(Sc2ccc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.252
+*c1ccc2c(c1)C(=O)N(c1cc(OCCN(CC)c3ccc(/N=N/c4ccc([N+](=O)[O-])cc4)cc3)cc(N3C(=O)c4ccc(C(*)(C(F)(F)F)C(F)(F)F)cc4C3=O)c1)C2=O,0.154
+*c1ccc2c(c1)C(=O)N(c1ccc(C(c3ccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)cc3)(C(F)(F)F)C(F)(F)F)cc1)C2=O,0.151
+*c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(C(c4ccc(Oc5ccc(N6C(=O)c7ccc(C(*)(C(F)(F)F)C(F)(F)F)cc7C6=O)cc5C(F)(F)F)cc4)(C(F)(F)F)C(F)(F)F)cc3)c(C(F)(F)F)c1)C2=O,0.152
+*c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)cc3)cc1)C2=O,0.165
+*c1ccc2c(c1)C(=O)N(c1cccc(C(c3cccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)c3)(C(F)(F)F)C(F)(F)F)c1)C2=O,0.111
+*c1ccc2c(c1)C(CCCCCC)(CCCCCC)c1cc(-c3cc(CCCCCC)c(*)cc3CCCCCC)ccc1-2,0.46
+*c1ccc2c(c1)C(CCCCCC)(CCCCCC)c1cc(-c3cc(CCCCCCCC)c(*)cc3CCCCCCCC)ccc1-2,0.349
+*c1ccc2c(c1)C(CCCCCC)(CCCCCC)c1cc(-c3cc(CCCCCCCCCC)c(*)cc3CCCCCCCCCC)ccc1-2,0.216
+*c1ccc2c(c1)C(CCCCCC)(CCCCCC)c1cc(-c3cc(OCCCCCCCC)c(*)cc3OCCCCCCCC)ccc1-2,0.291
+*c1ccc2c(c1)C(CCCCCC)(CCCCCC)c1cc(-c3cc(OCc4ccccc4)c(*)cc3OCc3ccccc3)ccc1-2,0.184
+*c1ccc2c(c1)SC1=Nc3cc(-c4ccc5c(c4)N=C4Sc6cc(*)ccc6N=C4N5)ccc3NC1=N2,0.506
+*c1ccc2cc(*)ccc2c1,1.59
+*c1ccc2ccc(*)cc2c1,0.221
+*c1ccc2ccc3c(*)cc(C#C)c4ccc1c2c34,0.582
+*c1ccc2ccc3c(*)cc(C#CC=C)c4ccc1c2c34,0.429
+*c1cccc(-c2nc3ccc(-c4ccc5oc(*)nc5c4)cc3o2)c1,0.3795
+*c1cccc2c(*)cccc12,0.685
+*c1nc(-c2ccccc2)nc(N(c2ccccc2)c2ncnc(N(*)c3ccccc3)n2)n1,0.185
+*c1nc(C)nc(N(CCCCCCN(*)c2ccccc2)c2ccccc2)n1,0.21
+*c1nc2cc(-c3ccc4[nH]c(-c5ccc(*)o5)nc4c3)ccc2[nH]1,0.446
+*c1nc2cc3sc(-c4cc(OCCCCCCCCCCCC)c(*)cc4OCCCCCCCCCCCC)nc3cc2s1,0.3647499999999999
+*c1sc(*)c(OCCCCCCCCCCCC)c1C,0.37875
+*c1sc(*)c(OCCCCCCCCCCCCCC)c1C,0.43675
+*c1sc(*)c(OCCCCCCCCCCCCCCCC)c1C,0.388
+*c1sc(*)c(OCCCCCCCCCCCCCCCCCCCC)c1C,0.3747499999999999
+*c1sc(*)c2c1OCC(CCCCCCCCCCCCCCCC)O2,0.44475
+*c1sc(*)c2sc(CCCCCCCCC)nc12,0.482
+*c1sc(-c2cc(CCCCCCCCCC)c(*)s2)cc1CCCCCCCCCC,0.307
+CC1(C)CC(CC(C)(C*)C1)N1C(=O)C2=CC=C(C=C2C1=O)C1=CC2=C(C=C1)C(=O)N(*)C2=O,0.231
+CCNC(=O)OCCCCC(*)=C=C=C(*)CCCCOC(=O)NCC,0.26
+Cc1ccc(cc1)S(=O)(=O)OCCCCC(*)=C=C=C(*)CCCCOS(=O)(=O)c1ccc(C)cc1,0.21
+FC(F)(F)C(C1=CC2=C(OC(=N2)C2=CC=C(OC3=C4C5C6=C(C=CC=C6)C(C6=C5C=CC=C6)C4=C(OC4=CC=C(*)C=C4)C4=C3C3C5=C(C=CC=C5)C4C4=C3C=CC=C4)C=C2)C=C1)(C1=CC=C2OC(*)=NC2=C1)C(F)(F)F,0.109
+FC(F)(F)C(C1=CC2=C(OC(=N2)C2=CC=C(OC3=C4C5C6=C(C=CC=C6)C(C6=C5C=CC=C6)C4=C(OC4=CC=C(*)C=C4)C=C3)C=C2)C=C1)(C1=CC=C2OC(*)=NC2=C1)C(F)(F)F,0.176
+FC(F)(F)C(C1=CC2=C(OC(=N2)C2=CC=C(OC3=CC=C(OC4=CC=C(*)C=C4)C4=C3C3C5=C(C=CC=C5)C4C4=C3C=CC=C4)C=C2)C=C1)(C1=CC=C2OC(*)=NC2=C1)C(F)(F)F,0.155

simson_modeling/kaggle_comp/train_supplement/dataset3.csv

@@ -0,0 +1,47 @@
+SMILES,Tg
+*=Nc1ccc(N=C(C)Nc2ccc(-c3ccc(NC(=*)C)c(C(=O)O)c3)cc2C(=O)O)cc1,89.38045943
+*C(=O)OC(=O)COc1ccc(OCC(=O)OC(=O)c2ccc(*)nc2)cc1,155.9709567
+*C(=O)c1ccc(C(=O)c2ccc(C=C3CCC(=Cc4ccc(*)cc4)C3=O)cc2)cc1,192.2096838
+*C=C(*)c1ccc(OCCCCCC(=O)Oc2c(F)c(F)c(F)c(F)c2F)cc1,73.83198457
+*C=CC1C=CC(*)c2ccc(CCCCCC)cc21,9.70407322
+*CC#CC#CCOc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,48.046331
+*CC(CCCCCCOc1ccc(-c2ccc(C#N)cc2)cc1)COC(=O)N(C)c1ccc(N(C)C(=O)O*)cc1,78.11061669
+*CC1CCCC(*)(CO)C1=O,71.70468573
+*CCC(=O)NNC(=O)c1cccc(C(=O)NNC(=O)c2cccc(O*)c2)c1,234.2133464
+*CCCC(=O)NCc1ccc(CNC(=O)CCCOC(=O)c2ccc(C(=O)O*)cc2)cc1,53.55726117
+*CCCCCCCCCCOc1ccc(C=Cc2ccc(OCCCCCCCCCCOP(=O)(O*)OCCCCCCCCCCOc3ccc(N=Nc4ccc(C)cc4)cc3)cc2)cc1,5.81702489
+*CCCCCCCCCCOc1ccc(C=Cc2ccc(OCCCCCCCCCCOP(=O)(O*)OCCCCCCCCCCOc3ccc(N=Nc4ccc(F)cc4)cc3)cc2)cc1,-7.2122695
+*CCCCCCCOc1ccc(C=CC=Cc2ccc(O*)c(C)c2)cc1C,41.89270134
+*CCCCCCOC(=O)c1ccc(S(=O)(=O)CCCCCCS(=O)(=O)c2ccc(C(=O)O*)cc2)cc1,35.86441642
+*CCCCSSC(=O)N(C)c1ccc(Cc2ccc(N(C)C(=O)SS*)cc2)cc1,20.68923822
+*CCCCc1nc2cc(NC(=NO)C(=NO)Nc3ccc4nc(*)[nH]c4c3)ccc2[nH]1,170.1130329
+*CCNC(=O)c1ccc(C(=O)NCCOC(=O)c2cccc(C(=O)O*)c2)cc1,121.124261
+*CCNC(=S)C=Cc1ccc(Cc2ccc(C=CC(=S)N*)cc2)cc1,99.87529352
+*Cc1cc(C=O)c(O)c(Cc2cc(C=O)c(O)c(CNC(=O)NC(=O)N*)c2)c1,190.6072154
+*Cc1ccc(COC(=O)c2ccccc2C(=O)O*)cc1,95.33964688
+*Cc1ccc(CSC(=O)Nc2ccc(Cc3ccc(NC(=O)S*)cc3)cc2)cc1,90.77725081
+*Cc1ccc2nc(-c3cc(-c4nc5ccc(*)cc5c(=O)o4)cc(N4C(=O)c5c(Cl)c(Cl)c(Cl)c(Cl)c5C4=O)c3)oc(=O)c2c1,378.8956296
+*N=C1C=CC(=NC2=CC(=O)C(*)=CC2=O)C=C1,212.9967182
+*N=Cc1ccc(C=Nc2sc(*)c(C#N)c2C#N)cc1,204.4271705
+*Nc1cc(NC(=O)c2cc(OCCN(C)c3ccc(S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F)cc3)cc(C(*)=O)c2)cc(C(=O)OCCN(C)c2ccc(S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F)cc2)c1,172.7344272
+*Nc1ccc(NC(=O)c2cc(NC(=O)C(CCSC)N3C(=O)c4ccccc4C3=O)cc(C(*)=O)c2)cc1,230.3191562
+*OC(C)CCC(C)OC(=O)Nc1ccc(Cc2ccc(NC(*)=O)cc2)cc1,63.5893379
+*OS(=O)(=O)c1ccc(S(=O)(=O)c2ccc(S(=O)(=O)Oc3ccc(S(=O)(=O)c4ccc(*)cc4)cc3)cc2)cc1,194.2678014
+*OS(=O)(=O)c1ccc(Sc2ccc(S(=O)(=O)Oc3ccc(C4(c5ccc(*)cc5)CCCCC4)cc3)cc2)cc1,157.8104834
+*Oc1c(C(=O)Nc2ccc(NC(=O)c3ccc4ccccc4c3Oc3nc(*)nc(N4CCCCC4)n3)cc2)ccc2ccccc12,162.6671353
+*Oc1c([2H])c([2H])c(C(c2c([2H])c([2H])c(OC(*)=O)c([2H])c2[2H])(C([2H])([2H])[2H])C([2H])([2H])[2H])c([2H])c1[2H],230.9913822
+*Oc1cc(OC(=O)c2ccc(C=Nc3ccc(OCCCCCCOc4ccc(N=Cc5ccc(C(*)=O)cc5)cc4Cl)c(Cl)c3)cc2)c(Cl)cc1Cl,82.06188226
+*Oc1ccc(C(=O)CNc2ccc(NCC(=O)c3ccc(*)cc3)cc2)cc1,158.6944649
+*Oc1ccc(C(=O)OCCCCOC(=O)c2ccc(OC(=O)c3ccc(C(*)=O)cc3)cc2)cc1,68.79315579
+*Oc1ccc(C(C)(CCCC)c2ccc(OC(*)=O)cc2)cc1,118.8361345
+*Oc1ccc(CNC(=O)CCCCCCC(=O)NCc2ccc(OC3COC4C(*)COC34)cc2)cc1,21.58173134
+*Oc1ccc2c(c1)nc1n2C(=O)c2ccc(Oc3ccc4c(c3)C(=O)n3c-4nc4ccc(*)cc43)cc2-1,291.281809
+*Oc1ccc2cc(C(=O)Oc3ccccc3OC(=O)c3ccc4cc(Oc5nc(*)nc(N6CCN(C)CC6)n5)ccc4c3)ccc2c1,54.90728348
+*Oc1cccc(OC(=O)c2ccc(C=Nc3ccc(OCCCCCCOc4ccc(N=Cc5ccc(C(*)=O)cc5)cc4)cc3)cc2)c1,83.83402436
+*c1cc(CCCCCC(F)(F)C(F)(F)C(F)(F)C(F)(F)F)c(-c2cc(CCCCCCCC)c(*)s2)s1,6.47608023
+*c1cc(CCCCCC)c(C=Cc2sc(C=Cc3sc(-c4ccc(*)c5nsnc45)cc3CCCCCC)c(CCCCCC)c2CCCCCC)s1,17.9542177
+*c1ccc(*)c2nccnc12,216.378732
+*c1ccc(-c2ccc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,421.9822435
+*c1ccc(C(=O)CNc2ccc(NCC(=O)c3ccc(S(*)(=O)=O)cc3)cc2)cc1,198.9026743
+*c1ccc2c(c1)C(=O)N(c1c(F)c(F)c(N3C(=O)c4ccc(C(*)(C(F)(F)F)C(F)(F)F)cc4C3=O)c(F)c1F)C2=O,388.0137456
+*c1cccc(N2C(=O)c3ccc(Oc4ccc5c(c4)C(C)(c4ccc(Oc6ccc7c(c6)C(=O)N(c6cccc(N8C(=O)c9ccc(Oc%10ccc(C%11(C)CC(C)(C)c%12cc(Oc%13ccc%14c(c%13)C(=O)N(*)C%14=O)ccc%12%11)cc%10)cc9C8=O)c6)C7=O)cc4)CC5(C)C)cc3C2=O)c1,231.956044

simson_modeling/kaggle_comp/train_supplement/dataset4.csv

@@ -0,0 +1,863 @@
+SMILES,FFV
+*C(=O)NNC(=O)c1ccc([Si](c2ccccc2)(c2ccccc2)c2ccc(C(=O)NNC(=O)c3ccc(*)nc3)cc2)cc1,0.37272461
+*C(=O)NNC(=O)c1ccc([Si](c2ccccc2)(c2ccccc2)c2ccc(C(=O)NNC(=O)c3cncc(*)c3)cc2)cc1,0.36547823
+*C(=O)Nc1cc(NC(=O)c2ccc3[nH]c(-c4cc(-c5nc6cc(*)ccc6[nH]5)cc(N5C(=O)c6ccccc6C5=O)c4)nc3c2)cc(-c2nc3ccccc3[nH]2)c1,0.37637691
+*C(=O)Nc1ccc(-c2cc(-c3ccccc3)cc(-c3ccc(NC(=O)c4ccc5c(c4)C(=O)N(c4cccc(P(=O)(c6ccccc6)c6cccc(N7C(=O)c8ccc(*)cc8C7=O)c6)c4)C5=O)cc3)n2)cc1,0.37693882
+*C(=O)Nc1ccc(-c2ccc(NC(=O)c3ccc4c(c3)C(=O)N(c3ccc(Oc5ccc(N6C(=O)c7ccc(*)cc7C6=O)cc5)cc3)C4=O)cc2)cc1,0.35523486
+*C(=O)Nc1ccc(-c2ccc(NC(=O)c3ccc4c(c3)C(=O)N(c3ccc(S(=O)(=O)c5ccc(N6C(=O)c7ccc(*)cc7C6=O)cc5)cc3)C4=O)cc2)cc1,0.35424303
+*C(=O)Nc1ccc(-c2sc(-c3ccc(NC(=O)c4ccc5c(c4)C(=O)N(c4ccc(Oc6cccc7c(Oc8ccc(N9C(=O)c%10ccc(*)cc%10C9=O)cc8)cccc67)cc4)C5=O)cc3)c(-c3ccccc3)c2-c2ccccc2)cc1,0.38574846
+*C(=O)Nc1ccc(C(c2ccc(NC(=O)c3ccc4c(c3)C(=O)N(c3cccc5c(N6C(=O)c7ccc(*)cc7C6=O)cccc35)C4=O)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.36906594
+*C(=O)Nc1ccc(C2(c3ccc(NC(=O)c4ccc5c(c4)C(=O)N(c4ccc(-c6ccc(N7C(=O)c8ccc(*)cc8C7=O)c(OC)c6)cc4OC)C5=O)cc3)c3ccccc3-c3ccccc32)cc1,0.37058306
+*C(=O)Nc1ccc(C2(c3ccc(NC(=O)c4ccc5c(c4)C(=O)N(c4ccc(Oc6ccc(N7C(=O)c8ccc(*)cc8C7=O)cc6)cc4)C5=O)cc3)c3ccccc3-c3ccccc32)cc1,0.37211646
+*C(=O)Nc1ccc(N=Nc2ccc([N+](=O)[O-])cc2)c(NC(=O)c2ccc3c(c2)C(=O)N(c2c(C)cc(Cc4cc(C)c(N5C(=O)c6ccc(*)cc6C5=O)c(C)c4)cc2C)C3=O)c1,0.37657696
+*C(=O)Nc1ccc(Oc2ccc(-c3ccc(Oc4ccc(NC(=O)c5ccc6c(c5)C(=O)N(c5ccc(C)c(N7C(=O)c8ccc(*)cc8C7=O)c5)C6=O)cc4)cc3)cc2)cc1,0.36178667
+*C(=O)Nc1ccc(Oc2ccc(-c3ccc(Oc4ccc(NC(=O)c5ccc6c(c5)C(=O)N(c5ccc(Oc7ccc(C8(c9ccc(Oc%10ccc(N%11C(=O)c%12ccc(*)cc%12C%11=O)cc%10)cc9)CC9CC8C8CCCC98)cc7)cc5)C6=O)cc4)cc3C)c(C)c2)cc1,0.37683611
+*C(=O)Nc1ccc(Oc2ccc(-c3ccc(Oc4ccc(NC(=O)c5ccc6c(c5)C(=O)N(c5cccc(N7C(=O)c8ccc(*)cc8C7=O)c5)C6=O)cc4)cc3)cc2)cc1,0.35193775
+*C(=O)Nc1ccc(Oc2ccc(C(C)(C)c3ccc(Oc4ccc(NC(=O)c5ccc(N6C(=O)c7ccc(*)cc7C6=O)cc5)cc4)cc3)cc2)cc1,0.36224354
+*C(=O)Nc1ccc(Oc2ccc(C(C)(C)c3ccc(Oc4ccc(NC(=O)c5ccc6c(c5)C(=O)N(c5ccc(Oc7cccc(N8C(=O)c9ccc(*)cc9C8=O)c7)cc5)C6=O)cc4)cc3)cc2)cc1,0.36079128
+*C(=O)Nc1ccc(Oc2ccc(Oc3ccc(NC(=O)c4ccc5c(c4)C(=O)N(c4ccc(-c6sc(-c7ccc(N8C(=O)c9ccc(*)cc9C8=O)cc7)c(-c7ccccc7)c6-c6ccccc6)cc4)C5=O)cc3)cc2)cc1,0.38060777
+*C(=O)Nc1ccc(Oc2cccc(NC(=O)c3ccc4c(c3)C(=O)N(c3ccc(Oc5ccc(C6(c7ccc(Oc8ccc(N9C(=O)c%10ccc(*)cc%10C9=O)cc8)cc7)NC(=O)c7ccccc76)cc5)cc3)C4=O)c2)cc1,0.36268788
+*C(=O)Nc1ccc(Oc2cccc(Oc3ccc(NC(=O)c4ccc5c(c4)C(=O)N(c4cccc(Oc6cccc(Oc7cccc(N8C(=O)c9ccc(*)cc9C8=O)c7)c6C#N)c4)C5=O)cc3)c2)cc1,0.35558372
+*C(=O)Nc1ccc(S(=O)(=O)c2ccc(NC(=O)c3ccc4c(c3)C(=O)N(c3ccc(-c5sc(-c6ccc(N7C(=O)c8ccc(*)cc8C7=O)cc6)c(-c6ccccc6)c5-c5ccccc5)cc3)C4=O)cc2)cc1,0.39133819
+*C(=O)Nc1ccc(S(=O)(=O)c2ccc(NC(=O)c3ccc4c(c3)C(=O)N(c3ccc(NC(=O)Nc5ccc(N6C(=O)c7ccc(*)cc7C6=O)cc5)cc3)C4=O)cc2)cc1,0.34470216
+*C(=O)Nc1ccc(S(=O)(=O)c2ccc(NC(=O)c3ccc4c(c3)C(=O)N(c3cccc(N5C(=O)c6ccc(*)cc6C5=O)c3)C4=O)cc2)cc1,0.35285588
+*C(=O)Nc1ccc(Sc2ccc(NC(=O)c3ccc4c(c3)C(=O)N(c3ccc(Oc5ccc(N6C(=O)c7ccc(*)cc7C6=O)cc5)cc3)C4=O)cc2)cc1,0.35778072
+*C(=O)Nc1cccc(C=CC(=O)C=Cc2cccc(NC(=O)c3ccc(N4C(=O)c5ccc(*)cc5C4=O)cc3)c2)c1,0.34241742
+*C(=O)Nc1cccc(NC(=O)c2ccc3[nH]c(-c4cccc(-c5nc6cc(*)ccc6[nH]5)c4)nc3c2)n1,0.36871452
+*C(=O)Nc1cccc(Oc2ccc(C(=O)c3ccc(Oc4cccc(NC(=O)c5ccc(*)nc5)c4)cc3)cc2)c1,0.3539953
+*C(=O)Nc1cccc(Oc2cccc(Oc3cccc(Oc4cccc(Oc5cccc(NC(=O)c6ccc7c(c6)C(=O)N(c6ccc(Oc8cccc(Oc9ccc(N%10C(=O)c%11ccc(*)cc%11C%10=O)cc9)c8C#N)cc6)C7=O)c5)c4C#N)c3)c2C#N)c1,0.3612591
+*C(=O)Oc1ccc(C(C)(C)c2ccc(OC(=O)c3ccc4c(c3)C(=O)N(c3ccc(Oc5ccc(N6C(=O)c7ccc(*)cc7C6=O)cc5)cc3)C4=O)cc2)cc1,0.36144044
+*C(=O)Oc1ccc(OC(=O)c2ccc3c(c2)C(=O)N(c2ccc(Cc4ccc(N5C(=O)c6ccc(*)cc6C5=O)cc4)cc2)C3=O)c(C(C)(C)C)c1,0.36805651
+*C(=O)Oc1ccc([Si](c2ccccc2)(c2ccccc2)c2ccc(OC(=O)c3ccc(*)s3)cc2)cc1,0.38403914
+*C(=O)c1cc(C(=O)c2ccc3c(c2)C(=O)N(c2ccc(Oc4ccc(N5C(=O)c6ccc(*)cc6C5=O)cc4)cc2)C3=O)cc(C(C)(C)C)c1,0.38251574
+*C(=O)c1cc2c(cc1Cl)C(=O)N(c1cc(Cl)c(N3C(=O)c4cc(*)c(Cl)cc4C3=O)cc1Cl)C2=O,0.40503796
+*C(=O)c1ccc(-c2ccc(C(C)(C)c3ccc(-c4ccc(C(=O)c5ccc6c(c5)C(=O)N(c5ccc(Cc7ccc(N8C(=O)c9ccc(*)cc9C8=O)cc7)cc5)C6=O)cc4)cc3)cc2)cc1,0.38251752
+*C(=O)c1ccc(C(=O)N2CC(C)N(*)CC2C)cc1,0.36842025
+*C(=O)c1ccc(Oc2ccc(Oc3ccc(C(=O)c4ccc5c(c4)C(=O)N(c4ccc(N6C(=O)c7ccc(*)cc7C6=O)cc4)C5=O)cc3)cc2)cc1,0.36785413
+*C(=O)c1ccc(Oc2ccc(S(=O)(=O)c3ccc(Oc4ccc(C(=O)c5ccc6c(c5)C(=O)N(c5ccc(Cc7ccc(N8C(=O)c9ccc(*)cc9C8=O)cc7)cc5)C6=O)cc4)cc3)cc2)cc1,0.37320978
+*C(=O)c1ccc2c(c1)C(=O)N(c1ccc(N3C(=O)c4ccc(*)cc4C3=O)cc1)C2=O,0.37740339
+*C(=O)c1ccc2c(c1)C(=O)N(c1ccc(NC(=O)c3cccc(C(=O)Nc4ccc(N5C(=O)c6ccc(*)cc6C5=O)cc4)c3)cc1)C2=O,0.35291653
+*C(=O)c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(C(=O)c4ccc(C(=O)c5ccc(Oc6ccc(N7C(=O)c8ccc(*)cc8C7=O)cc6)cc5)cc4)cc3)cc1)C2=O,0.37475153
+*C(=O)c1ccc2c(c1)C(=O)N(c1ccc(Oc3cccc4c(Oc5ccc(N6C(=O)c7ccc(*)cc7C6=O)cc5)cccc34)cc1)C2=O,0.3770815
+*C(=O)c1ccc2c(c1)C(=O)N(c1cccc(NC(=O)c3cccc(C(=O)Nc4cccc(N5C(=O)c6ccc(*)cc6C5=O)c4)c3)c1)C2=O,0.3482104
+*C(=O)c1cccc(C(=O)N2CCN(*)CC2)c1,0.34759038
+*C(=O)c1cccc(C(=O)c2ccc(C=C3CCC(=Cc4ccc(*)cc4)C3=O)cc2)c1,0.37124566
+*C(=O)c1cccc(C(=O)c2ccc3c(c2)C(=O)N(c2ccc(Oc4ccc(N5C(=O)c6ccc(*)cc6C5=O)cc4)cc2)C3=O)c1,0.36604695
+*C1C(=O)N(C2CCCCC2)C(=O)C1*,0.39675252
+*C1C(=O)N(CCCOc2ccc(-c3ccc(C#N)cc3)cc2)C(=O)C1*,0.34332558
+*C1C(=O)N(c2cc(Br)c(O[Si](c3ccccc3)(c3ccccc3)c3ccccc3)c(Br)c2)C(=O)C1*,0.40469568
+*C1C(=O)N(c2ccc(O[Si](c3ccccc3)(c3ccccc3)c3ccccc3)cc2)C(=O)C1*,0.40006119
+*C1C=C(CCCCCC)C(*)S1,0.42189435
+*C=CC1CC(*)C(C(=O)OCCCCCCCCOc2ccc(C=Cc3ccc([N+](=O)[O-])cc3)cc2)C1,0.36024408
+*C=Cc1cc(OCCc2ccccc2)c(*)cc1OC,0.36576533
+*C=Cc1ccc(C=Cc2ccc3c(c2)C(CCCCCCOc2ccc4ccc(=O)oc4c2)(CCCCCCOc2ccc4ccc(=O)oc4c2)c2cc(*)ccc2-3)cc1,0.35196182
+*C=Cc1ccc(C=Cc2ccc3c(c2)Sc2cc(*)ccc2N3c2ccc(OCCCCCCCCCCCC)cc2)s1,0.39219852
+*C=Cc1sc(-c2ccc(-c3sc(C=CC4=CC(=C(C#N)C#N)C=C(*)O4)c(CCCCCC)c3CCCCCC)s2)c(CCCCCC)c1CCCCCC,0.41455567
+*CC#CC#CCOc1ccc(C(=O)OCCN(CCOC(=O)c2ccc(O*)cc2)c2ccc(N=Nc3ccc(C#N)cc3)cc2)cc1,0.36879149
+*CC#CC#CCOc1ccc(C(=O)OCCN(CCOC(=O)c2ccc(O*)cc2)c2ccc(N=Nc3ccc([N+](=O)[O-])cc3)cc2)cc1,0.35856006
+*CC#CC#CCOc1cccc(C(=O)OCCN(CCOC(=O)c2cccc(O*)c2)c2ccc(N=Nc3ccc(C#N)cc3)cc2)c1,0.36722522
+*CC(*)(C)C(=O)OC(COc1cccc2ccccc12)COc1cccc2ccccc12,0.35180615
+*CC(*)(C)C(=O)OC1CCCCCCCCC1,0.40440294
+*CC(*)(C)C(=O)OCC1CO1,0.33062914
+*CC(*)(C)C(=O)OCC1OC(n2ccc(=O)[nH]c2=O)C(O)C1O,0.28114011
+*CC(*)(C)C(=O)OCCCCCCCCCCOc1ccc(C(=O)Oc2ccc(C(=O)C=Cc3c(C)c4ccccc4n3C)cc2)cc1,0.36171157
+*CC(*)(C)C(=O)OCCCCCCCCCCOc1ccc(C(=O)Oc2ccc(C(=O)C=Cc3c(C)c4ccccc4n3CCCC)cc2)cc1,0.36405968
+*CC(*)(C)C(=O)OCCCCCCCCOc1ccc(C(=O)Oc2ccc(C(=O)C=Cc3c(C)c4ccccc4n3C)cc2)cc1,0.35752069
+*CC(*)(C)C(=O)OCCCCCCCCOc1ccc(C(=O)Oc2ccc(C(=O)C=Cc3c(C)c4ccccc4n3CCCC)cc2)cc1,0.36425846
+*CC(*)(C)C(=O)OCCCCCCOc1ccc(C(=O)Oc2ccc(C(=O)C=Cc3c(C)c4ccccc4n3C)cc2)cc1,0.35645942
+*CC(*)(C)C(=O)OCCCCCCOc1ccc(C(=O)Oc2ccc(C(=O)C=Cc3c(C)c4ccccc4n3CCCC)cc2)cc1,0.36019365
+*CC(*)(C)C(=O)OCCC[Si]12O[Si]3(CC(C)C)O[Si]4(CC(C)C)O[Si](CC(C)C)(O1)O[Si]1(CC(C)C)O[Si](CC(C)C)(O2)O[Si](CC(C)C)(O3)O[Si](CC(C)C)(O4)O1,0.40617403
+*CC(*)(CC(=O)OC1CCCCCCC1)C(=O)OC1CCCCCCC1,0.36818557
+*CC(*)(CC(=O)OCCC1CCCCC1)C(=O)OCCC1CCCCC1,0.3743525
+*CC(*)(F)C(=O)OCC(F)(F)C(F)(F)C(F)(F)F,0.32178633
+*CC(*)C(=O)N1CCCCC1,0.36828508
+*CC(*)C(=O)Nc1ccc2c(c1)C(=O)c1ccccc1C2=O,0.32709343
+*CC(*)C(=O)OCC1(CC)COC(c2ccccc2)OC1,0.34648032
+*CC(*)C(=O)OCCOc1ccc(C(=O)Oc2ccc(OC(=O)c3ccc(OCCCC)cc3)cc2)cc1,0.3436788
+*CC(*)C(=O)OCCOc1ccc(C(=O)Oc2ccc(OC(=O)c3ccc(OCCCCC)cc3)cc2)cc1,0.34788271
+*CC(*)C(=O)OCCOc1ccc(C(C)(C)c2ccc(OCCO)cc2)cc1,0.33916196
+*CC(*)C(=O)Oc1ccc(C(=O)OCc2ccccc2)cc1,0.33941879
+*CC(*)C(=O)Oc1ccc(C(=O)Oc2ccc(OC(=O)c3ccc(OCCCCC)cc3)cc2)cc1,0.34978241
+*CC(*)N1CCCCCC1=O,0.36209846
+*CC(*)c1ccc(C(=O)CCN2CCCCC2)cc1,0.37311156
+*CC(*)c1ccc(C(=O)N(CC)CC)cc1,0.36711341
+*CC(*)c1ccc(C(=O)N2CCOCC2)cc1,0.35986197
+*CC(*)c1ccc(COCCOCCCC)cc1,0.37958253
+*CC(*)c1ccc(COc2ccc(-c3ccc(-c4ccc(C)s4)c4nsnc34)cc2)cc1,0.36773
+*CC(*)n1cncn1,0.33624313
+*CC(=O)Nc1ccc(Oc2cccc(Oc3ccc(NC(=O)CN4C(=O)c5ccc(C(c6ccc7c(c6)C(=O)N(*)C7=O)(C(F)(F)F)C(F)(F)F)cc5C4=O)cc3)c2)cc1,0.34064566
+*CC(=O)OC(=O)COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.33458907
+*CC(C)(C)C1C(=O)N(C2CCCCC2)C(=O)C1*,0.36558232
+*CC(C)(C)COC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.3487602
+*CC(C)(C)CS(=O)(=O)CC(C)(C)COC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.35233663
+*CC(C)N1C(=O)C2C3C=CC(C4C(=O)N(*)C(=O)C34)C2C1=O,0.3634472
+*CC(CCCCCCCCCCCCCCCC)C(CCCCCCCCCCCCCCCC)COC(=O)c1ccc(C(=O)O*)cc1,0.39720442
+*CC(CO)(CCl)COc1ccc(C(c2ccc(O*)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.35329338
+*CC(COc1c(Cl)cc(C(C)(C)c2cc(Cl)c(O*)c(Cl)c2)cc1Cl)OC(C)=O,0.36697598
+*CC(COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1)OC(=O)C=Cc1ccccc1,0.35543793
+*CC(COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1)OC(=O)CC,0.35519812
+*CC(COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1)OC(=O)CCl,0.35599023
+*CC(COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1)OC(C)=O,0.35142781
+*CC(F)(F)C1(F)CC(C(O)(C(F)(F)F)C(F)(F)F)CC1*,0.32084568
+*CC(O)CN(C)S(=O)(=O)c1cccc(S(=O)(=O)N(C)CC(O)COc2ccc(C(C)(C)c3ccc(O*)cc3)cc2)c1,0.34239354
+*CC(O)CN(C)S(=O)(=O)c1cccc(S(=O)(=O)N(C)CC(O)COc2ccc(O*)cc2)c1,0.33491941
+*CC(O)CN(CC(O)COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1)c1ccc(N=Nc2ccc([N+](=O)[O-])cc2)cc1,0.35223599
+*CC(O)CN(CCO)CC(O)COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.33466845
+*CC(O)COC(=O)/C=C\C(=O)Oc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.33533983
+*CC(O)COC(=O)CCCCC(=O)OCC(O)COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.33384251
+*CC(O)COC(=O)CCCCCCC(=O)OCC(O)COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.34100579
+*CC(O)COC(=O)CCCCCCCCC(=O)OCC(O)COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.3435317
+*CC(O)COC(=O)CCCCCCCCCCC(=O)OCC(O)COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.34941747
+*CC(O)COc1c(C)cc(C(C)(C)c2cc(C)c(O*)c(C)c2)cc1C,0.37509406
+*CC(O)COc1c(Cl)cc(C(C)(C)c2cc(Cl)c(O*)c(Cl)c2)cc1Cl,0.36746955
+*CC(O)COc1ccc(C(C)(C)c2ccc(O*)c(Cl)c2)cc1Cl,0.36275869
+*CC(O)COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.35095055
+*CC(O)COc1ccc(C(C)(CC)c2ccc(O*)cc2)cc1,0.35394579
+*CC(O)COc1ccc(Cc2ccc(O*)cc2)cc1,0.34455061
+*CC(O)COc1ccc(S(=O)(=O)c2ccc(OCC(O)COc3c(C)cc(S(=O)(=O)c4cc(C)c(O*)c(C)c4)cc3C)cc2)cc1,0.35617654
+*CC(O)COc1ccc(S(=O)(=O)c2ccc(OCC(O)COc3ccc(S(=O)(=O)c4ccc(O*)c(C)c4)cc3C)cc2)cc1,0.34891923
+*CC(OC(=O)Oc1ccc(C(=O)OC)cc1)C(COC(=O)O*)OC(=O)Oc1ccc(C(=O)OC)cc1,0.3223452
+*CC(c1ccccn1)C(c1ccccc1)C(*)c1ccccn1,0.39661394
+*CC1(C)CC(N2C(=O)c3ccc(-c4ccc5c(c4)C(=O)N(*)C5=O)cc3C2=O)CC(C)(C)C1,0.37465828
+*CC1CC(CNC(=O)c2cccc(C(=O)N*)c2)CC(C(C)(C)C)C1,0.3514179
+*CC1CCC(CNC(=O)c2cc(C(=O)N*)cc(C(C)(C)C)c2)CC1,0.3576586
+*CC1CCC(CNC(=O)c2cccc(C(=O)N*)c2)CC1,0.34399294
+*CC1CCC(COC(=O)C2CCC(C(=O)O*)CC2)CC1,0.35005916
+*CC1CCC(COC(C)OC(=O)c2ccc(C(=O)OC(C)O*)c3ccccc23)CC1,0.35502936
+*CC1CCCC(CNC(=O)c2cc(C(=O)N*)cc(C(C)(C)C)c2)C1,0.35610431
+*CC1CCCC(CNC(=O)c2cccc(C(=O)N*)c2)C1,0.33940105
+*CC=CCOC(=O)C(Cc1ccccc1)NC(=O)C=CC(=O)NC(Cc1ccccc1)C(=O)O*,0.33875482
+*CCC1CC2C(CC(*)C2OC(=O)CCCCCCCCCCOc2ccc(-c3ccc(C#N)cc3)cc2)C1OC(=O)CCCCCCCCCCOc1ccc(-c2ccc(C#N)cc2)cc1,0.36522309
+*CCCC(C)CN1C(=O)c2ccc(C(=O)Oc3ccc4cc(OC(=O)c5ccc6c(c5)C(=O)N(*)C6=O)ccc4c3)cc2C1=O,0.34177327
+*CCCC1(CCCNC(=O)CCC2(CCC(=O)N*)c3ccccc3-c3ccccc32)c2ccccc2-c2ccccc21,0.35305757
+*CCCCCC(=O)NNC(=O)c1ccc(C(=O)NNC(=O)CCCCCOc2ccc(O*)c(C)c2)cc1,0.34281562
+*CCCCCCCCCCC(=O)Nc1ccc(Cc2ccc(NC(=O)CCCCCCCCCCN3C(=O)c4ccc(C(=O)c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.35192407
+*CCCCCCCCCCCCCCCCOC(=O)CCCCCCC(=O)O*,0.37544747
+*CCCCCCCCCCCCCCCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.36655412
+*CCCCCCCCCCCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.35988995
+*CCCCCCCCCCCN1C(=O)c2ccc(Oc3ccc4c(c3)C(=O)N(*)C4=O)cc2C1=O,0.3550053
+*CCCCCCCCCCCNC(=O)CCCCCCCCC(=O)N*,0.37104926
+*CCCCCCCCCCN1C(=O)C2C3C=CC(C4C(=O)N(*)C(=O)C34)C2C1=O,0.34804179
+*CCCCCCCCCCN1C(=O)c2ccc(Oc3ccc4c(c3)C(=O)N(*)C4=O)cc2C1=O,0.34969426
+*CCCCCCCCCCNC(=O)c1ccc(Cc2ccc(C(=O)N*)cc2)cc1,0.35614349
+*CCCCCCCCCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.35710365
+*CCCCCCCCCCOc1c(OC)cc(C=C2CCCC(=Cc3cc(OC)c(O*)c(OC)c3)C2=O)cc1OC,0.3627628
+*CCCCCCCCCCOc1ccc(C=C2CCCC(=Cc3ccc(O*)c(OC)c3)C2=O)cc1OC,0.36585975
+*CCCCCCCCCCOc1ccc(C=C2CCCC(=Cc3ccc(O*)cc3)C2=O)cc1,0.37076764
+*CCCCCCCCCCOc1ccc(C=Cc2ccc(OCCCCCCCCCCOP(=O)(O*)OCCCCCCCCCCOc3ccc(N=Nc4ccc(Cl)cc4)cc3)cc2)cc1,0.37552981
+*CCCCCCCCCCOc1ccc(C=Cc2ccc(OCCCCCCCCCCOP(=O)(O*)OCCCCCCCCCCOc3ccc(N=Nc4ccc(OC)cc4)cc3)cc2)cc1,0.374166
+*CCCCCCCCCCOc1ccc(C=Cc2ccc(OCCCCCCCCCCOP(=O)(O*)OCCCCCCCCCCOc3ccc(N=Nc4ccc([N+](=O)[O-])cc4)cc3)cc2)cc1,0.36876796
+*CCCCCCCCCCOc1ccc(C=Cc2ccc(OCCCCCCCCCCOP(=O)(O*)OCCCCCCCCCCOc3ccc(N=Nc4ccccc4)cc3)cc2)cc1,0.37909933
+*CCCCCCCCCCc1ccc(-c2c(-c3ccccc3)cc(-c3cccc(-c4cc(-c5ccccc5)c(-c5ccc(*)cc5)c(-c5ccccc5)c4-c4ccccc4)c3)c(-c3ccccc3)c2-c2ccccc2)cc1,0.39826604
+*CCCCCCCCCN1C(=O)c2ccc(Oc3ccc4c(c3)C(=O)N(*)C4=O)cc2C1=O,0.34911033
+*CCCCCCCCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.35367211
+*CCCCCCCCN1C(=O)c2ccc(Oc3ccc4c(c3)C(=O)N(*)C4=O)cc2C1=O,0.34901426
+*CCCCCCCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.35257805
+*CCCCCCCCOC(=O)Nc1ccc(NC(=O)OCCCCCCCCOc2ccc(-c3ccc(O*)cc3)cc2)c(C)c1,0.3579984
+*CCCCCCCCOc1c(OC)cc(C=C2CCCC(=Cc3cc(OC)c(O*)c(OC)c3)C2=O)cc1OC,0.35816729
+*CCCCCCCCOc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.36752126
+*CCCCCCCCOc1ccc(C(c2ccc(O*)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.36265916
+*CCCCCCCCOc1ccc(C=C2CCCC(=Cc3ccc(O*)c(OC)c3)C2=O)cc1OC,0.36354284
+*CCCCCCCCOc1ccc(C=C2CCCC(=Cc3ccc(O*)cc3)C2=O)cc1,0.37127154
+*CCCCCCCCc1nc2cc(NC(=O)CCCCC(=O)Nc3ccc4oc(*)nc4c3)ccc2o1,0.35552869
+*CCCCCCCN1C(=O)c2ccc(Oc3ccc4c(c3)C(=O)N(*)C4=O)cc2C1=O,0.3473574
+*CCCCCCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.34774213
+*CCCCCCN1C(=O)C(=O)N(c2ccc(C)c(N3C(=O)C(=O)N(*)C3=O)c2)C1=O,0.33065809
+*CCCCCCN1C(=O)C(=O)N(c2ccc(Oc3ccc(N4C(=O)C(=O)N(*)C4=O)cc3)cc2)C1=O,0.33381102
+*CCCCCCN1C(=O)c2ccc(Oc3ccc4c(c3)C(=O)N(*)C4=O)cc2C1=O,0.34767207
+*CCCCCCNC(=O)c1cc(NC(=O)c2ccc(NC(=O)C(CC(C)C)N3C(=O)c4ccccc4C3=O)cc2)cc(C(=O)N*)c1,0.33657316
+*CCCCCCNC(=O)c1ccc(C(C)(CC)c2ccc(C(=O)N*)cc2)cc1,0.35362781
+*CCCCCCOC(=O)C(CCCCCOc1cc(-c2ccccn2)nc(-c2ccccn2)c1)C(=O)OCCCCCCOc1ccc(-c2ccc(O*)cc2)cc1,0.36437086
+*CCCCCCOC(=O)C(Cc1ccccc1)NC(=O)C=CC(=O)NC(Cc1ccccc1)C(=O)O*,0.34396826
+*CCCCCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.34648888
+*CCCCCCOc1c(OC)cc(C=C2CCCC(=Cc3cc(OC)c(O*)c(OC)c3)C2=O)cc1OC,0.35644797
+*CCCCCCOc1ccc(C(=O)N(C(=O)c2ccc(O*)cc2)c2ccc(Oc3ccccc3)cc2)cc1,0.36783158
+*CCCCCCOc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.36632136
+*CCCCCCOc1ccc(C=C2CCCC(=Cc3ccc(O*)c(OC)c3)C2=O)cc1OC,0.35895367
+*CCCCCCOc1ccc(C=C2CCCC(=Cc3ccc(O*)cc3)C2=O)cc1,0.36783098
+*CCCCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.34273288
+*CCCCN1C(=O)C2C3C=CC(C4C(=O)N(*)C(=O)C34)C2C1=O,0.34543609
+*CCCCNC(=O)c1ccc(C(C)(CC)c2ccc(C(=O)N*)cc2)cc1,0.34798992
+*CCCCOC(=O)C(Cc1ccccc1)NC(=O)C=CC(=O)NC(Cc1ccccc1)C(=O)O*,0.33930122
+*CCCCOC(=O)CCCCCNC(=O)CCCCC(=O)NCCCCCC(=O)O*,0.34021952
+*CCCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.34189824
+*CCCCOC(=O)c1ccc(-c2ccc(C(=O)O*)cc2)cc1,0.33930265
+*CCCCOC(=O)c1ccc(C(C)(C)c2ccc(C(=O)O*)cc2)cc1,0.35363706
+*CCCCOCCCCOCCCCOC(=O)c1ccc(N=Cc2cc(OCCCCCC)c(C=Cc3cc(OCCCCCC)c(C=Cc4cc(OCCCCCC)c(C=Nc5ccc(C(=O)O*)cc5)cc4OCCCCCC)cc3OCCCCCC)cc2OCCCCCC)cc1,0.38309201
+*CCCN1C(=O)C2C3C=CC(C4C(=O)N(*)C(=O)C34)C2C1=O,0.34806971
+*CCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.33832602
+*CCCOCCCCOCCCN1C(=O)c2ccc(C(=O)Oc3ccc(OC(=O)c4ccc5c(c4)C(=O)N(*)C5=O)cc3)cc2C1=O,0.33583724
+*CCCOCCCCOCCCN1C(=O)c2ccc(C(=O)Oc3ccc4cc(OC(=O)c5ccc6c(c5)C(=O)N(*)C6=O)ccc4c3)cc2C1=O,0.33819968
+*CCN(CCOC(=O)NCC1(C)CC(NC(=O)O*)CC(C)(C)C1)c1ccc(N=Nc2ccc(C#N)cc2)cc1,0.36385839
+*CCN(CCOC(=O)NCC1(C)CC(NC(=O)O*)CC(C)(C)C1)c1ccc(N=Nc2ccc([N+](=O)[O-])cc2)cc1,0.34598899
+*CCN(CCOC(=O)Nc1ccc(-c2ccc(NC(=O)O*)c(C)c2)cc1C)c1ccc(N=Nc2ccc([N+](=O)[O-])cc2)cc1,0.34910461
+*CCN(CCOC(=O)Nc1ccc(-c2ccc(NC(=O)O*)c(OC)c2)cc1OC)c1ccc(N=Nc2ccc([N+](=O)[O-])cc2)cc1,0.34489269
+*CCN(CCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1)c1ccccc1,0.34479226
+*CCN(CCOC(=O)OCc1ccc(COC(=O)O*)cc1)c1ccc(N=Nc2ccc([N+](=O)[O-])cc2)cc1,0.34805417
+*CCN(CCOC(=O)c1cc(OCCN(C)c2ccc(S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F)cc2)cc(C(=O)O*)c1)c1ccc(S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F)cc1,0.34325537
+*CCN(CCOC(=O)c1cc(OCCN(C)c2ccc(S(=O)(=O)CCCCCCCC)cc2)cc(C(=O)O*)c1)c1ccc(S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F)cc1,0.35536738
+*CCN(CCOC(=O)c1cc(OCc2c(F)c(F)c(OC)c(F)c2F)cc(C(=O)O*)c1)c1ccc(C=Cc2ccc(C=CC3=C(C#N)C(=C(C#N)C#N)OC3(c3ccccc3)C(F)(F)F)s2)cc1,0.36032332
+*CCNC(=O)Nc1ccc(Cc2ccc(NC(=O)NCCOCCO*)cc2)cc1,0.33154374
+*CCNC(=O)c1ccc([Si](C)(C)c2ccc(C(=O)NCCN(*)c3ccc(/C=C/c4ccc([N+](=O)[O-])cc4)cc3)cc2)cc1,0.35386775
+*CCNC(=O)c1ccc([Si](CCCC)(CCCC)c2ccc(C(=O)NCCN(*)c3ccc(/C=C/c4ccc([N+](=O)[O-])cc4)cc3)cc2)cc1,0.35921769
+*CCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.33628572
+*CCOC(=O)c1ccc(C(C)(CC)c2ccc(C(=O)O*)cc2)cc1,0.35349899
+*CCOCCOCCN1C(=O)c2ccc(C(=O)Oc3ccc(OC(=O)c4ccc5c(c4)C(=O)N(*)C5=O)cc3)cc2C1=O,0.33052641
+*CCOCCOCCN1C(=O)c2ccc(C(=O)Oc3ccc4cc(OC(=O)c5ccc6c(c5)C(=O)N(*)C6=O)ccc4c3)cc2C1=O,0.3345641
+*CCOCCOCCOCCOC(=O)Nc1ccc(Cc2ccc(NC(=O)O*)cc2)cc1,0.33889511
+*CCOCCOCCOCCOCCOCCOc1ccc(C(=O)Nc2cc(NC(=O)c3ccc(O*)cc3)cc(-c3nc4ccccc4[nH]3)c2)cc1,0.34429063
+*CCOCCOCCOCCOCCOc1ccc(C(=O)Nc2cc(NC(=O)c3ccc(O*)cc3)cc(-c3nc4ccccc4[nH]3)c2)cc1,0.34659235
+*CCOCCOCCOCCOc1ccc(C(=O)Nc2cc(NC(=O)c3ccc(O*)cc3)cc(-c3nc4ccccc4[nH]3)c2)cc1,0.3483589
+*CCOCCOCCOc1ccc(C(=O)Nc2cc(NC(=O)c3ccc(O*)cc3)cc(-c3nc4ccccc4[nH]3)c2)cc1,0.34154325
+*CCOCCOc1ccc(C(=O)Nc2cc(NC(=O)c3ccc(O*)cc3)cc(-c3nc4ccccc4[nH]3)c2)cc1,0.34638057
+*CCOc1ccc(C(=O)Nc2cc(NC(=O)c3ccc(O*)cc3)cc(-c3nc4ccccc4[nH]3)c2)cc1,0.35204064
+*CN1C(=O)c2ccc(C(c3ccc4c(c3)C(=O)N(Cc3nnc(-c5ccc(-c6nnc(*)o6)cc5)o3)C4=O)(C(F)(F)F)C(F)(F)F)cc2C1=O,0.37085226
+*CNC(=O)OCc1cocc1COC(=O)NCc1ccc(C(C)(C)c2ccc(*)o2)o1,0.33476958
+*COc1ccc(C(C)(C)c2ccc(O*)cc2)cc1,0.35264631
+*COc1ccc(C(c2ccc(O*)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.34402643
+*Cc1cc2cc(C(=O)Nc3ccc(-c4ccc(NC(=O)c5cc6cc(*)c(OC(=O)COc7ccc8ccc(=O)oc8c7)cc6oc5=O)cc4)cc3)c(=O)oc2cc1OC(=O)COc1ccc2ccc(=O)oc2c1,0.32178966
+*Cc1ccc(COC(=O)c2cccc(C(=O)O*)c2)cc1,0.34174571
+*Cc1ccc(COP(=O)(N=Nc2ccc(-c3ccc(N=NP(=O)(O*)OC)cc3)cc2)OC)cc1,0.35769989
+*Cc1ccc(C[n+]2ccc(-c3cc[n+](*)cc3)cc2)cc1,0.36770634
+*Cc1ccc2nc(-c3cc(-c4nc5ccc(*)cc5c(=O)o4)cc(N4C(=O)c5ccccc5C4=O)c3)oc(=O)c2c1,0.37326662
+*Cc1cccc(C[n+]2ccc(-c3cc[n+](*)cc3)cc2)c1,0.36232627
+*Cc1ccccc1C[n+]1ccc(-c2cc[n+](*)cc2)cc1,0.35795758
+*N/C(C=C)=C/C=C(\C)C1(c2ccc(N*)cc2)CCCCC1,0.35375342
+*N/N=N\c1ccc(N*)c2c1C(=O)c1c(N)ccc(N)c1C2=O,0.34005083
+*N=P(*)(Oc1ccc2ccccc2c1)Oc1ccc2ccccc2c1,0.3648512
+*NC(=C)/C=C\C(=C/C)C1(c2ccc(N*)cc2)CCCCC1,0.3442031
+*NC/C=C(/c1cccc(-c2ccccc2)c1)c1ccccc1-c1ccccc1-c1ccc(C2(c3ccccc3)c3ccccc3-c3ccccc32)cc1N*,0.37006353
+*NC1=C(N)N[C@H](N*)NC1=O,0.28322193
+*NC1=C(c2c(N*)ccc3ccccc23)c2ccccc2CC1,0.35718606
+*NC1=C(c2ccccc2)[C@@](O)(N*)[C@H](N)C=C1,0.32796087
+*NC1=CC=C(c2ccc(N*)cc2)C(C(C)(C)C)(C(C)(C)C)C1,0.34704926
+*NC1=NC(=S)N=C(N)C1N*,0.30874827
+*NCC1(C)CC(N*)CC(C)(C)C1,0.34576246
+*NCC1CCC(CN*)CC1,0.33576539
+*NCCCc1ccc2ccc3ccc(N*)cc3c2c1,0.33634808
+*NCCc1ccc2ccc3ccc(N*)cc3c2c1,0.33458647
+*NC[C@@H]1CCC[C@@H](CN*)C1,0.32836534
+*NNC(=O)C=CC(=O)Nc1cccc(C=C2CCCC(=Cc3cccc(NC(=O)C=CC(*)=O)c3)C2=O)c1,0.3376016
+*NNC(=O)c1cc(NC(=O)c2ccc3c(c2)C(=O)N(c2ccc(C)cn2)C3=O)cc(C(=O)NNC(=O)c2ccc(C(*)=O)cc2)c1,0.33692653
+*NNC(=O)c1cc(NC(=O)c2ccc3c(c2)C(=O)N(c2ncccc2C)C3=O)cc(C(=O)NNC(=O)c2ccc(C(*)=O)cc2)c1,0.33234263
+*NNC(=O)c1ccccc1C(=O)Nc1cccc(C=C2CCCC(=Cc3cccc(NC(=O)c4ccccc4C(*)=O)c3)C2=O)c1,0.35281266
+*N[C@H]1C(=O)NC(=O)[C@@](N*)(n2c(C)nc3c(N)c(N)cc(N)c3c2=O)[C@H]1N,0.35197979
+*Nc1c(C)cc(C(c2cc(C)c(N*)c(C)c2)C(c2ccc(N)c(C(C)(C)C)c2)c2ccc(N)c(C(C)(C)C)c2)cc1C,0.39156416
+*Nc1c(C)cc(Cc2cc(C)c(N*)c(CC)c2)cc1CC,0.36832
+*Nc1c(CC)cc(Cc2cc(CC)c(N*)c(CC)c2)cc1CC,0.37359767
+*Nc1c(CC)cc(Cc2cc(CC)c(N*)c(CC)c2Cl)c(Cl)c1CC,0.37886544
+*Nc1c(N)c2c(c(N*)c1NC)C(=O)c1cccc(N)c1C2=O,0.34496829
+*Nc1c(N*)c(-c2ccccc2-c2ccccc2)c(-c2ccccc2)c(-c2ccccc2)c1-c1ccccc1,0.37334739
+*Nc1cc(C(c2ccc(C)c(N*)c2)(C(F)(F)F)C(F)(F)F)ccc1C,0.34739951
+*Nc1cc(C(c2ccc(O)c(N*)c2)(C(F)(F)F)C(F)(F)F)ccc1O,0.32241826
+*Nc1cc(C)c(-c2c(C)cc(N*)cc2-c2ccccc2)c(-c2ccccc2)c1,0.36600387
+*Nc1cc(C)c(C2(c3c(C)cc(N*)c4ccccc34)c3ccccc3-c3ccccc32)c2ccccc12,0.38470754
+*Nc1cc(C)c(Cc2ccc(CCCCCCCCCCCCCc3ccc(Cc4c(C)cc(N*)cc4C)cc3)cc2)c(C)c1,0.35997455
+*Nc1cc(C)c(Cc2ccc(CCCCCCCCCCCCc3ccc(Cc4c(C)cc(N*)cc4C)cc3)cc2)c(C)c1,0.35798452
+*Nc1cc(C)c(Cc2ccc(CCCCCCCCCc3ccc(Cc4c(C)cc(N*)cc4C)cc3)cc2)c(C)c1,0.36147124
+*Nc1cc(C)c(Cc2ccc(CCCCCCCCc3ccc(Cc4c(C)cc(N*)cc4C)cc3)cc2)c(C)c1,0.35897643
+*Nc1cc(C)c(N*)c2c1C(=O)c1c(N)c(C)cc(N)c1C2=O,0.34660788
+*Nc1cc(C2CCCCC2)c2ccc3c(N*)c(-c4ccc(C5(c6ccccc6)c6ccccc6-c6ccccc65)cc4)c(C4CCCCC4)c4ccc1c2c34,0.39403941
+*Nc1cc(N)c(N)c(C)c1C(=O)Oc1cc(N)c(C(=O)Oc2cc(N)c(N)c(C)c2N)c(N)c1N*,0.32137021
+*Nc1cc(N*)c(Cc2cc(C)c(N)cc2N)cc1C,0.35659354
+*Nc1cc(N*)c2c(ccc3ccccc32)c1,0.33406138
+*Nc1cc(N*)c2ccc3ccccc3c2c1,0.33145622
+*Nc1cc(NC(=O)Nc2ccc(Cc3ccc(NC(*)=O)cc3)cc2)cc(C(=O)Nc2ccc3c(c2)C(=O)c2ccccc2C3=O)c1,0.33705899
+*Nc1cc(NC(=O)Nc2ccc(NC(*)=O)cc2)cc(C(=O)Nc2cccc3c2C(=O)c2ccccc2C3=O)c1,0.32684433
+*Nc1cc(NC(=O)c2cc(NC(=O)C(C(C)CC)N3C(=O)c4ccccc4C3=O)cc(C(*)=O)c2)ccc1C,0.34847575
+*Nc1cc(NC(=O)c2cc(OCCN(C)c3ccc(C#N)cc3)cc(C(*)=O)c2)cc(C(=O)OCCN(C)c2ccc(C#N)cc2)c1,0.35581869
+*Nc1cc(NC(=O)c2cc(OCCN(C)c3ccc(C#N)cc3)cc(C(*)=O)c2)cc(C(=O)OCCN(C)c2ccc(S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F)cc2)c1,0.34405633
+*Nc1cc(NC(=O)c2cc(OCCN(C)c3ccc(S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F)cc3)cc(C(*)=O)c2)cc(C(=O)OCCN(C)c2ccc(C#N)cc2)c1,0.3482804
+*Nc1cc(NC(=O)c2ccc(C(*)=O)cc2)cc(C(=O)Oc2cccc3ccccc23)c1,0.34233379
+*Nc1cc(NC(=O)c2ccc3cc(C(*)=O)ccc3c2)cc(C(=O)OCCOc2ccc(C=CC(=O)c3ccccc3)cc2)c1,0.34387133
+*Nc1cc2c(-c3ccc4c(c3)c3ccccc3c3c(N*)c(N)ccc43)cc3c4ccccc4ccc3c2cc1N,0.3459392
+*Nc1cc2c(N*)cccc2c2ccccc12,0.333837
+*Nc1cc2c(cc(N*)c3c(-c4ccc5ccccc5c4)c(-c4ccc5ccccc5c4)c(-c4ccc5ccccc5c4)c(-c4ccc5ccccc5c4)c32)c2ccccc12,0.37064494
+*Nc1cc2c(cc1N*)C(=O)c1cc(N)c(N)cc1C2=O,0.34542857
+*Nc1cc2c3cccc(-c4ccc(C)c(C)c4)c3c(N*)cc2c2ccccc12,0.35695006
+*Nc1cc2cccc(N*)c2c2ccccc12,0.33765318
+*Nc1cc2ccccc2c(N*)c1-c1ccccc1,0.3508717
+*Nc1cc2ccccc2c2c(N*)cccc12,0.33679998
+*Nc1cc2ccccc2c2c1ccc1ccc3c(N*)cc4ccccc4c3c12,0.36566777
+*Nc1ccc(*)cc1OCCCCCCCCCCOc1ccc(C2CCC(CCCCC)CC2)cc1,0.3832015
+*Nc1ccc(-c2c(-c3ccccc3)cc(-c3ccc(-c4cc(-c5ccccc5)c(-c5ccc(NC(=O)c6ccc(C(*)=O)cc6)cc5)c(-c5ccccc5)c4)cc3)cc2-c2ccccc2)cc1,0.38336728
+*Nc1ccc(-c2c(C(C)C)cc(C)cc2C2(c3cc(C)cc(C(C)C)c3-c3ccc(N*)cc3)c3ccccc3-c3ccccc32)cc1,0.39756786
+*Nc1ccc(-c2cc(-c3ccc(-c4ccccc4)cc3)cc(-c3ccc(-c4cc(-c5ccc(N*)cc5)cc(-c5ccc(-c6ccccc6)cc5)c4)cc3)c2)cc1,0.35431916
+*Nc1ccc(-c2cc(-c3ccc(N*)cc3)c3ccc4c(-c5ccc(N)cc5)cc(-c5ccc(N)cc5)c5ccc2c3c54)cc1,0.36303147
+*Nc1ccc(-c2ccc(-c3ccc(N*)c(-c4ccc5ccccc5c4)c3-c3ccc4ccccc4c3)c(-c3ccc4ccccc4c3)c2)c(-c2ccc3ccccc3c2)c1,0.36605712
+*Nc1ccc(-c2ccc(-c3ccc(N*)cc3)c3c2CC2(CCCC2)C3)cc1,0.35946418
+*Nc1ccc(-c2ccc(N*)c(-c3ccc(-c4ccccc4)cc3)c2-c2ccc(-c3ccccc3)cc2)cc1,0.35925281
+*Nc1ccc(-c2ccc(N*)c(-c3cccc(C)c3-c3ccccc3)c2)cc1,0.35748308
+*Nc1ccc(-c2ccc(N*)c(/C=C/c3ccccc3)c2)cc1,0.34484999
+*Nc1ccc(-c2ccc(N*)c(Cc3ccccc3)c2Cc2ccccc2)c(Cc2ccccc2)c1Cc1ccccc1,0.35710982
+*Nc1ccc(-c2ccc(N*)c(N)c2-c2ccccc2)c(-c2ccccc2)c1N,0.35339596
+*Nc1ccc(-c2ccc(N*)cc2-c2cc(N)ccc2-c2ccc(N)cc2)cc1,0.36187072
+*Nc1ccc(-c2ccc(N*)cc2-c2ccc(C)cc2)c(-c2ccc(C)cc2)c1,0.36702255
+*Nc1ccc(-c2ccc(N*)cc2-c2ccc(C)cc2C)c(-c2ccc(C)cc2C)c1,0.37675264
+*Nc1ccc(-c2ccc(N*)cc2-c2ccc(C=C)cc2)c(-c2ccc(C=C)cc2)c1,0.35833444
+*Nc1ccc(-c2ccc(N*)cc2-c2ccc(CC)cc2)c(-c2ccc(CC)cc2)c1,0.36900944
+*Nc1ccc(-c2ccc(N*)cc2-c2cccc(C)c2)c(-c2cccc(C)c2)c1,0.36515839
+*Nc1ccc(-c2ccc(N*)cc2-c2cccc(CC)c2)c(-c2cccc(CC)c2)c1,0.36267578
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2)c(-c2ccccc2)c1,0.35575719
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2-c2ccc(C)cc2)cc1,0.35953405
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2-c2ccccc2)cc1,0.35741644
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2-c2ccccc2C)cc1,0.36316601
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2C(C)(C)C)c(-c2ccccc2C(C)(C)C)c1,0.37633983
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2C(C)C)c(-c2ccccc2C(C)C)c1,0.37695577
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2C)c(-c2ccccc2C)c1,0.36761088
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2CC)c(-c2ccccc2CC)c1,0.3676166
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2CC=C)c(-c2ccccc2CC=C)c1,0.35805994
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2CCC)c(-c2ccccc2CCC)c1,0.36819448
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2CCCC)c(-c2ccccc2CCCC)c1,0.36989526
+*Nc1ccc(-c2ccc(N*)cc2-c2ccccc2[C@@H](C)CC)c(-c2ccccc2[C@@H](C)CC)c1,0.37601542
+*Nc1ccc(-c2ccc(N*)cc2/C(N)=C/c2ccccc2)c(/C(N)=C/c2ccccc2)c1,0.35009849
+*Nc1ccc(-c2ccccc2)c(C2CCCCC2)c1N*,0.37359962
+*Nc1ccc(-c2ccccc2-c2ccccc2-c2ccc(N*)cc2)cc1,0.35490612
+*Nc1ccc(/C(=C(/c2ccc3ccccc3c2)c2ccc(N*)c(-c3ccc4ccccc4c3)c2-c2ccc3ccccc3c2)c2ccc3ccccc3c2)cc1,0.37988811
+*Nc1ccc(/C(C)=C/C(C)(C)c2ccc(N*)cc2)cc1,0.35500937
+*Nc1ccc(/C=C/c2ccc(N*)cc2-c2ccccc2)c(-c2ccccc2)c1,0.35626419
+*Nc1ccc(/C=C/c2ccc3ccccc3c2/C=C/c2ccc(N*)cc2)cc1,0.35372743
+*Nc1ccc(C(=C)C(C)(C)C(C)(C)c2ccc(N*)cc2)cc1,0.34980902
+*Nc1ccc(C(=C)CC(C)(C)c2ccc(N*)cc2)cc1,0.34510572
+*Nc1ccc(C(=C2CCCCC2)c2ccc(N*)cc2)cc1,0.37173273
+*Nc1ccc(C(C)(C)c2cc(C(C)(C)c3ccc(N)cc3)cc(C(C)(C)c3ccc(N*)cc3)c2)cc1,0.36915657
+*Nc1ccc(C(C)(C)c2ccc(C(C)(C)c3ccc(N*)cc3)cc2)cc1,0.35733218
+*Nc1ccc(C(C)(C)c2ccc(C(C)(C)c3cccc(N*)c3)cc2)cc1,0.35860249
+*Nc1ccc(C(C)(C)c2ccc(N*)cc2)cc1,0.34514842
+*Nc1ccc(C(C)(C=C)c2ccc(N*)cc2)cc1,0.34310285
+*Nc1ccc(C(C)(CC(C)C)c2ccc(N*)cc2)cc1,0.35303022
+*Nc1ccc(C(C)(CC)c2ccc(N*)cc2)cc1,0.35054839
+*Nc1ccc(C(C)(CC=C)c2ccc(N*)cc2)cc1,0.34950176
+*Nc1ccc(C(C)(CCC(C)C)c2ccc(N*)cc2)cc1,0.3593959
+*Nc1ccc(C(C)(CCC)c2ccc(N*)cc2)cc1,0.35256265
+*Nc1ccc(C(C)(CCCC)c2ccc(N*)cc2)cc1,0.35842613
+*Nc1ccc(C(C)(CCCCC)c2ccc(N*)cc2)cc1,0.35858625
+*Nc1ccc(C(C)(CCCCCC)c2ccc(N*)cc2)cc1,0.36233629
+*Nc1ccc(C(C)(c2ccc(N*)cc2)C(C)C)cc1,0.35465545
+*Nc1ccc(C(C)(c2ccc(N*)cc2)[C@H](C)C(=C)C)cc1,0.35652932
+*Nc1ccc(C(CC(C)(C)c2ccc(N*)cc2)=C(C)C)cc1,0.35535977
+*Nc1ccc(C(CC(C)C)(CC(C)C)c2ccc(N*)cc2)cc1,0.36637357
+*Nc1ccc(C(CC)(C/C=C/[C@@H](C)CCC)c2ccc(N*)cc2)cc1,0.36522046
+*Nc1ccc(C(CC)(CC)c2ccc(N*)cc2)cc1,0.3582996
+*Nc1ccc(C(CC)(CCC(C)C)c2ccc(N*)cc2)cc1,0.36819424
+*Nc1ccc(C(CC)(CCC)c2ccc(N*)cc2)cc1,0.35892089
+*Nc1ccc(C(CC)(CCCC)c2ccc(N*)cc2)cc1,0.36309206
+*Nc1ccc(C(CC)(CCCCC)c2ccc(N*)cc2)cc1,0.36534914
+*Nc1ccc(C(CC)(CCCCCC)c2ccc(N*)cc2)cc1,0.36353044
+*Nc1ccc(C(CC)(C[C@H](C)CC)c2ccc(N*)cc2)cc1,0.35671255
+*Nc1ccc(C(CC)c2ccc(N*)c(Cc3ccccc3)c2Cc2ccccc2)c(Cc2ccccc2)c1Cc1ccccc1,0.36855173
+*Nc1ccc(C(CC=C)(CC=C)c2ccc(N*)cc2)cc1,0.34731572
+*Nc1ccc(C(CC=C)c2ccc(N*)cc2)cc1,0.34719504
+*Nc1ccc(C(CCC)(CCC)c2ccc(N*)cc2)cc1,0.36239191
+*Nc1ccc(C(CCCC)(CCCC)c2ccc(N*)cc2)cc1,0.3699291
+*Nc1ccc(C(C[C@@H]2CCC[C@@H](C(c3ccc(N)cc3)c3ccc(N*)cc3)C2)c2ccc(N)cc2)cc1,0.36461546
+*Nc1ccc(C(c2ccc(N*)c(C(C)(C)C)c2)C(c2ccc(N)c(C(C)(C)C)c2)c2ccc(N)c(C(C)(C)C)c2)cc1C(C)(C)C,0.3977767
+*Nc1ccc(C(c2ccc(N*)c(C)c2)C(c2ccc(N)c(C)c2)c2ccc(N)c(C)c2)cc1C,0.38150109
+*Nc1ccc(C(c2ccc(N*)cc2)(C(C)C)C(C)C)cc1,0.36562181
+*Nc1ccc(C(c2ccc(N*)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.34186008
+*Nc1ccc(C(c2ccc(N*)cc2)([C@H](C)CC)[C@H](C)CC)cc1,0.37291553
+*Nc1ccc(C(c2ccc(N*)cc2)C(C)(C)C)cc1,0.3599413
+*Nc1ccc(C(c2ccc(N*)cc2)C(c2ccc(N)cc2)c2ccc(N)cc2)cc1,0.36559722
+*Nc1ccc(C(c2ccc(N*)cc2)C(c2cccc(N)c2)c2cccc(N)c2)cc1,0.35897099
+*Nc1ccc(C(c2ccc(N*)cc2)C(c2ccccc2N)(c2ccccc2N)[C@H](c2ccc(N)cc2)c2ccccc2N)cc1,0.36452149
+*Nc1ccc(C(c2ccc(NC(=O)c3cc(NC(=O)CCCN4C(=O)c5ccccc5C4=O)cc(C(*)=O)c3)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.33372764
+*Nc1ccc(C2(c3ccc(N*)c(-c4ccc(C)cc4)c3-c3ccc(C)cc3)CCCCC2)c(-c2ccc(C)cc2)c1-c1ccc(C)cc1,0.39222234
+*Nc1ccc(C2(c3ccc(N*)c(C)c3)c3ccccc3Cc3ccccc32)cc1C,0.37721583
+*Nc1ccc(C2(c3ccc(N*)cc3)C=CC=C3C2=Cc2ccccc23)cc1,0.36753725
+*Nc1ccc(C2(c3ccc(N*)cc3)CCCC2)cc1,0.34564076
+*Nc1ccc(C2(c3ccc(N*)cc3)CCc3ccccc32)cc1,0.35743146
+*Nc1ccc(C2(c3ccc(N*)cc3)[C@H]3C[C@@H]4C[C@@H](C[C@H]2C4)C3)cc1,0.36122631
+*Nc1ccc(C2(c3ccc(N*)cc3)c3ccccc3Cc3ccccc32)cc1,0.36815633
+*Nc1ccc(C2=CC=C(c3ccc(N*)cc3)C2(C)C)cc1,0.35499932
+*Nc1ccc(C2=CC[C@](N*)(c3ccccc3-c3ccccc3C)C=C2)cc1,0.35437873
+*Nc1ccc(C2=C[C@@H]3CC[C@H]2C=C3c2ccc(N*)cc2)cc1,0.35798661
+*Nc1ccc(CC[C@@H](Cc2ccc(N*)cc2)[C@@H](Cc2ccc(N)cc2)c2ccccc2)cc1,0.35442602
+*Nc1ccc(CCc2ccc(C3(c4ccc(CCc5ccc(N*)cc5)cc4)CCC(c4ccccc4)CC3)cc2)cc1,0.362202
+*Nc1ccc(Cc2cc(Cc3ccc(N)cc3)cc(Cc3ccc(N*)cc3)c2)cc1,0.36046154
+*Nc1ccc(Cc2ccc(Cc3ccc(N*)c(C)c3C)cc2)c(C)c1C,0.35499508
+*Nc1ccc(Cc2ccc(Cc3ccc(N*)cc3)cc2)cc1,0.34845951
+*Nc1ccc(Cc2ccc(N*)c(C)c2)c(CC)c1,0.3496197
+*Nc1ccc(Cc2ccc(N*)c(C)c2)cc1C,0.35117058
+*Nc1ccc(Cc2ccc(N*)c(C)c2C)c(C)c1,0.35276469
+*Nc1ccc(Cc2ccc(N*)c(C)c2C)c(C)c1C,0.35444913
+*Nc1ccc(Cc2ccc(N*)c(CC)c2CC)c(CC)c1CC,0.37391243
+*Nc1ccc(Cc2ccc(N*)c(CC=C)c2CC=C)c(CC=C)c1CC=C,0.35378076
+*Nc1ccc(Cc2ccc(N*)c(Cl)c2)cc1Cl,0.3514118
+*Nc1ccc(Cc2ccc(N*)cc2)cc1,0.34181931
+*Nc1ccc(Cc2ccc(NC(=O)CCCCCCCC(*)=O)cc2)cc1,0.34905905
+*Nc1ccc(Cc2ccc(NC(=O)CCCCCCCCC(*)=O)cc2)cc1,0.35151514
+*Nc1ccc(Cc2ccc(NC(=O)NCCCCCCCCCCCCCCCCCCNC(*)=O)cc2)cc1,0.37009241
+*Nc1ccc(Cc2ccc(NC(=O)NCCCCCCCCCCCCNC(*)=O)cc2)cc1,0.35680733
+*Nc1ccc(Cc2ccc(NC(=O)NCCCCCCCCCCNC(*)=O)cc2)cc1,0.35544532
+*Nc1ccc(Cc2ccc(NC(=O)NCCCCCCCCCNC(*)=O)cc2)cc1,0.35319219
+*Nc1ccc(Cc2ccc(NC(=O)NCCCCCCCCNC(*)=O)cc2)cc1,0.35239715
+*Nc1ccc(Cc2ccc(NC(=O)NCCCCCCNC(*)=O)cc2)cc1,0.34117859
+*Nc1ccc(Cc2ccc(NC(=O)Nc3ccccc3CCc3ccc(NC(*)=O)cc3)cc2)cc1,0.35103259
+*Nc1ccc(Cc2ccc(NC(=O)c3cc(C(*)=O)cc(N4C(=O)C5C6C=CC(C6)C5C4=O)c3)cc2)cc1,0.35689692
+*Nc1ccc(Cc2ccc(NC(=O)c3cc(NC(=O)CCCN4C(=O)c5ccccc5C4=O)cc(C(*)=O)c3)cc2)cc1,0.33667621
+*Nc1ccc(Cc2ccc(NC(=O)c3cc(NC(=O)c4ccc(NC(=O)C(CC(C)C)N5C(=O)c6ccccc6C5=O)cc4)cc(C(*)=O)c3)cc2)cc1,0.34741181
+*Nc1ccc(Cc2cccc(N*)c2)cc1,0.33815386
+*Nc1ccc(N*)c(-c2ccc3ccccc3c2)c1,0.34047659
+*Nc1ccc(N*)c(C(c2ccc3ccccc3c2)c2ccc3ccccc3c2)c1,0.36285479
+*Nc1ccc(N*)c2c1ccc1ccccc12,0.33816871
+*Nc1ccc(NC(=O)Cc2cc(C)c(CC(*)=O)cc2C)cc1,0.3373035
+*Nc1ccc(NC(=O)Cc2cc(CC(*)=O)c(C)cc2C)cc1,0.33730529
+*Nc1ccc(NC(=O)c2cc(C(*)=O)cc(S(=O)(=O)c3ccccc3)c2)cc1,0.34297424
+*Nc1ccc(NC(=O)c2ccc(C(=O)c3ccc(C(*)=O)c(C(=O)O)c3)cc2C(=O)O)cc1,0.31794387
+*Nc1ccc(NC(=O)c2ccc(C(=O)c3ccc(C(*)=O)c(C(=O)OCC)c3)cc2C(=O)OCC)cc1,0.34534308
+*Nc1ccc(NC(=O)c2ccc(NC(=O)CCCCCCC(=O)Nc3ccc(C(*)=O)cc3)cc2)cc1C(=O)OCCCCCCCCCCCCCCCCCC,0.35844067
+*Nc1ccc(NC(=O)c2ccc(NC(=O)CCCCCCCCCCCCC(=O)Nc3ccc(C(*)=O)cc3)cc2)cc1C(=O)OCCCCCCCCCCCC,0.35882755
+*Nc1ccc(NC(=O)c2ccc(NC(=O)CCCCCCCCCCCCC(=O)Nc3ccc(C(*)=O)cc3)cc2)cc1C(=O)OCCCCCCCCCCCCCC,0.3595526
+*Nc1ccc(NC(=O)c2ccc(NC(=O)CCCCCCCCCCCCC(=O)Nc3ccc(C(*)=O)cc3)cc2)cc1C(=O)OCCCCCCCCCCCCCCCC,0.36201115
+*Nc1ccc(NC(=O)c2ccc(NC(=O)CCCCCCCCCCCCC(=O)Nc3ccc(C(*)=O)cc3)cc2)cc1C(=O)OCCCCCCCCCCCCCCCCCC,0.36659861
+*Nc1ccc(Oc2ccc(S(=O)(=O)c3ccc(Oc4ccc(N*)cc4)cc3)cc2)cc1,0.34442362
+*Nc1ccc(Oc2cccc(Oc3ccc(N*)cc3)c2)cc1,0.34111608
+*Nc1ccc(SSc2ccc(N*)cc2)cc1,0.35710288
+*Nc1ccc([C@@H](C)c2ccc(C(C)(C)c3ccc(N*)cc3)cc2)cc1,0.35607415
+*Nc1ccc([C@@H](c2ccccc2)[C@H](c2ccccc2)c2ccc(N*)cc2)cc1,0.36377948
+*Nc1ccc([C@@H]2CC(C)(C)c3cc(N*)ccc32)cc1,0.36237935
+*Nc1ccc([C@@H]2CC(C)(C)c3ccc(N*)cc32)cc1,0.3624745
+*Nc1ccc([C@H](CC)c2ccc([C@@H](CC)c3ccc(N*)cc3)cc2)cc1,0.3623964
+*Nc1ccc([C@H](CCCC)c2ccc(C3(c4ccc([C@@H](CCCC)c5ccc(N*)cc5C)cc4)CCC(C)CC3)cc2)c(C)c1,0.38081893
+*Nc1ccc([C@H](CCCCCC)c2ccc(C3(c4ccc([C@@H](CCCCCC)c5ccc(N*)cc5)cc4)CCC(CCCCC)CC3)cc2)cc1,0.37108303
+*Nc1ccc([C@H](c2ccc(N*)c(C)c2)C(c2ccc(N)c(C)c2)c2ccc(N)c(C)c2)cc1,0.37242979
+*Nc1ccc([C@H](c2cccc(N*)c2)C(c2cccc(N)c2)c2cccc(N)c2)cc1,0.35918801
+*Nc1ccc([C@H](c2ccccc2N*)C(c2ccc(N)cc2)c2ccc(N)cc2)cc1,0.37002899
+*Nc1ccc([C@H]2CC[C@H](c3ccc(N*)cc3)CC2)cc1,0.35770572
+*Nc1ccc2c(N*)cc3ccccc3c2c1,0.334748
+*Nc1ccc2c(c1)-c1ccc3c4ccc5c6c(ccc(c7ccc(c1c73)C2)c64)-c1cc(N*)ccc1C5,0.34349672
+*Nc1ccc2c(c1)C(=O)c1ccc(N*)cc1C2=O,0.33028392
+*Nc1ccc2c(c1)[C@]1(C)CC[C@@]2(C)c2cc(N*)ccc21,0.36507821
+*Nc1ccc2c(c1)c(C)c(C)c1cc(N*)ccc12,0.33627798
+*Nc1ccc2c(c1)c(N*)cc1ccccc12,0.33211721
+*Nc1ccc2c(c1)cc(N*)c1ccccc12,0.33817655
+*Nc1ccc2c(c1N*)CCc1ccccc1-2,0.341292
+*Nc1ccc2c(ccc3c(N*)cccc32)c1,0.3358041
+*Nc1ccc2c(ccc3cc(N*)ccc32)c1,0.3363309
+*Nc1ccc2c(ccc3ccc(N*)cc32)c1,0.33807688
+*Nc1ccc2c(ccc3ccc4ccc5ccc6cc(N*)ccc6c5c4c32)c1,0.3586391
+*Nc1ccc2c(ccc3cccc(N*)c32)c1,0.3331587
+*Nc1ccc2c(ccc3ccccc32)c1N*,0.3361781
+*Nc1ccc2c3cc(-c4ccc(-c5ccccc5)cc4)c(-c4ccc(-c5ccccc5)cc4)c4c(N*)c(-c5ccc(-c6ccccc6)cc5)c(-c5ccc(-c6ccccc6)cc5)c(c5cccc1c25)c43,0.3619219
+*Nc1ccc2cc(N*)c3ccccc3c2c1,0.33919037
+*Nc1ccc2ccc3ccc(N*)cc3c2c1,0.33497194
+*Nc1ccc2ccc3cccc(N*)c3c2c1,0.32965144
+*Nc1ccc2ccc3ccccc3c2c1N*,0.33674811
+*Nc1cccc(-c2cc(N*)ccc2-c2ccccc2-c2ccccc2)c1,0.35340744
+*Nc1cccc(-c2ccccc2-c2cc(N*)ccc2-c2ccccc2)c1,0.35219454
+*Nc1cccc(-c2ccccc2-c2ccccc2-c2cccc(N*)c2)c1,0.35392163
+*Nc1cccc(-c2ccccc2-c2ccccc2-c2ccccc2)c1N*,0.35659206
+*Nc1cccc(C(c2cccc(N*)c2)(C(F)(F)F)C(F)(F)F)c1,0.34059386
+*Nc1cccc(Cc2cccc(N*)c2)c1,0.33697796
+*Nc1cccc(NC(=C(C#N)C#N)c2cccc(C(*)=C(C#N)C#N)c2)c1,0.41003738
+*Nc1cccc(NC(=O)Cc2cc(C)c(CC(*)=O)cc2C)c1,0.3367393
+*Nc1cccc(NC(=O)Cc2cc(CC(*)=O)c(C)cc2C)c1,0.33294467
+*Nc1cccc(NC(=O)c2cc(C(*)=O)cc(S(=O)(=O)c3ccccc3)c2)c1,0.34798034
+*Nc1cccc(NC(=O)c2cc(NC(=O)C(CCSC)N3C(=O)c4ccccc4C3=O)cc(C(*)=O)c2)c1,0.33770588
+*Nc1cccc(Oc2ccc(S(=O)(=O)c3ccc(Oc4cccc(N*)c4)cc3)cc2)c1,0.34393632
+*Nc1cccc(Oc2cccc(Oc3cccc(N*)c3)c2)c1,0.33787009
+*Nc1cccc2c(NC(=O)c3ccc(C(*)=O)cc3)cccc12,0.34599686
+*Nc1cccc2c(NC(=O)c3ccc(NC(=O)c4ccc([Si](C)(C)c5ccc(C(=O)Nc6ccc(C(*)=O)cc6)cc5)cc4)cc3)cccc12,0.3612299
+*Nc1cccc2c1C(=O)c1cccc(N[Se]*)c1C2=O,0.3481788
+*Nc1cccc2c1C1=C(C[C@](N*)(c3ccccc3-c3ccccc3)C=C1)C2(c1ccccc1)c1ccccc1,0.37540911
+*Nc1cccc2c1c(N*)cc1ccccc12,0.33290552
+*Nc1cccc2c1ccc1c(N*)cccc12,0.33410164
+*Nc1cccc2c1ccc1cccc(N*)c12,0.33883964
+*Nc1cccc2ccc3cccc(N*)c3c12,0.34248529
+*Nc1ccccc1-c1cccc(-c2ccccc2-c2cccc(-c3ccccc3)c2)c1N*,0.35563081
+*Nc1ccccc1-c1ccccc1-c1ccccc1-c1ccccc1N*,0.35892837
+*Nc1ccccc1/C=C/c1ccc2ccccc2c1/C=C/c1ccccc1N*,0.35648517
+*Nc1ccccc1CCc1ccccc1NC(=O)Nc1ccc(CCc2ccc(NC(*)=O)cc2)cc1,0.35411182
+*Nc1ccccc1SSc1ccccc1N*,0.35017586
+*Nc1nc(=O)n(C)c(N*)c1N,0.31039992
+*OC(=O)C(Cc1ccccc1)NC(=O)CCCCCCC(=O)NC(Cc1ccccc1)C(=O)OC1COC2C(*)COC12,0.34161233
+*OC(=O)C(Cc1ccccc1)NC(=O)CCCCCCCCC(=O)NC(Cc1ccccc1)C(=O)OC1COC2C(*)COC12,0.34522868
+*OC(=O)C(Cc1ccccc1)NC(=O)CCCCCCCCCCC(=O)NC(Cc1ccccc1)C(=O)OC1COC2C(*)COC12,0.35207165
+*OC(=O)Oc1ccc(C(=O)Oc2ccc(OC(=O)OC3COC4C(*)COC34)cc2)cc1,0.33078823
+*OC(=O)c1ccc(C(=O)OC2COC3C(*)COC23)cc1,0.33842265
+*OC(=O)c1ccc(Cc2ccc(C(*)=O)cc2)cc1,0.34410161
+*OC(COC(=O)c1ccc2cc(C(*)=O)ccc2c1)COc1ccc(N=Nc2ccc(C#N)cc2)cc1,0.35895878
+*OC1C(C)(C)C(OC(=O)C2CCC(C(*)=O)CC2)C1(C)C,0.35756125
+*OS(=O)(=O)c1cccc(S(=O)(=O)Oc2ccc(C(C)(C)c3ccc(*)cc3)cc2)c1,0.36372411
+*OS(=O)(=O)c1cccc(S(=O)(=O)Oc2ccc(C(C)(CC)c3ccc(*)cc3)cc2)c1,0.36537348
+*OS(=O)(=O)c1cccc(S(=O)(=O)Oc2ccc(C3(c4ccc(*)cc4)CCCCC3)cc2)c1,0.36029922
+*O[Si](*)(C)CCCOc1ccc(C(=O)Oc2ccc(C(=O)Oc3ccc(OC)cc3)cc2)cc1,0.34401737
+*O[Si](C)(C)CCCC(=O)Oc1ccc(C=Nc2ccc(Cc3ccc(N=Cc4ccc(OC(=O)CCC[Si](*)(C)C)cc4)cc3)cc2)cc1,0.38299785
+*O[Si](C)(C)CCCN=Cc1cc(Cc2ccc(O)c(C=NCCC[Si](*)(C)C)c2)ccc1O,0.39347596
+*O[Si](C)(C)OC(CCl)COc1ccc(C(C)(C)c2ccc(OCC(*)CCl)cc2)cc1,0.3750933
+*O[Si](C)(C)O[Si](C)(C)O[Si](C)(C)O[Si](C)(C)O[Si](C)(C)O[Si](C)(C)Oc1c(*)c2ccccc2c2ccccc12,0.41772931
+*O[Si](C)(C)O[Si](C)(C)O[Si](C)(C)O[Si](C)(C)O[Si](C)(C)Oc1c(*)c2ccccc2c2ccccc12,0.41127913
+*O[Si](C)(C)O[Si](C)(C)O[Si](C)(C)O[Si](C)(C)Oc1c(*)c2ccccc2c2ccccc12,0.40298758
+*O[Si](C)(C)Oc1ccc(C(C)(C)c2ccc(*)cc2)cc1,0.40918281
+*O[Si](C)(C)c1cccc2c1ccc1c([Si](*)(C)C)cccc12,0.40173269
+*O[Si](C)(Oc1ccc(*)cc1)c1ccccc1,0.40342541
+*Oc1c(-c2ccccc2)cc(*)cc1-c1ccccc1-c1ccccc1,0.4050477
+*Oc1c(-c2ccccc2)cc(Cc2cc(-c3ccccc3)c(OC(=O)CCCCC(*)=O)c(-c3ccccc3)c2)cc1-c1ccccc1,0.37195156
+*Oc1c(-c2ccccc2)cc(Cc2cc(-c3ccccc3)c(OC(=O)CCCCCC(*)=O)c(-c3ccccc3)c2)cc1-c1ccccc1,0.37107521
+*Oc1c(-c2ccccc2)cc(Cc2cc(-c3ccccc3)c(OC(=O)CCCCCCCCC(*)=O)c(-c3ccccc3)c2)cc1-c1ccccc1,0.3718338
+*Oc1c(Br)cc(C(C)(C)c2cc(Br)c(OC(*)=O)c(Br)c2)cc1Br,0.4290399
+*Oc1c(Br)cc(C(C)(C)c2cc(Br)c(OC(=O)c3ccc(OCCCCCCCCCCOc4ccc(C(*)=O)cc4)cc3)c(Br)c2)cc1Br,0.39126002
+*Oc1c(Br)cc(C(c2cc(Br)c(OC(*)=O)c(Br)c2)(C(F)(F)F)C(F)(F)F)cc1Br,0.41928552
+*Oc1c(C(C)C)cc(C(=O)c2cccc(C(=O)c3ccc(*)cc3)c2)cc1C(C)C,0.40376992
+*Oc1c(C)cc(C(C)(C)c2cc(C)c(OC(*)=O)c(C)c2)cc1C,0.39805007
+*Oc1c(C)cc(C(C)(C)c2cc(C)c(OC(*)=O)c(Cl)c2)cc1Cl,0.3979854
+*Oc1c(C)cc(C(C)(C)c2cc(C)c(OC(=O)CCCCC(*)=O)c(C)c2)cc1C,0.37611741
+*Oc1c(C)cc(C(C)(C)c2cc(C)c(OC(=O)CCCCCC(*)=O)c(C)c2)cc1C,0.37560672
+*Oc1c(C)cc(C(C)(C)c2cc(C)c(OC(=O)CCCCCCCCC(*)=O)c(C)c2)cc1C,0.38134315
+*Oc1c(C)cc(C(c2cc(C)c(OC(*)=O)c(C)c2)(C(F)(F)F)C(F)(F)F)cc1C,0.39598526
+*Oc1c(Cl)cc(C(C)(C)c2cc(Cl)c(OC(*)=O)c(Cl)c2)cc1Cl,0.39482335
+*Oc1c(Cl)cc(C(C)(C)c2cc(Cl)c(OC(=O)CCCCC(*)=O)c(Cl)c2)cc1Cl,0.37453429
+*Oc1c(Cl)cc(C(C)(C)c2cc(Cl)c(OC(=O)c3ccc(OCCCCCCCCCCOc4ccc(C(*)=O)cc4)cc3)c(Cl)c2)cc1Cl,0.37760348
+*Oc1c(Cl)cc(C(c2cc(Cl)c(OC(*)=O)c(Cl)c2)C(Cl)(Cl)Cl)cc1Cl,0.39461971
+*Oc1c(Cl)cc(C2(c3cc(Cl)c(OC(*)=O)c(Cl)c3)CCCCC2)cc1Cl,0.39600978
+*Oc1c(F)c(C#N)c(Oc2ccc(C(C)(C)c3cccc(C(C)(C)c4ccc(*)cc4)c3)cc2)c(F)c1C#N,0.38046147
+*Oc1cc(Br)c(C(C)(C)c2c(Br)cc(OC(*)=O)cc2Br)c(Br)c1,0.3939151
+*Oc1cc(Cl)c(C(C)(C)c2c(Cl)cc(OC(*)=O)cc2Cl)c(Cl)c1,0.37057341
+*Oc1cc(OC(=O)c2ccc(C)cc2)c(OC(=O)CCCCCCCCCCCCCCC(*)=O)cc1OC(=O)c1ccc(C)cc1,0.36849104
+*Oc1cc(OC(=O)c2ccc(OC)cc2)c(OC(=O)CCCC(*)=O)cc1OC(=O)c1ccc(OC)cc1,0.33574151
+*Oc1cc(OC(=O)c2ccc(OC)cc2)c(OC(=O)CCCCCCCCCCCCCCC(*)=O)cc1OC(=O)c1ccc(OC)cc1,0.35345176
+*Oc1cc(OC(=O)c2ccc(OCC(C)CC)cc2)c(OC(=O)CCCC(*)=O)cc1OC(=O)c1ccc(OCC(C)CC)cc1,0.35730159
+*Oc1cc(OC(=O)c2ccc(OCC)cc2)c(OC(=O)CCCC(*)=O)cc1OC(=O)c1ccc(OCC)cc1,0.33981747
+*Oc1cc(OC(=O)c2ccc(OCC)cc2)c(OC(=O)CCCCCCCCCCCCCCC(*)=O)cc1OC(=O)c1ccc(OCC)cc1,0.36137547
+*Oc1cc(OC(=O)c2ccc(OCCC)cc2)c(OC(=O)CCCC(*)=O)cc1OC(=O)c1ccc(OCCC)cc1,0.34814804
+*Oc1cc(OC(=O)c2ccc(OCCC)cc2)c(OC(=O)CCCCCCCCCCCCCCC(*)=O)cc1OC(=O)c1ccc(OCCC)cc1,0.36365256
+*Oc1cc(OC(=O)c2ccc(OCCCC)cc2)c(OC(=O)C(C)(C)CCC(*)=O)cc1OC(=O)c1ccc(OCCCC)cc1,0.35709055
+*Oc1cc(OC(=O)c2ccc(OCCCC)cc2)c(OC(=O)C(C)CCC(*)=O)cc1OC(=O)c1ccc(OCCCC)cc1,0.35328505
+*Oc1cc(OC(=O)c2ccc(OCCCC)cc2)c(OC(=O)CCCC(*)=O)cc1OC(=O)c1ccc(OCCCC)cc1,0.35109057
+*Oc1cc(OC(=O)c2ccc(OCCCC)cc2)c(OC(=O)CCCCCC(*)=O)cc1OC(=O)c1ccc(OCCCC)cc1,0.35336805
+*Oc1cc(OC(=O)c2ccc(OCCCC)cc2)c(OC(=O)CCCCCCCC(*)=O)cc1OC(=O)c1ccc(OCCCC)cc1,0.35540563
+*Oc1cc(OC(=O)c2ccc(OCCCCC)cc2)c(OC(=O)CCCC(*)=O)cc1OC(=O)c1ccc(OCCCCC)cc1,0.35445196
+*Oc1cc(OC(=O)c2ccc(OCCCCCCCCCCCC)cc2)c(OC(=O)CCCC(*)=O)cc1OC(=O)c1ccc(OCCCCCCCCCCCC)cc1,0.37044637
+*Oc1cc(OC(=O)c2ccc(Oc3ccc(C4(c5ccc(Oc6ccc(C(*)=O)cc6)cc5)CCC(C(C)(C)C)CC4)cc3)cc2)ccc1C12CC3CC(CC(C3)C1)C2,0.38278757
+*Oc1ccc(-c2ccc(OC(=O)OC3C(C)(C)C(OC(*)=O)C3(C)C)cc2)cc1,0.35906343
+*Oc1ccc(-c2ccc(OC3(F)C(*)(F)C(F)(F)C3(F)F)cc2)cc1,0.34511864
+*Oc1ccc(-c2ccc(Oc3cccc(*)n3)cc2)cc1,0.34884407
+*Oc1ccc(C(=O)NNC(=O)c2ccc(*)cc2)cc1,0.34717894
+*Oc1ccc(C(=O)Nc2cc(NC(=O)c3ccc(*)cc3)cc(-c3nc4ccccc4[nH]3)c2)cc1,0.36445259
+*Oc1ccc(C(=O)Nc2ccc(S(=O)(=O)c3ccc(NC(=O)c4ccc(Oc5ccc(C(=O)c6ccc(S(=O)(=O)c7ccc(C(=O)c8ccc(*)cc8)cc7)cc6)cc5)cc4)cc3)cc2)cc1,0.36195969
+*Oc1ccc(C(=O)Nc2ccc(S(=O)(=O)c3ccc(NC(=O)c4ccc(Oc5nc(*)nc(Sc6ccccc6)n5)cc4)cc3)cc2)cc1,0.35315957
+*Oc1ccc(C(=O)OCC(C)(C)COC(=O)c2ccc(*)cc2)cc1,0.35526052
+*Oc1ccc(C(=O)OCCCCCOC(=O)c2ccc(*)cc2)cc1,0.34696395
+*Oc1ccc(C(=O)OCCCOC(=O)c2ccc(*)cc2)cc1,0.34520298
+*Oc1ccc(C(=O)c2ccc(C(=O)c3ccc(Oc4cccc(Cc5cccc(*)c5)c4)cc3)cc2)cc1,0.36639351
+*Oc1ccc(C(=O)c2cccc(C(=O)c3ccc(*)c(C(C)C)c3)c2)cc1C,0.39318082
+*Oc1ccc(C(=O)c2cccc(C(=O)c3ccc(*)c(C(C)C)c3)c2)cc1CC,0.39239857
+*Oc1ccc(C(=O)c2cccc(C(=O)c3ccc(*)c(CC)c3)c2)cc1CC,0.38536105
+*Oc1ccc(C(=O)c2cccc(C(=O)c3ccc(*)cc3)c2)cc1,0.36581437
+*Oc1ccc(C(=O)c2cccc(C(=O)c3ccc(Oc4ccc(Cc5ccc(*)cc5)cc4)cc3)c2)cc1,0.37058113
+*Oc1ccc(C(C)(C)c2cc(Cl)c(OC(*)=O)c(Cl)c2)cc1,0.37520677
+*Oc1ccc(C(C)(C)c2ccc(C(C)(C)c3ccc(OC(*)=O)cc3)cc2)cc1,0.36640421
+*Oc1ccc(C(C)(C)c2ccc(OC(*)(Oc3ccccc3)Oc3ccccc3)cc2)cc1,0.37316612
+*Oc1ccc(C(C)(C)c2ccc(OC(*)=O)c(C(C)C)c2)cc1C(C)C,0.40309692
+*Oc1ccc(C(C)(C)c2ccc(OC(*)=O)c(C)c2)cc1C,0.37267711
+*Oc1ccc(C(C)(C)c2ccc(OC(*)=O)c(CC)c2)cc1CC,0.38097605
+*Oc1ccc(C(C)(C)c2ccc(OC(*)=O)c(Cl)c2)cc1,0.3646685
+*Oc1ccc(C(C)(C)c2ccc(OC(*)=O)c(Cl)c2)cc1C,0.37412442
+*Oc1ccc(C(C)(C)c2ccc(OC(*)=O)c(Cl)c2)cc1Cl,0.37372084
+*Oc1ccc(C(C)(C)c2ccc(OC(*)=S)cc2)cc1,0.35877547
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)CC(C)CCC(*)=O)cc2)cc1,0.35041329
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)CCCCC(*)=O)c(C)c2)cc1C,0.35992444
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)CCCCC(*)=O)cc2)cc1,0.34517826
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)CCCCCCCCC(*)=O)cc2)cc1,0.35872609
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)OCCCCCOC(*)=O)cc2)cc1,0.34414164
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)OCCCCOC(*)=O)cc2)cc1,0.34176051
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)OCCCOC(*)=O)cc2)cc1,0.33934743
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)OCCN(CCOC(*)=O)c3ccc(OC)cc3)cc2)cc1,0.34363634
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)OCCN(CCOC(*)=O)c3ccccc3)cc2)cc1,0.34756362
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)SCCCCCCSC(*)=O)cc2)cc1,0.3614361
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)SCCCSC(*)=O)cc2)cc1,0.35558207
+*Oc1ccc(C(C)(C)c2ccc(OC(=O)c3ccc(OCCCCCCCCCCOc4ccc(C(*)=O)cc4)cc3)cc2)cc1,0.35755108
+*Oc1ccc(C(C)(C)c2ccc(Oc3ccc(C(=O)C(=O)c4ccc(*)cc4)cc3)cc2)cc1,0.37690328
+*Oc1ccc(C(C)(C)c2ccc(Oc3ccc(C(=O)Nc4ccc(NC(=O)c5ccc(*)cc5)cc4)cc3)cc2)cc1,0.35980678
+*Oc1ccc(C(C)(C)c2ccc(Oc3ccc(C(=O)c4c(C(=O)c5ccc(*)cc5)c(-c5ccccc5)c(-c5ccc6ccccc6c5)c(-c5ccc6ccccc6c5)c4-c4ccccc4)cc3)cc2)cc1,0.39617794
+*Oc1ccc(C(C)(C)c2ccc(Oc3ccc(C(=O)c4cccc(C(=O)c5ccc(*)cc5)c4)cc3)cc2)cc1,0.37447472
+*Oc1ccc(C(C)(C)c2ccc(Oc3ccc(C(=O)c4ccccc4-c4ccccc4C(=O)c4ccc(*)cc4)cc3)cc2)cc1,0.37964806
+*Oc1ccc(C(C)(CC(C)C)c2ccc(OC(*)=S)cc2)cc1,0.36650609
+*Oc1ccc(C(C)(CC)c2ccc(OC(*)=O)c(C)c2)cc1C,0.37939809
+*Oc1ccc(C(C)(CC)c2ccc(OC(*)=O)c(Cl)c2)cc1Cl,0.37781492
+*Oc1ccc(C(C)(CC)c2ccc(OC(*)=O)cc2)cc1,0.3639544
+*Oc1ccc(C(C)(CC)c2ccc(OC(*)=S)cc2)cc1,0.36451292
+*Oc1ccc(C(C)(CCC#N)c2ccc(OC(*)=O)c(C)c2)cc1C,0.38107835
+*Oc1ccc(C(C)(CCC#N)c2ccc(OC(*)=O)cc2)cc1,0.36182275
+*Oc1ccc(C(C)(CCC)c2ccc(OC(*)=O)cc2)cc1,0.37045396
+*Oc1ccc(C(C)(c2ccccc2)c2ccc(OC(*)=O)cc2)cc1,0.36147298
+*Oc1ccc(C(C)(c2ccccc2)c2ccc(OC(=O)c3ccccc3-c3ccccc3C(*)=O)cc2)cc1,0.36060662
+*Oc1ccc(C(C)c2ccc(OC(*)=O)cc2)cc1,0.35421995
+*Oc1ccc(C(CC)(CC)c2ccc(OC(*)=S)cc2)cc1,0.36838966
+*Oc1ccc(C(CC)c2ccc(OC(*)=O)cc2)cc1,0.36281879
+*Oc1ccc(C(CC)c2ccc(OC(*)=S)cc2)cc1,0.36420995
+*Oc1ccc(C(CCC)(CCC)c2ccc(OC(*)=O)c(C)c2)cc1C,0.39582423
+*Oc1ccc(C(CCC)(CCC)c2ccc(OC(*)=O)cc2)cc1,0.38249055
+*Oc1ccc(C(CCC)c2ccc(OC(*)=O)cc2)cc1,0.36627071
+*Oc1ccc(C(CCC)c2ccc(OC(*)=S)cc2)cc1,0.3689351
+*Oc1ccc(C(CCCC)(CCCC)c2ccc(OC(*)=O)cc2)cc1,0.38524755
+*Oc1ccc(C(c2ccc(OC(*)=O)cc2)(C(F)(F)Cl)C(F)(F)Cl)cc1,0.36111109
+*Oc1ccc(C(c2ccc(OC(*)=O)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.3466164
+*Oc1ccc(C(c2ccc(OC(*)=O)cc2)C(C)C)cc1,0.36947312
+*Oc1ccc(C(c2ccc(OC(*)=O)cc2)C(Cl)(Cl)Cl)cc1,0.36652065
+*Oc1ccc(C(c2ccc(OC(*)=O)cc2)C(Cl)Cl)cc1,0.36363286
+*Oc1ccc(C(c2ccc(OC(*)=S)cc2)C(C)C)cc1,0.37198799
+*Oc1ccc(C(c2ccc(OC(*)=S)cc2)C(CC)CC)cc1,0.37352636
+*Oc1ccc(C(c2ccc(OC(=O)c3ccc(OCCCCCCCCCCOc4ccc(C(*)=O)cc4)cc3)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.35492275
+*Oc1ccc(C(c2ccc(Oc3ccc(C(=O)C(=O)c4ccc(*)cc4)cc3)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.37168595
+*Oc1ccc(C(c2ccc(Oc3ccc(C(=O)Nc4ccc(NC(=O)c5ccc(*)cc5)cc4)cc3)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.35746728
+*Oc1ccc(C(c2ccc(Oc3ccc(C(=O)c4c(C(=O)c5ccc(*)cc5)c(-c5ccccc5)c(-c5ccc6ccccc6c5)c(-c5ccc6ccccc6c5)c4-c4ccccc4)cc3)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.39580075
+*Oc1ccc(C(c2ccc(Oc3ccc(C(=O)c4cc(C(=O)c5ccc(*)cc5)cc(C(C)(C)C)c4)cc3)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.38577086
+*Oc1ccc(C(c2ccc(Oc3ccc(C(=O)c4cccc(C(=O)c5ccc(*)cc5)c4)cc3)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.37070417
+*Oc1ccc(C(c2ccc(Oc3ccc(C(=O)c4ccccc4-c4ccccc4C(=O)c4ccc(*)cc4)cc3)cc2)(C(F)(F)F)C(F)(F)F)cc1,0.37602202
+*Oc1ccc(C(c2ccccc2)(c2ccccc2)c2ccc(OC(=O)OC3C(C)(C)C(OC(*)=O)C3(C)C)cc2)cc1,0.37906621
+*Oc1ccc(C2(c3ccc(OC(*)=O)c(C)c3)CCCCC2)cc1C,0.38771377
+*Oc1ccc(C2(c3ccc(OC(*)=O)c(Cl)c3)CCCCC2)cc1Cl,0.37361861
+*Oc1ccc(C2(c3ccc(OC(*)=O)cc3)CCCC2)cc1,0.35187363
+*Oc1ccc(C2(c3ccc(OC(*)=O)cc3)CCCCC2)cc1,0.35918735
+*Oc1ccc(C2(c3ccc(OC(*)=O)cc3)CCc3ccccc32)cc1,0.36699475
+*Oc1ccc(C2(c3ccc(OC(*)=O)cc3)c3ccccc3-c3ccccc32)cc1,0.38475968
+*Oc1ccc(C2(c3ccc(OC(*)=S)cc3)CCCC2)cc1,0.35616229
+*Oc1ccc(C2(c3ccc(OC(=O)CCCCCCCCC(*)=O)cc3)c3ccccc3Cc3ccccc32)cc1,0.36332436
+*Oc1ccc(C2(c3ccc(OC(=O)OC4C(C)(C)C(OC(*)=O)C4(C)C)cc3)CC3CCC2C3)cc1,0.3705045
+*Oc1ccc(C2(c3ccc(OC(=O)c4ccc(C(*)=O)cc4)cc3)c3ccccc3C(=O)c3ccccc32)cc1,0.36880796
+*Oc1ccc(C2(c3ccc(OC(=O)c4ccc(Oc5ccc(C6(c7ccc(Oc8ccc(C(*)=O)cc8)cc7)CCC(C(C)(C)C)CC6)cc5)cc4)cc3)CC3CC2C2CCCC32)cc1,0.37986369
+*Oc1ccc(C2(c3ccc(Oc4ccc(C(=O)c5c(C(=O)c6ccc(*)cc6)c(-c6ccccc6)c(-c6ccc7ccccc7c6)c(-c6ccc7ccccc7c6)c5-c5ccccc5)cc4)cc3)c3ccccc3-c3ccccc32)cc1,0.40813978
+*Oc1ccc(C2(c3ccc(Oc4ccc5c(=O)n6c7cc(Oc8ccc9c(c8)nc8c%10ccc(*)c%11cccc(c(=O)n98)c%11%10)ccc7nc6c6cccc4c56)cc3)c3ccccc3-c3ccccc32)cc1,0.396728
+*Oc1ccc(C=C2CCCC(=Cc3ccc(OC(=O)CCCCCCCCC(*)=O)c(OC)c3)C2=O)cc1OC,0.35776264
+*Oc1ccc(C=NN=Cc2ccc(Oc3ccc(C(C)(C)c4ccc(*)cc4)cc3)cc2)cc1,0.3809024
+*Oc1ccc(C=NN=Cc2ccc(Oc3ccc(C(c4ccc(*)cc4)(C(F)(F)F)C(F)(F)F)cc3)cc2)cc1,0.37282962
+*Oc1ccc(CCNC(=O)c2cccc(C(=O)NCCc3ccc(OC(=O)c4cccc(C(*)=O)c4)cc3)c2)cc1,0.33853882
+*Oc1ccc(CNC(=O)CCCCC(=O)NCc2ccc(OC3COC4C(*)COC34)cc2)cc1,0.33099906
+*Oc1ccc(Cc2ccc(Cc3ccc(OC(*)=O)cc3)cc2)cc1,0.36126118
+*Oc1ccc(Cc2ccc(OC(*)=O)c(C)c2)cc1C,0.36953235
+*Oc1ccc(Cc2ccc(OC(*)=O)cc2)cc1,0.34889783
+*Oc1ccc(Cc2ccc(OC(*)=S)cc2)cc1,0.35541969
+*Oc1ccc(Cc2ccc(OC(=O)CCCCC(*)=O)cc2)cc1,0.34469429
+*Oc1ccc(NC(=O)CCCCCCC(=O)Nc2ccc(OC3COC4C(*)COC34)cc2)cc1,0.33802231
+*Oc1ccc(NC(=O)NC2CC(C)(C)CC(C)(CNC(=O)Nc3ccc(*)cc3)C2)cc1,0.34918835
+*Oc1ccc(NC(=O)c2cc(C(=O)Nc3ccc(Oc4ccc(C(C)(C)c5ccc(*)cc5)cc4)cc3)cc(C(C)(C)C)c2)cc1,0.36926959
+*Oc1ccc(NC(=O)c2cc(C(=O)Nc3ccc(Oc4ccc(C(c5ccc(*)cc5)(C(F)(F)F)C(F)(F)F)cc4)cc3)cc(C(C)(C)C)c2)cc1,0.36861613
+*Oc1ccc(NC(=O)c2cc(C(=O)Nc3ccc(Oc4ccc(C(c5ccc(*)cc5)(C(F)(F)F)C(F)(F)F)cc4)cc3)cc([N+](=O)[O-])c2)cc1,0.3558116
+*Oc1ccc(NC(=O)c2cc(NC(=O)CCCCCCCCCCN3C(=O)c4ccccc4C3=O)cc(C(=O)Nc3ccc(*)cc3)c2)cc1,0.34139919
+*Oc1ccc(NC(=O)c2cc(NC(=O)c3ccc(OC(C)=O)cc3)cc(C(=O)Nc3ccc(*)cc3)c2)cc1,0.33796697
+*Oc1ccc(NC(=O)c2cc(NC(=O)c3ccccc3)cc(C(=O)Nc3ccc(*)cc3)c2)cc1,0.34264944
+*Oc1ccc(NC(=O)c2ccc(NC(=O)c3ccc([Si](C)(C)c4ccc(C(=O)Nc5ccc(C(=O)Nc6ccc(*)cc6)cc5)cc4)cc3)cc2)cc1,0.35582732
+*Oc1ccc(NC(=O)c2cccc(C(=O)Nc3ccc(Oc4ccc(C(c5ccc(*)cc5)(C(F)(F)F)C(F)(F)F)cc4)cc3)c2)cc1,0.35683545
+*Oc1ccc(NC(=O)c2cccc(C(=O)Nc3ccc(Oc4ccc(C5(c6ccc(*)cc6)C6CC7CC(C6)CC5C7)cc4)cc3)c2)cc1,0.36643837
+*Oc1ccc(OC(=O)c2cc(OCCCc3ccccc3)c(C(*)=O)cc2OCCCc2ccccc2)cc1C,0.35359821
+*Oc1ccc(OC(=O)c2ccc(-c3ccc(C(*)=O)cc3)cc2-c2ccccc2)cc1,0.35277091
+*Oc1ccc(OC(=O)c2ccc(-c3ccc(C(*)=O)cc3)cc2-c2ccccc2)cc1C,0.36137424
+*Oc1ccc(OC(=O)c2ccc(C(*)=O)cc2)cc1C1CCCCCCC1,0.36680265
+*Oc1ccc(OC(=O)c2ccc(C(*)=O)cc2Sc2ccc(C)cc2)cc1,0.36164456
+*Oc1ccc(OC(=O)c2ccc(C(*)=O)cc2Sc2ccc3ccccc3c2)cc1,0.35895279
+*Oc1ccc(OC(=O)c2ccc(C(*)=O)cc2Sc2ccccc2)cc1,0.35449521
+*Oc1ccc(OC(=O)c2ccc(C(*)=O)cc2Sc2ccccc2)cc1C,0.36029743
+*Oc1ccc(OC(=O)c2ccc(OCCCCCCCCCCCCOc3ccc(C(*)=O)cc3)cc2)cc1C=Cc1ccncc1,0.36385478
+*Oc1ccc(OC(=O)c2ccc([Si](C)(C)c3ccc(C(*)=O)cc3)cc2)cc1,0.36637923
+*Oc1ccc(OC(=O)c2cccc(Oc3cccc(C(*)=O)c3)c2)cc1,0.34914243
+*Oc1ccc(Oc2ccc(C(=O)c3cccc(-c4cccc(C(=O)c5ccc(*)cc5)c4)c3)cc2)cc1,0.36870915
+*Oc1ccc(Oc2ccc(C(=O)c3cccc(NC(=O)c4ccc(C(=O)Nc5cccc(C(=O)c6ccc(*)cc6)c5)cc4)c3)cc2)cc1,0.35637997
+*Oc1ccc(Oc2ccc(NC(=C(C#N)C#N)c3cccc(C(Nc4ccc(*)cc4)=C(C#N)C#N)c3)cc2)cc1,0.39273786
+*Oc1ccc(Oc2ccc(OC(=O)NC(=O)c3cc(C(=O)NC(*)=O)cc(C(C)(C)C)c3)cc2)cc1,0.33792975
+*Oc1ccc(Oc2ccc(P(C)(=O)c3ccc(*)cc3)cc2)cc1,0.37537227
+*Oc1ccc(Oc2ccc(S(=O)(=O)c3ccc(-c4ccc(-c5ccc(S(=O)(=O)c6ccc(*)cc6)cc5)cc4)cc3)cc2)cc1,0.3744368
+*Oc1ccc(Oc2ccc(S(=O)(=O)c3ccc(Oc4ccc(C(=O)c5ccc(*)cc5)cc4)cc3)cc2)cc1,0.37202073
+*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C(=O)c4ccc(*)cc4)cc3)cc2)cc1,0.37219019
+*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C(C)(C)c4ccc(OCCCCOc5ccc(C(C)(C)c6ccc(*)cc6)cc5)cc4)cc3)cc2)cc1,0.36776278
+*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C4(c5ccc(*)c(C)c5)CCCCC4)cc3C)cc2)cc1,0.38723397
+*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C4(c5ccc(*)cc5)CC5CCC4C5)cc3)cc2)cc1,0.38350802
+*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C4(c5ccc(*)cc5)CCCCC4)cc3)cc2)cc1,0.37562068
+*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C4(c5ccc(*)cc5)CCCCCC4)cc3)cc2)cc1,0.37649846
+*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(C=C4CCCCC(=Cc5ccc(*)cc5)C4=O)cc3)cc2)cc1,0.3771408
+*Oc1ccc(S(=O)(=O)c2ccc(Oc3ccc(Sc4ccc(*)cc4)cc3)cc2)cc1,0.37748733
+*Oc1ccc(SSc2ccc(*)cc2)cc1,0.3974058
+*Oc1ccc2ccc(Oc3ccc(C(=O)Nc4ccc(C(C)(C)c5ccc(C(C)(C)c6ccc(NC(=O)c7ccc(*)cc7)cc6)cc5)cc4)cc3)cc2c1,0.36959735
+*Oc1cccc(C(=O)Nc2ccc(-c3ccc(NC(=O)c4cccc(Oc5nc(*)nc(Sc6ccccc6)n5)c4)cc3)cc2)c1,0.35084083
+*Oc1cccc(C(=O)OCC(F)(F)C(F)(F)C(F)(F)COC(=O)c2cccc(*)c2)c1,0.33298625
+*Oc1cccc(NC(=O)c2cc(NC(=O)c3ccc(OC(C)=O)cc3)cc(C(=O)Nc3ccc(*)cc3)c2)c1,0.3340158
+*Oc1cccc(NC(=O)c2ccc(C(=O)c3cccc(C(=O)Nc4ccc(*)cc4)c3)cc2)c1,0.35065699
+*Oc1cccc(NC(=O)c2ccc(P(=O)(c3ccccc3)c3ccc(C(=O)Nc4cccc(Oc5ccc(P(=O)(c6ccccc6)c6ccc(*)cc6)cc5)c4)cc3)cc2)c1,0.36861977
+*Oc1cccc(OC(=O)c2ccc([Si](C)(C)c3ccc(C(*)=O)cc3)cc2)c1,0.3731365
+*Oc1cccc(Oc2ccc(NC(=O)c3ccc(Oc4cccc(Oc5ccc(C(=O)Nc6ccc(*)cc6)cc5)c4)cc3)cc2)c1,0.3505917
+*Oc1cccc(Oc2ccc(S(=O)(=O)c3ccc(Oc4ccc(C(=O)c5ccc(*)cc5)cc4)cc3)cc2)c1,0.36939797
+*Oc1cccc(Oc2ccc3c(=O)n4c5cc(-c6ccc7c(c6)nc6c8ccc(*)c9cccc(c(=O)n76)c98)ccc5nc4c4cccc2c34)c1,0.3689235
+*Oc1cccc2ccc(Oc3ccc(NC(=O)c4ccc(Oc5cccc(Oc6ccc(C(=O)Nc7ccc(*)cc7)cc6)c5)cc4)cc3)cc12,0.35508677
+*Oc1cccc2ccc(Oc3ccc(NC(=O)c4ccc(S(=O)(=O)c5ccc(C(=O)Nc6ccc(*)cc6)cc5)cc4)cc3)cc12,0.35780365
+*Sc1ccc(Cc2ccc(SC(*)=O)cc2)cc1,0.37184413
+*c1c(C)cc(-c2cc(C)c(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)c(C)c2)cc1C,0.41438034
+*c1c(C)cc(C(C)(C)c2cc(C)c(S(*)(=O)=O)c(C)c2)cc1C,0.39361578
+*c1cc(Br)c(-c2c(Br)cc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(=O)OCCCC)c(C(=O)OCCCC)c1,0.40136201
+*c1cc(Br)c(-c2c(Br)cc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(=O)OCCCCCC)c(C(=O)OCCCCCC)c1,0.40008637
+*c1cc(Br)c(-c2c(Br)cc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(=O)OCCCCCCCC)c(C(=O)OCCCCCCCC)c1,0.39346173
+*c1cc(Br)c(-c2c(Br)cc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(=O)OCCCCCCCCCC)c(C(=O)OCCCCCCCCCC)c1,0.39569707
+*c1cc(Br)c(-c2c(Br)cc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(=O)OCCCCCCCCCCCC)c(C(=O)OCCCCCCCCCCCC)c1,0.39501882
+*c1cc(Br)c(-c2c(Br)cc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(=O)OCCCCCCCCCCCCCC)c(C(=O)OCCCCCCCCCCCCCC)c1,0.39219199
+*c1cc(Br)c(-c2c(Br)cc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(=O)OCCCCCCCCCCCCCCCC)c(C(=O)OCCCCCCCCCCCCCCCC)c1,0.38889387
+*c1cc(Br)c(-c2c(Br)cc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(=O)OCCCCCCCCCCCCCCCCCC)c(C(=O)OCCCCCCCCCCCCCCCCCC)c1,0.39124104
+*c1cc(C(C)(C)c2ccc(O)cc2)cc(*)c1O,0.36895404
+*c1cc(C)c(-c2c(C)cc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C)c(C)c1,0.42456606
+*c1cc(C)c(Cc2cc(C)c(N3C(=O)c4ccc(Oc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4C3=O)cc2C)cc1C,0.38884791
+*c1cc(CCCCCCOC(=O)Cc2ccccc2)c(*)s1,0.36920522
+*c1cc(Oc2c(C)cc(-c3cc(C)c(Oc4cc(N5C(=O)c6ccc(-c7ccc8c(c7)C(=O)N(*)C8=O)cc6C5=O)cc(C(F)(F)F)c4)c(C)c3)cc2C)cc(C(F)(F)F)c1,0.3863168
+*c1ccc(-c2cc(-c3ccc(OCCCC#N)cc3)cc(-c3ccc(N4C(=O)c5ccc(-c6ccc7c(c6)C(=O)N(*)C7=O)cc5C4=O)cc3)n2)cc1,0.38426678
+*c1ccc(-c2cc(C(C)(C)C)c(Oc3ccc(N4C(=O)c5ccc(S(=O)(=O)c6ccc7c(c6)C(=O)N(*)C7=O)cc5C4=O)cc3)c(C(C)(C)C)c2)cc1,0.40835599
+*c1ccc(-c2cc(C(C)(C)C)c(Oc3ccc(N4C(=O)c5ccc(S(=O)(=O)c6ccc7c(c6)C(=O)N(*)C7=O)cc5C4=O)cc3C(F)(F)F)c(C(C)(C)C)c2)cc1,0.40507785
+*c1ccc(-c2cc(CCCCCCBr)c(*)s2)s1,0.4247369
+*c1ccc(-c2cc3c(ccc4ccccc43)cc2-c2ccc(N(*)c3ccc(C)cc3)cc2)cc1,0.39961477
+*c1ccc(-c2ccc(-c3cc(-c4ccccc4)c4cc(-c5ccc6nc(*)cc(-c7ccccc7)c6c5)ccc4n3)cc2)cc1,0.41687752
+*c1ccc(-c2ccc(-c3ccc(-c4ccc(-c5ccc(*)n5CCCCCCCCCCCC)s4)s3)s2)s1,0.43060128
+*c1ccc(-c2ccc(-c3ccc(-c4ccc(-c5ccc6c(c5)C(=O)N(c5ccc(Oc7ccc(-c8ccc(Oc9ccc(N%10C(=O)c%11ccc(*)cc%11C%10=O)cc9)cc8)cc7)cc5)C6=O)cc4)cc3)cc2)cc1,0.36472216
+*c1ccc(-c2ccc(-c3ccc([Si](*)(C)C)s3)s2)s1,0.45230424
+*c1ccc(-c2ccc(-c3ccc([Si](*)(CCCC)CCCC)s3)s2)s1,0.43066164
+*c1ccc(-c2ccc(-c3ccc([Si](C)(C)[Si](*)(C)C)s3)s2)s1,0.45398953
+*c1ccc(-c2ccc(-c3ccc([Si](CCCC)(CCCC)[Si](*)(CCCC)CCCC)s3)s2)s1,0.42687929
+*c1ccc(-c2ccc(-c3nnc(-c4ccc([Si](c5ccccc5)(c5ccccc5)c5ccc(-c6nnc(*)o6)cc5)cc4)o3)cc2)cc1,0.46586821
+*c1ccc(-c2ccc(C3(*)c4ccccc4-c4ccccc43)cc2)cc1,0.41877221
+*c1ccc(-c2ccc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)c(C)c2)cc1C,0.39090779
+*c1ccc(-c2ccc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(F)(F)F)c(C(F)(F)F)c1,0.40447598
+*c1ccc(-c2ccc(N3C(=O)c4ccc(Oc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4C3=O)c(OC)c2)cc1OC,0.36448396
+*c1ccc(-c2ccc(N3C(=O)c4ccc(Oc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4C3=O)cc2)cc1,0.36285392
+*c1ccc(-c2ccc(NC(=O)c3cccc(C(=O)Nc4ccc(-c5ccc(N6C(=O)c7ccc(Oc8ccc9c(c8)C(=O)N(*)C9=O)cc7C6=O)cc5)cc4)c3)cc2)cc1,0.35467611
+*c1ccc(-c2ccc([Si](*)(C)C)s2)s1,0.43527879
+*c1ccc(-c2ccc([Si](*)(CCCC)CCCC)s2)s1,0.4246241
+*c1ccc(-c2ccc([Si](CCCC)(CCCC)[Si](*)(CCCC)CCCC)s2)s1,0.42578552
+*c1ccc(-c2cnc3cc(-c4ccc5nc(*)cnc5c4)ccc3n2)cc1,0.43314968
+*c1ccc(-c2cnc3ccc(-c4ccc5nc(*)cnc5c4)cc3n2)cc1,0.42108918
+*c1ccc(-c2nc3cc(C(=O)c4ccc5nc(-c6ccccc6)c(-c6ccc(N7C(=O)C8OC9C(=O)N(*)C(=O)C9C8C7=O)cc6)nc5c4)ccc3nc2-c2ccccc2)cc1,0.41616021
+*c1ccc(-c2nc3cc(Oc4ccc5nc(-c6ccccc6)c(*)nc5c4)ccc3nc2-c2ccccc2)cc1,0.4245693
+*c1ccc(/C=C(\C#N)C(=O)NC2CCCCC2NC(=O)/C(C#N)=C/c2ccc(N(c3ccccc3)c3ccc(N(*)c4ccccc4)cc3)cc2)cc1,0.39541341
+*c1ccc(C(=O)NCCCCCCCCNC(=O)c2ccc(-c3nc4ccccc4nc3*)cc2)cc1,0.36159736
+*c1ccc(C(=O)OCCCCCCCCCCOc2ccc(C=C3CCC(=Cc4ccc(OCCCCCCCCCCOC(=O)c5ccc(-c6nnc(*)o6)cc5)cc4)C3=O)cc2)cc1,0.36684911
+*c1ccc(C(=O)OCCCCCCOc2ccc(C=C3CCCCC(=Cc4ccc(OCCCCCCOC(=O)c5ccc(-c6nnc(*)o6)cc5)cc4)C3=O)cc2)cc1,0.36570631
+*c1ccc(C(=O)Oc2ccc3ccc(OC(=O)c4ccc(N5C(=O)CC(SCCOCCSC6CC(=O)N(*)C6=O)C5=O)cc4)cc3c2)cc1,0.33882496
+*c1ccc(C(=O)c2cccc(C(=O)c3ccc(S(*)(=O)=O)cc3)c2)cc1,0.3680485
+*c1ccc(C(C)(C)c2ccc(N3C(=O)c4ccc(Oc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4C3=O)cc2)cc1,0.38365681
+*c1ccc(C(Cl)(Cl)C(*)Cl)cc1,0.39641701
+*c1ccc(C(F)(F)C(*)(F)F)cc1,0.37735155
+*c1ccc(C(c2ccccc2)(c2ccc(-c3nc4ccc(-c5ccc6nc(*)oc6c5)cc4o3)cc2)C(F)(F)F)cc1,0.42450788
+*c1ccc(C(c2ccccc2)c2ccc(N(c3ccc(C)cc3)c3ccc(-c4ccc(N(*)c5ccc(C)cc5)cc4)cc3)cc2)cc1,0.43608862
+*c1ccc(C2(c3ccc(-c4cc(-c5ccccc5)c5cc(Oc6ccc7nc(*)cc(-c8ccccc8)c7c6)ccc5n4)cc3)c3ccccc3-c3ccccc32)cc1,0.42387068
+*c1ccc(C2C3C(=O)N(c4ccc(N5C(=O)C6ON(C)C(*)C6C5=O)cc4)C(=O)C3ON2C)cc1,0.38700602
+*c1ccc(Cc2ccc(N3C(=O)CC(Nc4ccc(N(c5ccc(NC6CC(=O)N(*)C6=O)cc5)c5ccc([N+](=O)[O-])cc5)cc4)C3=O)cc2)cc1,0.37849239
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.38180524
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(Oc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4C3=O)c(C)c2)cc1C,0.37895775
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(Oc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4C3=O)c(C)c2C)c(C)c1C,0.38199636
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(Oc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4C3=O)c(OC)c2)cc1OC,0.37197016
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(Oc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4C3=O)cc2)cc1,0.36838096
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(Oc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4C3=O)cc2C)c(C)c1,0.37649357
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(S(=O)(=O)c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)c(C(C)(C)C)c2)cc1C(C)(C)C,0.40289103
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(S(=O)(=O)c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.38388245
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(Sc5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)c(C(C)(C)C)c2)cc1C(C)(C)C,0.40667097
+*c1ccc(Cc2ccc(N3C(=O)c4ccc(Sc5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.37611089
+*c1ccc(Cc2ccc(NC(=O)c3ccc(Oc4cccc5c4C(=O)N(*)C5=O)cc3)cc2)cc1,0.36075451
+*c1ccc(Cc2ccc(S(*)(=O)=O)cc2)cc1,0.37585986
+*c1ccc(N2C(=O)c3ccc(C(c4ccc5c(c4)C(=O)N(c4ccc(N6C(=O)c7ccc(-c8ccc9c(c8)C(=O)N(*)C9=O)cc7C6=O)cc4)C5=O)(C(F)(F)F)C(F)(F)F)cc3C2=O)cc1,0.39383584
+*c1ccc(N2C(=O)c3ccc(Oc4ccc(Sc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4)cc3C2=O)cc1,0.36725031
+*c1ccc(NC(=O)Cc2ccc(-c3sc(-c4ccc(CC(=O)Nc5ccc(-c6sc(*)c(-c7ccccc7)c6-c6ccccc6)cc5)cc4)c(-c4ccccc4)c3-c3ccccc3)cc2)cc1,0.40560913
+*c1ccc(NC(=O)c2ccc(NC(=O)c3ccc([Si](C)(C)c4ccc(C(=O)Nc5ccc(C(=O)Nc6ccc(-c7sc(*)c(-c8ccccc8)c7-c7ccccc7)cc6)cc5)cc4)cc3)cc2)cc1,0.38057891
+*c1ccc(NC(=O)c2ccc(NC(=O)c3ccc([Si](C)(C)c4ccc(C(=O)Nc5ccc(C(=O)Nc6ccc(S(*)(=O)=O)cc6)cc5)cc4)cc3)cc2)cc1,0.3556199
+*c1ccc(NC(=O)c2ccc(OCCOCCOc3ccc(C(=O)Nc4ccc5[nH]c(*)nc5c4)cc3)cc2)cc1,0.34897445
+*c1ccc(OC(=O)CCCCCCCCCCCCCCCCCCCCC(=O)Oc2ccc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.35924634
+*c1ccc(OC(=O)c2cccc(C(=O)Oc3ccc(C4(*)NC(=O)c5ccccc54)cc3)c2)cc1,0.35684437
+*c1ccc(OC(=O)c2cccc(C(=O)Oc3ccc(C4(*)c5ccccc5C(=O)N4C)cc3)c2)cc1,0.36854686
+*c1ccc(OCCCCOc2ccc(-c3nc4ccc(-c5ccc6nc(*)c(-c7ccccc7)nc6c5)cc4nc3-c3ccccc3)cc2)cc1,0.38981232
+*c1ccc(OCCN(CC)c2ccc(-c3ccc(C(=C(C#N)C#N)c4ccc(-c5ccc(N(CC)CC)cc5)s4)s3)cc2)c(-c2cc(-c3ccccc3)c3cc(Oc4ccc5nc(*)cc(-c6ccccc6)c5c4)ccc3n2)c1,0.40222587
+*c1ccc(Oc2cc3ccccc3cc2Oc2ccc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.36809048
+*c1ccc(Oc2ccc(-c3c(-c4ccccc4)c(-c4ccc(-c5nc6ccccc6c(*)c5-c5ccccc5)cc4)nc4ccccc34)cc2)cc1,0.40153318
+*c1ccc(Oc2ccc(-c3cc(-c4ccccc4)c4cc5c(-c6ccccc6)cc(*)nc5cc4n3)cc2)cc1,0.41795495
+*c1ccc(Oc2ccc(-c3cc(OCCCCCC)c(-c4ccc(Oc5ccc(-c6nnc(*)o6)cc5)cc4)cc3OCCCCCC)cc2)cc1,0.39000442
+*c1ccc(Oc2ccc(-c3ccc(Oc4ccc(-c5cnc6cc(-c7ccc8nc(*)cnc8c7)ccc6n5)cc4)cc3)cc2)cc1,0.38709806
+*c1ccc(Oc2ccc(-c3ccc(Oc4ccc(-c5nc(-c6ccccn6)nnc5*)cc4)cc3)cc2)cc1,0.39038278
+*c1ccc(Oc2ccc(-c3ccc(Oc4ccc(N5C(=O)c6ccc(Oc7ccc(C8(c9ccc(Oc%10ccc%11c(c%10)C(=O)N(*)C%11=O)cc9)CCC(c9ccccc9)CC8)cc7)cc6C5=O)cc4)cc3C)c(C)c2)cc1,0.38011618
+*c1ccc(Oc2ccc(-c3nc4cc(Oc5ccc6nc(-c7ccccc7)c(*)nc6c5)ccc4nc3-c3ccccc3)cc2)cc1,0.41406386
+*c1ccc(Oc2ccc(-n3c(=O)c4cc5c(=O)n(-c6ncc(*)s6)c(=O)c5cc4c3=O)cc2)cc1,0.39753647
+*c1ccc(Oc2ccc(C(=O)c3ccc(Oc4ccc(-c5c6c(c(*)c7ccccc57)C(=O)N(C)C6=O)cc4)cc3)cc2)cc1,0.37568068
+*c1ccc(Oc2ccc(C(=O)c3ccc(Oc4ccc(-c5c6c(c(*)c7ccccc57)C(=O)N(CCCCCCCCCCCC)C6=O)cc4)cc3)cc2)cc1,0.37658949
+*c1ccc(Oc2ccc(C(=O)c3ccc(Oc4ccc(-c5cc(*)n(-c6ccccc6)n5)cc4)cc3)cc2)cc1,0.39170081
+*c1ccc(Oc2ccc(C(=O)c3ccc(Oc4ccc(-c5nnc(*)c6c(-c7ccc(F)cc7)c(-c7ccc(F)cc7)c(-c7ccc(F)cc7)c(-c7ccc(F)cc7)c56)cc4)cc3)cc2)cc1,0.4007497
+*c1ccc(Oc2ccc(C(=O)c3ccc4cc(C(=O)c5ccc(Oc6ccc(-c7nc(-c8ccccc8)[nH]c7*)cc6)cc5)ccc4c3)cc2)cc1,0.38999587
+*c1ccc(Oc2ccc(C(=O)c3cccc(C(=O)c4ccc(Oc5ccc(-c6cc(*)n(-c7ccccc7)n6)cc5)cc4)c3)cc2)cc1,0.38437007
+*c1ccc(Oc2ccc(C(C)(C)c3ccc(Oc4ccc(-c5nnc(*)c6c(-c7ccccc7)c(-c7ccc8ccccc8c7)c(-c7ccc8ccccc8c7)c(-c7ccccc7)c56)cc4)cc3)cc2)cc1,0.40019815
+*c1ccc(Oc2ccc(C(C)(C)c3ccc(Oc4ccc(N5C(=O)C6CCC7C(=O)N(*)C(=O)C7C6C5=O)cc4)cc3)cc2)cc1,0.37215765
+*c1ccc(Oc2ccc(C(C)(C)c3ccc(Oc4ccc(N5C(=O)c6ccc(Oc7ccc8c(c7)C(=O)N(*)C8=O)cc6C5=O)cc4)cc3)cc2)cc1,0.37435414
+*c1ccc(Oc2ccc(C(c3ccc(Oc4ccc(-c5nnc(*)c6c(-c7ccccc7)c(-c7ccc8ccccc8c7)c(-c7ccc8ccccc8c7)c(-c7ccccc7)c56)cc4)cc3)(C(F)(F)F)C(F)(F)F)cc2)cc1,0.39876705
+*c1ccc(Oc2ccc(C(c3ccc(Oc4ccc(N5C(=O)c6ccc(-c7ccc8c(c7)C(=O)N(*)C8=O)cc6C5=O)cc4)cc3)(C(F)(F)F)C(F)(F)F)cc2)cc1,0.37203901
+*c1ccc(Oc2ccc(C(c3ccc(Oc4ccc(N5C(=O)c6ccc(Oc7ccc8c(c7)C(=O)N(*)C8=O)cc6C5=O)cc4)cc3)(C(F)(F)F)C(F)(F)F)cc2)cc1,0.37553925
+*c1ccc(Oc2ccc(C3(c4ccc(Oc5ccc(N6C(=O)c7ccc(Oc8ccccc8Oc8ccc9c(c8)C(=O)N(*)C9=O)cc7C6=O)cc5C(F)(F)F)cc4)c4ccccc4-c4ccccc43)cc2)c(C(F)(F)F)c1,0.3879662
+*c1ccc(Oc2ccc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.37648982
+*c1ccc(Oc2ccc(N3C(=O)c4ccc(Oc5cc6ccccc6cc5Oc5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.36464157
+*c1ccc(Oc2ccc(N3C(=O)c4ccc(P(=O)(c5ccccc5)c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.39239064
+*c1ccc(Oc2ccc(N3C(=O)c4ccc([Si](C)(C)c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.38889031
+*c1ccc(Oc2ccc(N3C(=O)c4cccc(Oc5c(C)cc(-c6cc(C)c(Oc7cccc8c7C(=O)N(*)C8=O)c(C)c6)cc5C)c4C3=O)cc2)cc1,0.38403589
+*c1ccc(Oc2ccc(N3C(=O)c4cccc(Oc5c(C)cc(Cc6cc(C)c(Oc7cccc8c7C(=O)N(*)C8=O)c(C)c6)cc5C)c4C3=O)cc2)cc1,0.38048862
+*c1ccc(Oc2ccc(N3C(=O)c4cccc(Oc5ccc(-c6ccc(Oc7cccc8c7C(=O)N(*)C8=O)cc6)cc5)c4C3=O)cc2)cc1,0.36710709
+*c1ccc(Oc2ccc(N3C(=O)c4cccc(Oc5ccc(C(C)(C)c6ccc(Oc7cccc8c7C(=O)N(*)C8=O)cc6)cc5)c4C3=O)cc2)cc1,0.37037622
+*c1ccc(Oc2ccc(N3C(=O)c4cccc(Oc5ccc(Sc6ccc(Oc7cccc8c7C(=O)N(*)C8=O)cc6)cc5)c4C3=O)cc2)cc1,0.36952098
+*c1ccc(Oc2ccc(NC(=O)CN3C(=O)c4ccc(C(c5ccc6c(c5)C(=O)N(CC(=O)Nc5ccc(Oc7ccc(-c8nnc(*)o8)cc7)cc5)C6=O)(C(F)(F)F)C(F)(F)F)cc4C3=O)cc2)cc1,0.3576037
+*c1ccc(Oc2ccc(NC(=O)c3cc(NC(=O)c4ccc(OC(C)=O)cc4)cc(C(=O)Nc4ccc(Oc5ccc(-c6nnc(*)o6)cc5)cc4)c3)cc2)cc1,0.35432779
+*c1ccc(Oc2ccc(NC(=O)c3cccc(Oc4ccc5c(c4)C(=O)N(*)C5=O)c3)cc2)cc1,0.35195763
+*c1ccc(Oc2ccc(Oc3ccc(-c4nnc(*)c5c(-c6ccc(F)cc6)c(-c6ccc(F)cc6)c(-c6ccc(F)cc6)c(-c6ccc(F)cc6)c45)cc3)cc2)cc1,0.40913388
+*c1ccc(Oc2ccc(Oc3ccc(N4C(=O)c5ccc(Oc6ccc(Oc7ccc(Oc8ccc9c(c8)C(=O)N(*)C9=O)cc7)cc6)cc5C4=O)cc3)cc2)cc1,0.36392805
+*c1ccc(Oc2ccc(Oc3ccc(N4C(=O)c5cccc(Oc6c(C)cc(Cc7cc(C)c(Oc8cccc9c8C(=O)N(*)C9=O)c(C)c7)cc6C)c5C4=O)c(C)c3)cc2)cc1C,0.38135415
+*c1ccc(Oc2ccc(Oc3ccc(N4C(=O)c5cccc(Oc6ccc(C(C)(C)c7ccc(Oc8cccc9c8C(=O)N(*)C9=O)cc7)cc6)c5C4=O)c(C)c3)cc2)cc1C,0.37551052
+*c1ccc(Oc2ccc(S(=O)(=O)c3ccc(Oc4ccc(-c5nc(-c6ccc(-c7nc(*)c(-c8ccccc8)[nH]7)cc6)[nH]c5-c5ccccc5)cc4)cc3)cc2)cc1,0.40109727
+*c1ccc(Oc2ccc(S(=O)(=O)c3ccc(Oc4ccc(-c5nc6ccccc6n5-c5ccc(-n6c(*)nc7ccccc76)cc5)cc4)cc3)cc2)cc1,0.37966679
+*c1ccc(Oc2ccc(Sc3ccc(Oc4ccc(-c5nc(*)nc(-c6ccccc6)n5)cc4)cc3)cc2)cc1,0.39963304
+*c1ccc(Oc2ccc3c(c2)C(=O)N(*)C3=O)cc1,0.37183519
+*c1ccc(Oc2ccc3ccccc3c2-c2c(Oc3ccc(N4C(=O)c5ccc(NC(=O)Nc6cccc7c(NC(=O)Nc8ccc9c(c8)C(=O)N(*)C9=O)cccc67)cc5C4=O)cc3)ccc3ccccc23)cc1,0.36092398
+*c1ccc(Oc2cccc(N3C(=O)c4ccc(Oc5cccc6c(Oc7ccc8c(c7)C(=O)N(*)C8=O)cccc56)cc4C3=O)c2)cc1,0.37487112
+*c1ccc(Oc2cccc(NC(=O)c3ccc(C(=O)Nc4cccc(Oc5ccc(-c6nnc(*)o6)cc5)c4)c(Oc4ccccc4)c3)c2)cc1,0.36258207
+*c1ccc(Oc2cccc3c(NC(=O)c4ccc([Si](c5ccccc5)(c5ccccc5)c5ccc(C(=O)Nc6cccc7c(Oc8ccc(-c9nnc(*)o9)cc8)cccc67)cc5)cc4)cccc23)cc1,0.37704837
+*c1ccc(Oc2ccccc2Oc2ccc(N3C(=O)c4ccc(Oc5ccccc5Oc5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.35809599
+*c1ccc(Oc2ccccc2Oc2ccc(N3C(=O)c4ccc(Oc5ccccc5Oc5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2C(F)(F)F)c(C(F)(F)F)c1,0.36055432
+*c1ccc(S(=O)(=O)c2ccc(N3C(=O)c4ccc(-c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)cc2)cc1,0.37525452
+*c1ccc(Sc2ccc(Oc3ccc(Sc4ccc(N5C(=O)c6ccc(Oc7ccc(C(C)(C)c8ccc(Oc9ccc%10c(c9)C(=O)N(*)C%10=O)cc8)cc7)cc6C5=O)cc4)cc3)cc2)cc1,0.37448846
+*c1ccc(Sc2ccc(Sc3ccc(N4C(=O)c5ccc(Sc6ccc(Sc7ccc(Sc8ccc9c(c8)C(=O)N(*)C9=O)cc7)cc6)cc5C4=O)cc3)cc2)cc1,0.37717954
+*c1ccc(Sc2ccc(Sc3ccc(Sc4ccc(N5C(=O)c6ccc(-c7ccc8c(c7)C(=O)N(*)C8=O)cc6C5=O)cc4)cc3)cc2)cc1,0.37722426
+*c1ccc([Si](c2ccccc2)(c2ccccc2)c2ccc(-c3nnc(-c4ccc(-c5nnc(*)o5)nc4)o3)cc2)cc1,0.46577218
+*c1ccc2c(c1)C(=O)N(C1CCC(N3C(=O)c4ccc(C(*)(C(F)(F)F)C(F)(F)F)cc4C3=O)CC1)C2=O,0.37690953
+*c1ccc2c(c1)C(=O)N(c1c(C)c(C)c(N3C(=O)c4ccc(C(*)(C(F)(F)F)C(F)(F)F)cc4C3=O)c(C)c1C)C2=O,0.41737364
+*c1ccc2c(c1)C(=O)N(c1c(C)cc(-c3cc(C)c(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)c4ccccc34)c3ccccc13)C2=O,0.41291503
+*c1ccc2c(c1)C(=O)N(c1cc(-c3ccc(O)c(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)c3)ccc1O)C2=O,0.37301864
+*c1ccc2c(c1)C(=O)N(c1cc(C(=O)Nc3ccc(C(c4ccc(NC(=O)c5ccc(C)c(N6C(=O)c7ccc(C(*)(C(F)(F)F)C(F)(F)F)cc7C6=O)c5)cc4)(C(F)(F)F)C(F)(F)F)cc3)ccc1C)C2=O,0.36683082
+*c1ccc2c(c1)C(=O)N(c1cc(C)c(N3C(=O)c4ccc(C(*)(C(F)(F)F)C(F)(F)F)cc4C3=O)cc1C)C2=O,0.40933634
+*c1ccc2c(c1)C(=O)N(c1cc(OCCN(CC)c3ccc(N=Nc4ccc([N+](=O)[O-])cc4)cc3)cc(N3C(=O)c4ccc(C(*)(C(F)(F)F)C(F)(F)F)cc4C3=O)c1)C2=O,0.37866227
+*c1ccc2c(c1)C(=O)N(c1ccc(-c3ccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)c(OCCOc4ccc5c(C)cc(=O)oc5c4)c3)cc1OCCOc1ccc3c(C)cc(=O)oc3c1)C2=O,0.34983336
+*c1ccc2c(c1)C(=O)N(c1ccc(C(=O)Nc3ccc(Oc4cccc(Oc5ccc(NC(=O)c6ccc(N7C(=O)c8ccc(C(*)(C(F)(F)F)C(F)(F)F)cc8C7=O)cc6)cc5)c4)cc3)cc1)C2=O,0.35654385
+*c1ccc2c(c1)C(=O)N(c1ccc(C(c3ccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)cc3)(C(F)(F)F)C(F)(F)F)cc1)C2=O,0.39524704
+*c1ccc2c(c1)C(=O)N(c1ccc(N3C(=O)c4ccc(C(*)(C(F)(F)F)C(F)(F)F)cc4C3=O)cc1)C2=O,0.39320221
+*c1ccc2c(c1)C(=O)N(c1ccc(NC(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)C(=O)Nc3ccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)cc3)cc1)C2=O,0.34222618
+*c1ccc2c(c1)C(=O)N(c1ccc(OCCOCCOCCOCCOc3ccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)cc3)cc1)C2=O,0.34187588
+*c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(C(c4ccc(Oc5ccc(N6C(=O)c7ccc(C(*)(C(F)(F)F)C(F)(F)F)cc7C6=O)cc5C(F)(F)F)cc4)(C(F)(F)F)C(F)(F)F)cc3)c(C(F)(F)F)c1)C2=O,0.38326805
+*c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)cc3)cc1)C2=O,0.38674054
+*c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccc(S(=O)(=O)c4ccc(Oc5ccc(N6C(=O)c7ccc(C(*)(C(F)(F)F)C(F)(F)F)cc7C6=O)cc5)cc4)cc3)cc1)C2=O,0.37337767
+*c1ccc2c(c1)C(=O)N(c1ccc(Oc3ccccc3-c3ccccc3Oc3ccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)cc3)cc1)C2=O,0.37740671
+*c1ccc2c(c1)C(=O)N(c1cccc(C(=O)Nc3ccc(C(c4ccc(NC(=O)c5cccc(N6C(=O)c7ccc(C(*)(C(F)(F)F)C(F)(F)F)cc7C6=O)c5)cc4)(C(F)(F)F)C(F)(F)F)cc3)c1)C2=O,0.36118518
+*c1ccc2c(c1)C(=O)N(c1cccc(C(=O)Nc3ccc(C(c4ccc(NC(=O)c5cccc(N6C(=O)c7ccc(C(*)(C(F)(F)F)C(F)(F)F)cc7C6=O)c5C)cc4)(C(F)(F)F)C(F)(F)F)cc3)c1C)C2=O,0.36895419
+*c1ccc2c(c1)C(=O)N(c1cccc(C(=O)Nc3ccc(Oc4ccc(NC(=O)c5cccc(N6C(=O)c7ccc(C(*)(C(F)(F)F)C(F)(F)F)cc7C6=O)c5)cc4)cc3)c1)C2=O,0.35705395
+*c1ccc2c(c1)C(=O)N(c1cccc(C(c3cccc(N4C(=O)c5ccc(C(*)(C(F)(F)F)C(F)(F)F)cc5C4=O)c3)(C(F)(F)F)C(F)(F)F)c1)C2=O,0.38091589
+*c1ccc2c(c1)C(=O)N(c1cccc(Oc3cc(Oc4cccc(N5C(=O)c6ccc(C(*)(C(F)(F)F)C(F)(F)F)cc6C5=O)c4)ccc3P(=O)(c3ccccc3)c3ccccc3)c1)C2=O,0.37529286
+*c1ccc2c(c1)C(=O)N(c1cccc(Oc3ccc(N4C(=O)c5ccc(-c6c(-c7ccccc7)c(-c7ccccc7)c(-c7ccc(Sc8ccc(-c9c(-c%10ccccc%10)c(-c%10ccccc%10)c(*)c(-c%10ccccc%10)c9-c9ccccc9)cc8)cc7)c(-c7ccccc7)c6-c6ccccc6)cc5C4=O)cc3)c1)C2=O,0.4011794
+*c1ccc2c(c1)C(=O)N(c1cccc(Oc3ccc(Oc4cccc(N5C(=O)c6ccc(C(*)(C(F)(F)F)C(F)(F)F)cc6C5=O)c4)cc3)c1)C2=O,0.37037326
+*c1ccc2c(c1)C(=O)N(c1cccc(Oc3ccc(P(=O)(c4ccccc4)c4ccc(Oc5cccc(N6C(=O)c7ccc(C(*)(C(F)(F)F)C(F)(F)F)cc7C6=O)c5)cc4)cc3)c1)C2=O,0.37783134
+*c1ccc2c(c1)C(CCCCCC)(CCCCCC)c1cc(-c3ccc4c(c3)C(CC3=NC(Cc5ccccc5)CO3)(CC3=NC(Cc5ccccc5)CO3)c3cc(*)ccc3-4)ccc1-2,0.40982823
+*c1ccc2c(c1)Sc1cc(-c3sc(C=CC4=CC(=C(C#N)C#N)C=C(C=Cc5sc(*)c(CCCCCC)c5CCCCCC)O4)c(CCCCCC)c3CCCCCC)ccc1N2CCCCCC,0.41634717
+*c1ccc2c(c1)Sc1cc(-c3sc4cc(*)sc4c3CCCCC)ccc1N2CCCCCC,0.52516398
+*c1ccc2c(c1)Sc1cc(-c3sc4cc(*)sc4c3CCCCC)ccc1N2CCCCCCCCCC,0.50803301
+*c1ccc2c(c1)Sc1cc(-c3sc4cc(*)sc4c3CCCCC)ccc1N2CCCCCCCCCCCC,0.4916283
+*c1ccc2c3ccc(-c4c5ccc(C=Cc6ccc(N(CCCCCC)CCCCCC)cc6)cc5c(*)c5ccc(C=Cc6ccc(N(CCCCCC)CCCCCC)cc6)cc45)cc3n(CCCCCCCC)c2c1,0.40341568
+*c1ccc2oc(-c3cccc(-c4nc5cc(C(*)(C(F)(F)F)C(F)(F)F)ccc5o4)n3)nc2c1,0.45901468
+*c1ccc2oc(C3CCC(c4nc5cc(C(*)(C(F)(F)F)C(F)(F)F)ccc5o4)CC3)nc2c1,0.38067376
+*c1cccc(-c2nc3cc(Oc4ccc5nc(-c6ccccc6)c(*)nc5c4)ccc3nc2-c2ccccc2)c1,0.41748276
+*c1cccc(C(=O)Nc2ccc(Cc3ccc(N4C(=O)c5ccc(S(=O)(=O)c6ccc7c(c6)C(=O)N(c6ccc(Cc8ccc(NC(=O)c9cccc(-c%10nc%11cc(-c%12ccc%13[nH]c(*)nc%13c%12)ccc%11[nH]%10)c9)cc8)cc6)C7=O)cc5C4=O)cc3)cc2)c1,0.37929385
+*c1cccc(C(=O)Nc2ccc(NC(=O)c3cccc(N4C(=O)c5ccc(-c6cccc7c6C(=O)N(*)C7=O)cc5C4=O)c3)cc2)c1,0.34929698
+*c1cccc(C(=O)Nc2ccc(Oc3ccc(-c4ccc(Oc5ccc(NC(=O)c6cccc(N7C(=O)c8ccc(-c9cccc%10c9C(=O)N(*)C%10=O)cc8C7=O)c6)cc5)cc4)cc3)cc2)c1,0.35563189
+*c1cccc(C(=O)Nc2ccc(Oc3ccc(Oc4ccc(NC(=O)c5cccc(N6C(=O)c7ccc(-c8ccc9c(c8)C(=O)N(*)C9=O)cc7C6=O)c5)cc4)cc3)cc2)c1,0.35757013
+*c1cccc(C(=O)Nc2ccc(Oc3ccc(Oc4ccc(Oc5ccc(NC(=O)c6cccc(N7C(=O)c8ccc(-c9ccc%10c(c9)C(=O)N(*)C%10=O)cc8C7=O)c6)cc5)cc4)cc3)cc2)c1,0.35608701
+*c1cccc(C(=O)Nc2cccc(S(=O)(=O)c3cccc(NC(=O)c4cccc(N5C(=O)c6ccc(-c7cccc8c7C(=O)N(*)C8=O)cc6C5=O)c4)c3)c2)c1,0.35520964
+*c1cccc(Cc2cccc(N3C(=O)c4ccc([Si](C)(C)O[Si](C)(C)O[Si](C)(C)c5ccc6c(c5)C(=O)N(*)C6=O)cc4C3=O)c2)c1,0.38675185
+*c1cccc(N2C(=O)c3ccc(Oc4ccc(Sc5ccc(Oc6ccc7c(c6)C(=O)N(*)C7=O)cc5)cc4)cc3C2=O)c1,0.36600422
+*c1cccc(NC(=O)c2ccc(-c3ccc(C(=O)Nc4cccc(S(*)(=O)=O)c4)c(C)c3)cc2C)c1,0.3574533
+*c1cccc(NC(=O)c2ccc(OCCOCCOc3ccc(C(=O)Nc4ccc5[nH]c(*)nc5c4)cc3)cc2)c1,0.34893481
+*c1cccc(OCCCCCCCCOc2cccc(N3C(=O)c4ccc(-c5cccc6c5C(=O)N(*)C6=O)cc4C3=O)c2)c1,0.35046399
+*c1cccc(OCCCCCCOc2cccc(N3C(=O)c4ccc(-c5cccc6c5C(=O)N(*)C6=O)cc4C3=O)c2)c1,0.34909456
+*c1cccc(OCCCCCOc2cccc(N3C(=O)c4ccc(-c5cccc6c5C(=O)N(*)C6=O)cc4C3=O)c2)c1,0.35089152
+*c1cccc(OCCCCOc2cccc(N3C(=O)c4ccc(-c5cccc6c5C(=O)N(*)C6=O)cc4C3=O)c2)c1,0.34538642
+*c1cccc(Oc2cccc(Oc3cccc(N4C(=O)c5ccc(Oc6ccc(Sc7ccc(Oc8ccc9c(c8)C(=O)N(*)C9=O)cc7)cc6)cc5C4=O)c3)c2)c1,0.36222427
+*c1cccc(P(C)(=O)c2cccc(N3C(=O)c4ccc(Oc5ccc(C(C)(C)c6ccc(Oc7ccc8c(c7)C(=O)N(*)C8=O)cc6)cc5)cc4C3=O)c2)c1,0.36957365

simson_modeling/moleculenet_eval/.ipynb_checkpoints/better_eval-checkpoint.py

@@ -0,0 +1,671 @@
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from transformers import BertConfig, BertModel, AutoTokenizer
+from rdkit import Chem, RDLogger
+from rdkit.Chem.Scaffolds import MurckoScaffold
+import copy
+from tqdm import tqdm
+import os
+from sklearn.metrics import roc_auc_score, root_mean_squared_error, mean_absolute_error
+from itertools import compress
+from collections import defaultdict
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
+import optuna
+import warnings
+warnings.filterwarnings("ignore")
+RDLogger.DisableLog('rdApp.*')
+
+torch.set_float32_matmul_precision('high')
+
+# --- 0. Pre-computed Contrastive SMILES Dataset ---
+class PrecomputedContrastiveSmilesDataset(Dataset):
+    """
+    A Dataset class that reads pre-augmented SMILES pairs from a Parquet file.
+    This is significantly faster as it offloads the expensive SMILES randomization
+    to a one-time preprocessing step.
+    """
+    def __init__(self, tokenizer, file_path: str, max_length: int = 512):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        
+        # Load the entire dataset from the Parquet file into memory.
+        # This is fast and efficient for subsequent access.
+        print(f"Loading pre-computed data from {file_path}...")
+        self.data = pd.read_parquet(file_path)
+        print("Data loaded successfully.")
+
+    def __len__(self):
+        """Returns the total number of pairs in the dataset."""
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        """
+        Retrieves a pre-augmented pair, tokenizes it, and returns it
+        in the format expected by the DataCollator.
+        """
+        # Retrieve the pre-augmented pair from the DataFrame
+        row = self.data.iloc[idx]
+        smiles_1 = row['smiles_1']
+        smiles_2 = row['smiles_2']
+        
+        # Tokenize the pair. This operation is fast and remains in the data loader.
+        tokens_1 = self.tokenizer(smiles_1, max_length=self.max_length, truncation=True, padding='max_length')
+        tokens_2 = self.tokenizer(smiles_2, max_length=self.max_length, truncation=True, padding='max_length')
+        
+        return {
+            'input_ids_1': torch.tensor(tokens_1['input_ids']),
+            'attention_mask_1': torch.tensor(tokens_1['attention_mask']),
+            'input_ids_2': torch.tensor(tokens_2['input_ids']),
+            'attention_mask_2': torch.tensor(tokens_2['attention_mask']),
+        }
+
+# --- 0a. SMILES enumeration for preprocessing ---
+class SmilesEnumerator:
+    """Generates randomized SMILES strings for data augmentation."""
+    def randomize_smiles(self, smiles):
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            return Chem.MolToSmiles(mol, doRandom=True, canonical=False) if mol else smiles
+        except:
+            return smiles
+
+def compute_embedding_similarity_precomputed(encoder, dataset, device):
+    """
+    Compute embedding similarity using pre-computed augmented SMILES pairs
+    """
+    encoder.eval()
+    similarities = []
+    
+    dataloader = DataLoader(dataset, batch_size=32, shuffle=False)
+    
+    with torch.no_grad():
+        for batch in dataloader:
+            input_ids_1 = batch['input_ids_1'].to(device)
+            attention_mask_1 = batch['attention_mask_1'].to(device)
+            input_ids_2 = batch['input_ids_2'].to(device)
+            attention_mask_2 = batch['attention_mask_2'].to(device)
+            
+            emb_1 = encoder(input_ids_1, attention_mask_1).cpu().numpy()
+            emb_2 = encoder(input_ids_2, attention_mask_2).cpu().numpy()
+            
+            # Compute cosine similarity for each pair in the batch
+            batch_similarities = []
+            for i in range(len(emb_1)):
+                sim = cosine_similarity([emb_1[i]], [emb_2[i]])[0][0]
+                batch_similarities.append(sim)
+            
+            similarities.extend(batch_similarities)
+    
+    return np.array(similarities)
+
+def create_augmented_smiles_file(smiles_list, output_path, num_augmentations=1):
+    """
+    Create a parquet file with pre-computed augmented SMILES pairs
+    """
+    enumerator = SmilesEnumerator()
+    pairs = []
+    
+    print(f"Generating {num_augmentations} augmentations for {len(smiles_list)} SMILES...")
+    
+    for smiles in tqdm(smiles_list):
+        for _ in range(num_augmentations):
+            augmented = enumerator.randomize_smiles(smiles)
+            pairs.append({
+                'smiles_1': smiles,
+                'smiles_2': augmented
+            })
+    
+    df = pd.DataFrame(pairs)
+    df.to_parquet(output_path, index=False)
+    print(f"Saved {len(pairs)} augmented pairs to {output_path}")
+    return output_path
+
+# --- 1. Data Loading ---
+def load_lists_from_url(data):
+    # Datasets and their splits, all configurations carried over
+    if data == 'bbbp':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/BBBP.csv')
+        smiles, labels = df.smiles, df.p_np
+    elif data == 'clintox':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/clintox.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif data == 'hiv':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/HIV.csv')
+        smiles, labels = df.smiles, df.HIV_active
+    elif data == 'sider':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/sider.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif data == 'esol':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/delaney-processed.csv')
+        smiles = df.smiles
+        labels = df['ESOL predicted log solubility in mols per litre']
+    elif data == 'freesolv':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/SAMPL.csv')
+        smiles = df.smiles
+        labels = df.calc
+    elif data == 'lipophicility':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/Lipophilicity.csv')
+        smiles, labels = df.smiles, df['exp']
+    elif data == 'tox21':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/tox21.csv.gz', compression='gzip')
+        df = df.dropna(axis=0, how='any').reset_index(drop=True)
+        smiles = df.smiles
+        labels = df.drop(['mol_id', 'smiles'], axis=1)
+    elif data == 'bace':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/bace.csv')
+        smiles, labels = df.mol, df.Class
+    elif data == 'qm8':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/qm8.csv')
+        df = df.dropna(axis=0, how='any').reset_index(drop=True)
+        smiles = df.smiles
+        labels = df.drop(['smiles', 'E2-PBE0.1', 'E1-PBE0.1', 'f1-PBE0.1', 'f2-PBE0.1'], axis=1)
+    return smiles, labels
+
+# --- 2. Scaffold Splitting ---
+class ScaffoldSplitter:
+    def __init__(self, data, seed, train_frac=0.8, val_frac=0.1, test_frac=0.1, include_chirality=True):
+        self.data = data
+        self.seed = seed
+        self.include_chirality = include_chirality
+        self.train_frac = train_frac
+        self.val_frac = val_frac
+        self.test_frac = test_frac
+
+    def generate_scaffold(self, smiles):
+        mol = Chem.MolFromSmiles(smiles)
+        scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol, includeChirality=self.include_chirality)
+        return scaffold
+
+    def scaffold_split(self):
+        smiles, labels = load_lists_from_url(self.data)
+        non_null = np.ones(len(smiles)) == 0
+
+        if self.data in {'tox21', 'sider', 'clintox'}:
+            for i in range(len(smiles)):
+                if Chem.MolFromSmiles(smiles[i]) and labels.loc[i].isnull().sum() == 0:
+                    non_null[i] = 1
+        else:
+            for i in range(len(smiles)):
+                if Chem.MolFromSmiles(smiles[i]):
+                    non_null[i] = 1
+
+        smiles_list = list(compress(enumerate(smiles), non_null))
+        rng = np.random.RandomState(self.seed)
+
+        scaffolds = defaultdict(list)
+        for i, sms in smiles_list:
+            scaffold = self.generate_scaffold(sms)
+            scaffolds[scaffold].append(i)
+
+        scaffold_sets = list(scaffolds.values())
+        rng.shuffle(scaffold_sets)
+        n_total_val = int(np.floor(self.val_frac * len(smiles_list)))
+        n_total_test = int(np.floor(self.test_frac * len(smiles_list)))
+        train_idx, val_idx, test_idx = [], [], []
+
+        for scaffold_set in scaffold_sets:
+            if len(val_idx) + len(scaffold_set) <= n_total_val:
+                val_idx.extend(scaffold_set)
+            elif len(test_idx) + len(scaffold_set) <= n_total_test:
+                test_idx.extend(scaffold_set)
+            else:
+                train_idx.extend(scaffold_set)
+        return train_idx, val_idx, test_idx
+
+# --- 2a. Normal Random Split ---
+def random_split_indices(n, seed=42, train_frac=0.8, val_frac=0.1, test_frac=0.1):
+    np.random.seed(seed)
+    indices = np.random.permutation(n)
+    n_train = int(n * train_frac)
+    n_val = int(n * val_frac)
+    train_idx = indices[:n_train]
+    val_idx = indices[n_train:n_train+n_val]
+    test_idx = indices[n_train+n_val:]
+    return train_idx.tolist(), val_idx.tolist(), test_idx.tolist()
+
+# --- 3. PyTorch Dataset ---
+class MoleculeDataset(Dataset):
+    def __init__(self, smiles_list, labels, tokenizer, max_len=512):
+        self.smiles_list = smiles_list
+        self.labels = labels
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.smiles_list)
+
+    def __getitem__(self, idx):
+        smiles = self.smiles_list[idx]
+        label = self.labels.iloc[idx]
+
+        encoding = self.tokenizer(
+            smiles,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_len,
+            return_tensors='pt'
+        )
+        item = {key: val.squeeze(0) for key, val in encoding.items()}
+        if isinstance(label, pd.Series):
+            label_values = label.values.astype(np.float32)
+        else:
+            label_values = np.array([label], dtype=np.float32)
+        item['labels'] = torch.tensor(label_values, dtype=torch.float)
+        return item
+
+# --- 4. Model Architecture ---
+def global_ap(x):
+    return torch.mean(x.view(x.size(0), x.size(1), -1), dim=1)
+
+class SimSonEncoder(nn.Module):
+    def __init__(self, config: BertConfig, max_len: int, dropout: float = 0.1):
+        super(SimSonEncoder, self).__init__()
+        self.config = config
+        self.max_len = max_len
+        self.bert = BertModel(config, add_pooling_layer=False)
+        self.linear = nn.Linear(config.hidden_size, max_len)
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, input_ids, attention_mask=None):
+        if attention_mask is None:
+            attention_mask = input_ids.ne(self.config.pad_token_id)
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        hidden_states = self.dropout(outputs.last_hidden_state)
+        pooled = global_ap(hidden_states)
+        return self.linear(pooled)
+
+class SimSonClassifier(nn.Module):
+    def __init__(self, encoder: SimSonEncoder, num_labels: int, dropout=0.1):
+        super(SimSonClassifier, self).__init__()
+        self.encoder = encoder
+        self.clf = nn.Linear(encoder.max_len, num_labels)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, input_ids, attention_mask=None):
+        x = self.encoder(input_ids, attention_mask)
+        x = self.relu(self.dropout(x))
+        logits = self.clf(x)
+        return logits
+
+    def load_encoder_params(self, state_dict_path):
+        self.encoder.load_state_dict(torch.load(state_dict_path))
+
+# --- 5. Training, Validation, and Testing Loops ---
+def get_criterion(task_type, num_labels):
+    if task_type == 'classification':
+        return nn.BCEWithLogitsLoss()
+    elif task_type == 'regression':
+        return nn.MSELoss()
+    else:
+        raise ValueError(f"Unknown task type: {task_type}")
+
+def train_epoch(model, dataloader, optimizer, scheduler, criterion, device):
+    model.train()
+    total_loss = 0
+    for batch in dataloader:
+        inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+        labels = batch['labels'].to(device)
+        optimizer.zero_grad()
+        outputs = model(**inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+        if scheduler is not None:
+            scheduler.step()
+        total_loss += loss.item()
+    return total_loss / len(dataloader)
+
+def calc_val_metrics(model, dataloader, criterion, device, task_type):
+    model.eval()
+    all_labels, all_preds = [], []
+    total_loss = 0
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels'].to(device)
+            outputs = model(**inputs)
+            loss = criterion(outputs, labels)
+            total_loss += loss.item()
+            if task_type == 'classification':
+                pred_probs = torch.sigmoid(outputs).cpu().numpy()
+                all_preds.append(pred_probs)
+                all_labels.append(labels.cpu().numpy())
+            else:
+                # Regression
+                preds = outputs.cpu().numpy()
+                all_preds.append(preds)
+                all_labels.append(labels.cpu().numpy())
+    avg_loss = total_loss / len(dataloader)
+    if task_type == 'classification':
+        y_true = np.concatenate(all_labels)
+        y_pred = np.concatenate(all_preds)
+        try:
+            score = roc_auc_score(y_true, y_pred, average='macro')
+        except Exception:
+            score = 0.0
+        return avg_loss, score
+    else:
+        return avg_loss, None
+
+def test_model(model, dataloader, device, task_type):
+    model.eval()
+    all_preds, all_labels = [], []
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels']
+            outputs = model(**inputs)
+            if task_type == 'classification':
+                preds = torch.sigmoid(outputs)
+            else:
+                preds = outputs
+            all_preds.append(preds.cpu().numpy())
+            all_labels.append(labels.numpy())
+    return np.concatenate(all_preds), np.concatenate(all_labels)
+
+# --- 6. Optuna Objective Function ---
+def create_objective(name, info, train_smiles, train_labels, val_smiles, val_labels, 
+                    test_smiles, test_labels, scaler, tokenizer, encoder_config, device):
+    """Creates objective function for Optuna optimization"""
+    
+    def objective(trial):
+        # Suggest hyperparameters
+        lr = trial.suggest_float('lr', 1e-6, 1e-4, log=True)
+        batch_size = trial.suggest_categorical('batch_size', [16, 32, 64, 128, 256])
+        dropout = trial.suggest_float('dropout', 0.1, 0.5)
+        weight_decay = trial.suggest_float('weight_decay', 0.0, 0.1)
+        scheduler_type = trial.suggest_categorical('scheduler', ['plateau', 'cosine', 'step'])
+        
+        # Additional hyperparameters for optimization
+        patience_lr = trial.suggest_int('patience_lr', 3, 10)
+        gamma = trial.suggest_float('gamma', 0.5, 0.9) if scheduler_type == 'step' else 0.1
+        
+        try:
+            # Create datasets and dataloaders
+            train_dataset = MoleculeDataset(train_smiles, train_labels, tokenizer, 512)
+            val_dataset = MoleculeDataset(val_smiles, val_labels, tokenizer, 512)
+            test_dataset = MoleculeDataset(test_smiles, test_labels, tokenizer, 512)
+            
+            train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+            val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
+            test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
+
+            # Create model
+            encoder = SimSonEncoder(encoder_config, 512, dropout=dropout)
+            encoder = torch.compile(encoder)
+            model = SimSonClassifier(encoder, num_labels=info['num_labels'], dropout=dropout).to(device)
+            model.load_encoder_params('../simson_checkpoints/checkpoint_best_model.bin')
+
+            criterion = get_criterion(info['task_type'], info['num_labels'])
+            optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)
+            
+            # Create scheduler based on trial suggestion
+            if scheduler_type == 'plateau':
+                scheduler = optim.lr_scheduler.ReduceLROnPlateau(
+                    optimizer, mode='max', factor=gamma, patience=patience_lr
+                )
+            elif scheduler_type == 'cosine':
+                scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
+            else:  # step
+                scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=gamma)
+
+            # Training loop
+            best_val_metric = -np.inf
+            patience_counter = 0
+            patience = 15
+            
+            for epoch in range(50):  # Max epochs
+                train_loss = train_epoch(model, train_loader, optimizer, 
+                                       scheduler if scheduler_type == 'cosine' else None, 
+                                       criterion, device)
+                val_loss, val_metric = calc_val_metrics(model, val_loader, criterion, device, info['task_type'])
+                
+                # Update scheduler
+                if scheduler_type == 'plateau':
+                    scheduler.step(val_loss if val_loss is not None else -val_loss)
+                elif scheduler_type == 'step':
+                    scheduler.step()
+                
+                # Determine metric to optimize
+                if info['task_type'] == 'classification':
+                    current_metric = val_loss if val_loss is not None else 0.0
+                else:
+                    current_metric = -val_loss  # For regression, minimize loss
+
+                # Early stopping and best model tracking
+                if current_metric <= val_loss:
+                    best_val_metric = current_metric
+                    patience_counter = 0
+                else:
+                    patience_counter += 1
+                    if patience_counter >= patience:
+                        break
+
+                # Optuna pruning
+                trial.report(current_metric, epoch)
+                if trial.should_prune():
+                    raise optuna.TrialPruned()
+
+            return best_val_metric
+            
+        except Exception as e:
+            print(f"Trial failed with error: {e}")
+            return -np.inf  # Return worst possible score for failed trials
+    
+    return objective
+
+# --- 7. Main Execution Block ---
+def main():
+    DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Using device: {DEVICE}")
+
+    DATASETS_TO_RUN = {
+        #'esol': {'task_type': 'regression', 'num_labels': 1, 'split': 'random'},
+        # Add more datasets here, e.g. 'bbbp': {'task_type': 'classification', 'num_labels': 1, 'split': 'random'},
+        #'sider': {'task_type': 'classification', 'num_labels': 27, 'split': 'random'},
+        #'bace': {'task_type': 'classification', 'num_labels': 1, 'split': 'random'},
+        'clintox': {'task_type': 'classification', 'num_labels': 2, 'split': 'scaffold'},
+        'tox21': {'task_type': 'classification', 'num_labels': 12, 'split': 'random'},
+        'bbbp': {'task_type': 'classification', 'num_labels': 1, 'split': 'scaffold'},
+        'hiv': {'task_type': 'classification', 'num_labels': 1, 'split': 'scaffold'},
+    }
+    
+    MAX_LEN = 512
+    N_TRIALS = 100  # Number of Optuna trials to run
+    
+    TOKENIZER = AutoTokenizer.from_pretrained('DeepChem/ChemBERTa-77M-MTR')
+    ENCODER_CONFIG = BertConfig(
+        vocab_size=TOKENIZER.vocab_size,
+        hidden_size=768,
+        num_hidden_layers=4,
+        num_attention_heads=12,
+        intermediate_size=2048,
+        max_position_embeddings=512
+    )
+
+    aggregated_results = {}
+
+    for name, info in DATASETS_TO_RUN.items():
+        print(f"\n{'='*20} Processing Dataset: {name.upper()} ({info['split']} split) {'='*20}")
+        smiles, labels = load_lists_from_url(name)
+
+        # For regression tasks, scale labels and remember scaling transform
+        scaler = None
+        if info["task_type"] == "regression":
+            scaler = StandardScaler()
+            all_labels = labels.values.reshape(-1, 1)
+            scaler.fit(all_labels)
+            labels = pd.Series(scaler.transform(all_labels).flatten(), index=labels.index)
+
+        # Data split
+        if info.get('split', 'scaffold') == 'scaffold':
+            splitter = ScaffoldSplitter(data=name, seed=42)
+            train_idx, val_idx, test_idx = splitter.scaffold_split()
+        elif info['split'] == 'random':
+            train_idx, val_idx, test_idx = random_split_indices(len(smiles), seed=42)
+        else:
+            raise ValueError(f"Unknown split type for {name}: {info['split']}")
+
+        train_smiles = smiles.iloc[train_idx].reset_index(drop=True)
+        train_labels = labels.iloc[train_idx].reset_index(drop=True)
+        val_smiles = smiles.iloc[val_idx].reset_index(drop=True)
+        val_labels = labels.iloc[val_idx].reset_index(drop=True)
+        test_smiles = smiles.iloc[test_idx].reset_index(drop=True)
+        test_labels = labels.iloc[test_idx].reset_index(drop=True)
+        print(f"Data split - Train: {len(train_smiles)}, Val: {len(val_smiles)}, Test: {len(test_smiles)}")
+
+        # Create Optuna study
+        study = optuna.create_study(
+            direction='maximize',
+            pruner=optuna.pruners.MedianPruner(n_startup_trials=5, n_warmup_steps=10)
+        )
+        
+        # Create objective function
+        objective_func = create_objective(
+            name, info, train_smiles, train_labels, val_smiles, val_labels,
+            test_smiles, test_labels, scaler, TOKENIZER, ENCODER_CONFIG, DEVICE
+        )
+        
+        # Run optimization
+        print(f"Starting Optuna optimization with {N_TRIALS} trials...")
+        study.optimize(objective_func, n_trials=N_TRIALS, timeout=None)
+        
+        # Get best parameters
+        best_params = study.best_params
+        best_score = study.best_value
+        print(f"Best parameters: {best_params}")
+        print(f"Best validation score: {0:.4f}")
+        
+        # Train final model with best parameters
+        print("Training final model with best parameters...")
+        train_dataset = MoleculeDataset(train_smiles, train_labels, TOKENIZER, MAX_LEN)
+        val_dataset = MoleculeDataset(val_smiles, val_labels, TOKENIZER, MAX_LEN)
+        test_dataset = MoleculeDataset(test_smiles, test_labels, TOKENIZER, MAX_LEN)
+        
+        train_loader = DataLoader(train_dataset, batch_size=best_params['batch_size'], shuffle=True)
+        val_loader = DataLoader(val_dataset, batch_size=best_params['batch_size'], shuffle=False)
+        test_loader = DataLoader(test_dataset, batch_size=best_params['batch_size'], shuffle=False)
+
+        # Final model training
+        encoder = SimSonEncoder(ENCODER_CONFIG, 512, dropout=best_params['dropout'])
+        encoder = torch.compile(encoder)
+        model = SimSonClassifier(encoder, num_labels=info['num_labels'], dropout=best_params['dropout']).to(DEVICE)
+        model.load_encoder_params('../simson_checkpoints/checkpoint_best_model.bin')
+
+        criterion = get_criterion(info['task_type'], info['num_labels'])
+        optimizer = optim.Adam(model.parameters(), lr=best_params['lr'], weight_decay=best_params['weight_decay'])
+        
+        # Set up best scheduler
+        if best_params['scheduler'] == 'plateau':
+            scheduler = optim.lr_scheduler.ReduceLROnPlateau(
+                optimizer, mode='max', factor=best_params.get('gamma', 0.7), 
+                patience=best_params.get('patience_lr', 5)
+            )
+        elif best_params['scheduler'] == 'cosine':
+            scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
+        else:
+            scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=best_params.get('gamma', 0.1))
+
+        # Train with best parameters
+        best_val_metric = -np.inf
+        best_model_state = None
+        patience_counter = 0
+        patience = 15
+        
+        for epoch in range(50):
+            train_loss = train_epoch(model, train_loader, optimizer, 
+                                   scheduler if best_params['scheduler'] == 'cosine' else None, 
+                                   criterion, DEVICE)
+            val_loss, val_metric = calc_val_metrics(model, val_loader, criterion, DEVICE, info['task_type'])
+            
+            if best_params['scheduler'] == 'plateau':
+                scheduler.step(val_loss if val_loss is not None else -val_loss)
+            elif best_params['scheduler'] == 'step':
+                scheduler.step()
+            
+            if info['task_type'] == 'classification':
+                print(f"Epoch {epoch+1}/50 | Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f} | ROC AUC: {val_metric:.4f}")
+                current_metric = val_metric if val_metric is not None else 0.0
+            else:
+                print(f"Epoch {epoch+1}/50 | Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f}")
+                current_metric = -val_loss
+
+            if current_metric <= val_loss:
+                best_val_metric = current_metric
+                best_model_state = copy.deepcopy(model.state_dict())
+                patience_counter = 0
+            else:
+                patience_counter += 1
+                if patience_counter >= patience:
+                    print(f'Early stopping at epoch {epoch+1}')
+                    break
+
+        # Test final model
+        if best_model_state is not None:
+            model.load_state_dict(best_model_state)
+        
+        test_preds, test_true = test_model(model, test_loader, DEVICE, info['task_type'])
+        
+        # Calculate final metrics
+        if info['task_type'] == 'regression' and scaler is not None:
+            test_preds = scaler.inverse_transform(test_preds.reshape(-1, 1)).flatten()
+            test_true = scaler.inverse_transform(test_true.reshape(-1, 1)).flatten()
+            rmse = root_mean_squared_error(test_true, test_preds)
+            mae = mean_absolute_error(test_true, test_preds)
+            final_score = -rmse
+            print(f"Test RMSE: {rmse:.4f}, MAE: {mae:.4f}")
+        else:
+            try:
+                final_score = roc_auc_score(test_true, test_preds, average='macro')
+                print(f"Test ROC AUC: {final_score:.4f}")
+            except Exception:
+                final_score = 0.0
+
+        # Compute embedding similarity using pre-computed augmented SMILES
+        print("Creating pre-computed augmented SMILES for similarity computation...")
+        test_smiles_list = list(test_smiles)
+        similarity_file_path = f"{name}_test_augmented.parquet"
+        create_augmented_smiles_file(test_smiles_list, similarity_file_path, num_augmentations=1)
+        
+        # Load pre-computed dataset for similarity computation
+        similarity_dataset = PrecomputedContrastiveSmilesDataset(
+            TOKENIZER, similarity_file_path, max_length=MAX_LEN
+        )
+        
+        similarities = compute_embedding_similarity_precomputed(
+            model.encoder, similarity_dataset, DEVICE
+        )
+        print(f"Similarity score: {similarities.mean():.4f}")
+        
+        # Clean up temporary file
+        if os.path.exists(similarity_file_path):
+            os.remove(similarity_file_path)
+
+        aggregated_results[name] = {
+            'best_score': final_score,
+            'best_params': best_params,
+            'optuna_trials': len(study.trials),
+            'study': study,
+            'similarity_score': similarities.mean()
+        }
+
+        if name == 'do_not_save':
+            torch.save(model.encoder.state_dict(), 'moleculenet_clintox_encoder.bin')
+
+    print(f"\n{'='*20} AGGREGATED RESULTS {'='*20}")
+    for name, result in aggregated_results.items():
+        print(f"{name}: Best score: {result['best_score']:.4f}")
+        print(f"  Best parameters: {result['best_params']}")
+        print(f"  Total trials: {result['optuna_trials']}")
+        print(f"  Similarity score: {result['similarity_score']:.4f}")
+
+    print("\nScript finished.")
+
+if __name__ == '__main__':
+    main()

simson_modeling/moleculenet_eval/.ipynb_checkpoints/eval-checkpoint.py

@@ -0,0 +1,457 @@
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from transformers import BertConfig, BertModel, AutoTokenizer
+from rdkit import Chem, RDLogger
+from rdkit.Chem.Scaffolds import MurckoScaffold
+import copy
+from tqdm import tqdm
+import os
+from sklearn.metrics import roc_auc_score, root_mean_squared_error, mean_absolute_error
+from itertools import compress
+from collections import defaultdict
+from sklearn.metrics.pairwise import cosine_similarity
+RDLogger.DisableLog('rdApp.*')
+
+
+torch.set_float32_matmul_precision('high')
+
+# --- 0. Smiles enumeration
+class SmilesEnumerator:
+    """Generates randomized SMILES strings for data augmentation."""
+    def randomize_smiles(self, smiles):
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            return Chem.MolToSmiles(mol, doRandom=True, canonical=False) if mol else smiles
+        except:
+            return smiles
+
+
+def compute_embedding_similarity(encoder, smiles_list, tokenizer, device, max_len=256):
+    encoder.eval()
+    enumerator = SmilesEnumerator()
+
+    embeddings_orig = []
+    embeddings_aug = []
+
+    with torch.no_grad():
+        for smi in smiles_list:
+            # Original SMILES encoding
+            encoding_orig = tokenizer(
+                smi,
+                truncation=True,
+                padding='max_length',
+                max_length=max_len,
+                return_tensors='pt'
+            )
+            # Augmented SMILES encoding
+            smi_aug = enumerator.randomize_smiles(smi)
+            encoding_aug = tokenizer(
+                smi_aug,
+                truncation=True,
+                padding='max_length',
+                max_length=max_len,
+                return_tensors='pt'
+            )
+
+            input_ids_orig = encoding_orig.input_ids.to(device)
+            attention_mask_orig = encoding_orig.attention_mask.to(device)
+            input_ids_aug = encoding_aug.input_ids.to(device)
+            attention_mask_aug = encoding_aug.attention_mask.to(device)
+
+            emb_orig = encoder(input_ids_orig, attention_mask_orig).cpu().numpy().flatten()
+            emb_aug = encoder(input_ids_aug, attention_mask_aug).cpu().numpy().flatten()
+
+            embeddings_orig.append(emb_orig)
+            embeddings_aug.append(emb_aug)
+
+    embeddings_orig = np.array(embeddings_orig)
+    embeddings_aug = np.array(embeddings_aug)
+
+    # Cosine similarity between each original and its augmented version
+    similarities = np.array([cosine_similarity([embeddings_orig[i]], [embeddings_aug[i]])[0][0] for i in range(len(embeddings_orig))])
+    return similarities
+
+# --- 1. Data Loading ---
+def load_lists_from_url(data):
+    if data == 'bbbp':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/BBBP.csv')
+        smiles, labels = df.smiles, df.p_np
+    elif data == 'clintox':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/clintox.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif data == 'hiv':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/HIV.csv')
+        smiles, labels = df.smiles, df.HIV_active
+    elif data == 'sider':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/sider.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif data == 'esol':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/delaney-processed.csv')
+        smiles = df.smiles
+        labels = df['ESOL predicted log solubility in mols per litre']
+    elif data == 'freesolv':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/SAMPL.csv')
+        smiles = df.smiles
+        labels = df.calc
+    elif data == 'lipophicility':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/Lipophilicity.csv')
+        smiles, labels = df.smiles, df['exp']
+    elif data == 'tox21':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/tox21.csv.gz', compression='gzip')
+        df = df.dropna(axis=0, how='any').reset_index(drop=True)
+        smiles = df.smiles
+        labels = df.drop(['mol_id', 'smiles'], axis=1)
+    elif data == 'bace':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/bace.csv')
+        smiles, labels = df.mol, df.Class
+    elif data == 'qm8':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/qm8.csv')
+        df = df.dropna(axis=0, how='any').reset_index(drop=True)
+        smiles = df.smiles
+        labels = df.drop(['smiles', 'E2-PBE0.1', 'E1-PBE0.1', 'f1-PBE0.1', 'f2-PBE0.1'], axis=1)
+    return smiles, labels
+
+# --- 2. Scaffold Splitting ---
+class ScaffoldSplitter:
+    def __init__(self, data, seed, train_frac=0.8, val_frac=0.1, test_frac=0.1, include_chirality=True):
+        self.data = data
+        self.seed = seed
+        self.include_chirality = include_chirality
+        self.train_frac = train_frac
+        self.val_frac = val_frac
+        self.test_frac = test_frac
+
+    def generate_scaffold(self, smiles):
+        mol = Chem.MolFromSmiles(smiles)
+        scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol, includeChirality=self.include_chirality)
+        return scaffold
+
+    def scaffold_split(self):
+        smiles, labels = load_lists_from_url(self.data)
+        non_null = np.ones(len(smiles)) == 0
+
+        if self.data in {'tox21', 'sider', 'clintox'}:
+            for i in range(len(smiles)):
+                if Chem.MolFromSmiles(smiles[i]) and labels.loc[i].isnull().sum() == 0:
+                    non_null[i] = 1
+        else:
+            for i in range(len(smiles)):
+                if Chem.MolFromSmiles(smiles[i]):
+                    non_null[i] = 1
+
+        smiles_list = list(compress(enumerate(smiles), non_null))
+        rng = np.random.RandomState(self.seed)
+
+        scaffolds = defaultdict(list)
+        for i, sms in smiles_list:
+            scaffold = self.generate_scaffold(sms)
+            scaffolds[scaffold].append(i)
+
+        scaffold_sets = list(scaffolds.values())
+        rng.shuffle(scaffold_sets)
+        n_total_val = int(np.floor(self.val_frac * len(smiles_list)))
+        n_total_test = int(np.floor(self.test_frac * len(smiles_list)))
+        train_idx, val_idx, test_idx = [], [], []
+
+        for scaffold_set in scaffold_sets:
+            if len(val_idx) + len(scaffold_set) <= n_total_val:
+                val_idx.extend(scaffold_set)
+            elif len(test_idx) + len(scaffold_set) <= n_total_test:
+                test_idx.extend(scaffold_set)
+            else:
+                train_idx.extend(scaffold_set)
+        return train_idx, val_idx, test_idx
+
+# --- 2a. Normal Random Split ---
+def random_split_indices(n, seed=42, train_frac=0.8, val_frac=0.1, test_frac=0.1):
+    np.random.seed(seed)
+    indices = np.random.permutation(n)
+    n_train = int(n * train_frac)
+    n_val = int(n * val_frac)
+    train_idx = indices[:n_train]
+    val_idx = indices[n_train:n_train+n_val]
+    test_idx = indices[n_train+n_val:]
+    return train_idx.tolist(), val_idx.tolist(), test_idx.tolist()
+
+# --- 3. PyTorch Dataset ---
+class MoleculeDataset(Dataset):
+    def __init__(self, smiles_list, labels, tokenizer, max_len=512):
+        self.smiles_list = smiles_list
+        self.labels = labels
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.smiles_list)
+
+    def __getitem__(self, idx):
+        smiles = self.smiles_list[idx]
+        label = self.labels.iloc[idx]
+
+        encoding = self.tokenizer(
+            smiles,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_len,
+            return_tensors='pt'
+        )
+        item = {key: val.squeeze(0) for key, val in encoding.items()}
+        if isinstance(label, pd.Series):
+            label_values = label.values.astype(np.float32)
+        else:
+            label_values = np.array([label], dtype=np.float32)
+        item['labels'] = torch.tensor(label_values, dtype=torch.float)
+        return item
+
+# --- 4. Model Architecture ---
+def global_ap(x):
+    return torch.mean(x.view(x.size(0), x.size(1), -1), dim=1)
+
+class SimSonEncoder(nn.Module):
+    def __init__(self, config: BertConfig, max_len: int, dropout: float = 0.1):
+        super(SimSonEncoder, self).__init__()
+        self.config = config
+        self.max_len = max_len
+        self.bert = BertModel(config, add_pooling_layer=False)
+        self.linear = nn.Linear(config.hidden_size, max_len)
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, input_ids, attention_mask=None):
+        if attention_mask is None:
+            attention_mask = input_ids.ne(self.config.pad_token_id)
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        hidden_states = self.dropout(outputs.last_hidden_state)
+        pooled = global_ap(hidden_states)
+        return self.linear(pooled)
+
+class SimSonClassifier(nn.Module):
+    def __init__(self, encoder: SimSonEncoder, num_labels: int, dropout=0.1):
+        super(SimSonClassifier, self).__init__()
+        self.encoder = encoder
+        self.clf = nn.Linear(encoder.max_len, num_labels)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, input_ids, attention_mask=None):
+        x = self.encoder(input_ids, attention_mask)
+        x = self.relu(self.dropout(x))
+        logits = self.clf(x)
+        return logits
+
+    def load_encoder_params(self, state_dict_path):
+        self.encoder.load_state_dict(torch.load(state_dict_path))
+        print("Pretrained encoder parameters loaded.")
+
+# --- 5. Training, Validation, and Testing Loops ---
+def get_criterion(task_type, num_labels):
+    if task_type == 'classification':
+        return nn.BCEWithLogitsLoss()
+    elif task_type == 'regression':
+        return nn.MSELoss()
+    else:
+        raise ValueError(f"Unknown task type: {task_type}")
+
+def train_epoch(model, dataloader, optimizer, scheduler, criterion, device):
+    model.train()
+    total_loss = 0
+    for batch in dataloader:
+        inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+        labels = batch['labels'].to(device)
+        optimizer.zero_grad()
+        outputs = model(**inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+        #scheduler.step()
+        total_loss += loss.item()
+    return total_loss / len(dataloader)
+
+def eval_epoch(model, dataloader, criterion, device):
+    model.eval()
+    total_loss = 0
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels'].to(device)
+            outputs = model(**inputs)
+            loss = criterion(outputs, labels)
+            total_loss += loss.item()
+    return total_loss / len(dataloader)
+
+def test_model(model, dataloader, device):
+    model.eval()
+    all_preds, all_labels = [], []
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels']
+            outputs = model(**inputs)
+            preds = torch.sigmoid(outputs)
+            all_preds.append(preds.cpu().numpy())
+            all_labels.append(labels.numpy())
+    return np.concatenate(all_preds), np.concatenate(all_labels)
+
+def calc_val_metrics(model, dataloader, criterion, device, task_type):
+    model.eval()
+    all_labels, all_preds = [], []
+    total_loss = 0
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels'].to(device)
+            outputs = model(**inputs)
+            loss = criterion(outputs, labels)
+            total_loss += loss.item()
+            if task_type == 'classification':
+                pred_probs = torch.sigmoid(outputs).cpu().numpy()
+                all_preds.append(pred_probs)
+                all_labels.append(labels.cpu().numpy())
+            else:
+                # Regression
+                preds = outputs.cpu().numpy()
+                all_preds.append(preds)
+                all_labels.append(labels.cpu().numpy())
+    avg_loss = total_loss / len(dataloader)
+    if task_type == 'classification':
+        y_true = np.concatenate(all_labels)
+        y_pred = np.concatenate(all_preds)
+        try:
+            score = roc_auc_score(y_true, y_pred, average='macro')
+        except Exception:
+            score = 0.0
+        return avg_loss, score
+    else:
+        return avg_loss, None
+
+# --- 6. Main Execution Block ---
+def main():
+    DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Using device: {DEVICE}")
+
+    DATASETS_TO_RUN = {
+        # 'esol': {'task_type': 'regression', 'num_labels': 1, 'split': 'random'},
+        #'tox21': {'task_type': 'classification', 'num_labels': 12, 'split': 'random'},
+        #'hiv': {'task_type': 'classification', 'num_labels': 1, 'split': 'scaffold'},
+        # Add more datasets here, e.g. 'bbbp': {'task_type': 'classification', 'num_labels': 1, 'split': 'random'},
+        #'sider': {'task_type': 'classification', 'num_labels': 27, 'split': 'random'},
+        #'bace': {'task_type': 'classification', 'num_labels': 1, 'split': 'random'},
+        'clintox': {'task_type': 'classification', 'num_labels': 2, 'split': 'random'},
+        #'bbbp': {'task_type': 'classification', 'num_labels': 1, 'split': 'scaffold'}
+    }
+    PATIENCE = 15
+    EPOCHS = 50
+    LEARNING_RATE = 1e-4
+    BATCH_SIZE = 16
+    MAX_LEN = 512
+
+    TOKENIZER = AutoTokenizer.from_pretrained('DeepChem/ChemBERTa-77M-MTR')
+    ENCODER_CONFIG = BertConfig(
+        vocab_size=TOKENIZER.vocab_size,
+        hidden_size=768,
+        num_hidden_layers=4,
+        num_attention_heads=12,
+        intermediate_size=2048,
+        max_position_embeddings=512
+    )
+
+    aggregated_results = {}
+
+    for name, info in DATASETS_TO_RUN.items():
+        print(f"\n{'='*20} Processing Dataset: {name.upper()} ({info['split']} split) {'='*20}")
+        smiles, labels = load_lists_from_url(name)
+
+        # Split selection
+        if info.get('split', 'scaffold') == 'scaffold':
+            splitter = ScaffoldSplitter(data=name, seed=42)
+            train_idx, val_idx, test_idx = splitter.scaffold_split()
+        elif info['split'] == 'random':
+            train_idx, val_idx, test_idx = random_split_indices(len(smiles), seed=42)
+        else:
+            raise ValueError(f"Unknown split type for {name}: {info['split']}")
+
+        train_smiles = smiles.iloc[train_idx].reset_index(drop=True)
+        train_labels = labels.iloc[train_idx].reset_index(drop=True)
+        val_smiles = smiles.iloc[val_idx].reset_index(drop=True)
+        val_labels = labels.iloc[val_idx].reset_index(drop=True)
+        test_smiles = smiles.iloc[test_idx].reset_index(drop=True)
+        test_labels = labels.iloc[test_idx].reset_index(drop=True)
+        print(f"Data split - Train: {len(train_smiles)}, Val: {len(val_smiles)}, Test: {len(test_smiles)}")
+
+        train_dataset = MoleculeDataset(train_smiles, train_labels, TOKENIZER, MAX_LEN)
+        val_dataset = MoleculeDataset(val_smiles, val_labels, TOKENIZER, MAX_LEN)
+        test_dataset = MoleculeDataset(test_smiles, test_labels, TOKENIZER, MAX_LEN)
+
+        train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+        val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False)
+        test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+        encoder = SimSonEncoder(ENCODER_CONFIG, 512)
+        encoder = torch.compile(encoder)
+        model = SimSonClassifier(encoder, num_labels=info['num_labels']).to(DEVICE)
+        model.load_encoder_params('../simson_checkpoints/checkpoint_best_model.bin')
+        criterion = get_criterion(info['task_type'], info['num_labels'])
+        optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE, weight_decay=0.0024)
+        scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.59298)
+
+        best_val_loss = float('-inf')
+        best_model_state = None
+        current_patience = 0
+        for epoch in range(EPOCHS):
+            train_loss = train_epoch(model, train_loader, optimizer, scheduler, criterion, DEVICE)
+            val_loss, val_metric = calc_val_metrics(model, val_loader, criterion, 'cuda', info['task_type'])
+            print(f"Epoch {epoch+1}/{EPOCHS} | Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f} | ROC AUC: {val_metric:.4f}")
+
+            if val_metric <= val_loss:
+                best_val_loss = val_loss
+                best_model_state = copy.deepcopy(model.state_dict())
+                print(f"  -> New best model saved with validation loss: {best_val_loss:.4f}")
+                current_patience = 0
+            else:
+                current_patience += 1
+                if current_patience >= PATIENCE:
+                    print(f'Early stopping at {PATIENCE} epochs')
+                    break
+
+        print("\nTesting with the best model...")
+        if not best_model_state is None:
+            model.load_state_dict(best_model_state)
+        test_loss = eval_epoch(model, test_loader, criterion, DEVICE)
+        print(f'Test loss: {test_loss}')
+        test_preds, test_true = test_model(model, test_loader, DEVICE)
+
+        aggregated_results[name] = {
+            'best_val_loss': best_val_loss,
+            'test_predictions': test_preds,
+            'test_labels': test_true
+        }
+        print(f"Finished testing for {name}.")
+        test_smiles_list = list(test_smiles)
+        similarities = compute_embedding_similarity(
+            model.encoder, test_smiles_list, TOKENIZER, DEVICE, MAX_LEN
+        )
+        print(f"Similarity score: {similarities.mean():.4f}")
+        if name == 'do_not_save':
+            torch.save(model.encoder.state_dict(), 'moleculenet_clintox_encoder.bin')
+
+
+
+    print(f"\n{'='*20} AGGREGATED RESULTS {'='*20}")
+    for name, result in aggregated_results.items():
+        if name in ['bbbp', 'tox21', 'sider', 'clintox', 'hiv', 'bace']:
+            auc = roc_auc_score(result['test_labels'], result['test_predictions'], average='macro')
+            print(f'{name} ROC AUC: {auc}')
+
+        if name in ['lipophicility', 'esol', 'qm8']:
+            rmse = root_mean_squared_error(result['test_labels'], result['test_predictions'])
+            mae = mean_absolute_error(result['test_labels'], result['test_predictions'])
+            print(f'{name} MAE: {mae}')
+            print(f'{name} RMSE: {rmse}')
+
+    print("\nScript finished.")
+
+if __name__ == '__main__':
+    main()

simson_modeling/moleculenet_eval/better_eval.py

@@ -0,0 +1,671 @@
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from transformers import BertConfig, BertModel, AutoTokenizer
+from rdkit import Chem, RDLogger
+from rdkit.Chem.Scaffolds import MurckoScaffold
+import copy
+from tqdm import tqdm
+import os
+from sklearn.metrics import roc_auc_score, root_mean_squared_error, mean_absolute_error
+from itertools import compress
+from collections import defaultdict
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
+import optuna
+import warnings
+warnings.filterwarnings("ignore")
+RDLogger.DisableLog('rdApp.*')
+
+torch.set_float32_matmul_precision('high')
+
+# --- 0. Pre-computed Contrastive SMILES Dataset ---
+class PrecomputedContrastiveSmilesDataset(Dataset):
+    """
+    A Dataset class that reads pre-augmented SMILES pairs from a Parquet file.
+    This is significantly faster as it offloads the expensive SMILES randomization
+    to a one-time preprocessing step.
+    """
+    def __init__(self, tokenizer, file_path: str, max_length: int = 512):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        
+        # Load the entire dataset from the Parquet file into memory.
+        # This is fast and efficient for subsequent access.
+        print(f"Loading pre-computed data from {file_path}...")
+        self.data = pd.read_parquet(file_path)
+        print("Data loaded successfully.")
+
+    def __len__(self):
+        """Returns the total number of pairs in the dataset."""
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        """
+        Retrieves a pre-augmented pair, tokenizes it, and returns it
+        in the format expected by the DataCollator.
+        """
+        # Retrieve the pre-augmented pair from the DataFrame
+        row = self.data.iloc[idx]
+        smiles_1 = row['smiles_1']
+        smiles_2 = row['smiles_2']
+        
+        # Tokenize the pair. This operation is fast and remains in the data loader.
+        tokens_1 = self.tokenizer(smiles_1, max_length=self.max_length, truncation=True, padding='max_length')
+        tokens_2 = self.tokenizer(smiles_2, max_length=self.max_length, truncation=True, padding='max_length')
+        
+        return {
+            'input_ids_1': torch.tensor(tokens_1['input_ids']),
+            'attention_mask_1': torch.tensor(tokens_1['attention_mask']),
+            'input_ids_2': torch.tensor(tokens_2['input_ids']),
+            'attention_mask_2': torch.tensor(tokens_2['attention_mask']),
+        }
+
+# --- 0a. SMILES enumeration for preprocessing ---
+class SmilesEnumerator:
+    """Generates randomized SMILES strings for data augmentation."""
+    def randomize_smiles(self, smiles):
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            return Chem.MolToSmiles(mol, doRandom=True, canonical=False) if mol else smiles
+        except:
+            return smiles
+
+def compute_embedding_similarity_precomputed(encoder, dataset, device):
+    """
+    Compute embedding similarity using pre-computed augmented SMILES pairs
+    """
+    encoder.eval()
+    similarities = []
+    
+    dataloader = DataLoader(dataset, batch_size=32, shuffle=False)
+    
+    with torch.no_grad():
+        for batch in dataloader:
+            input_ids_1 = batch['input_ids_1'].to(device)
+            attention_mask_1 = batch['attention_mask_1'].to(device)
+            input_ids_2 = batch['input_ids_2'].to(device)
+            attention_mask_2 = batch['attention_mask_2'].to(device)
+            
+            emb_1 = encoder(input_ids_1, attention_mask_1).cpu().numpy()
+            emb_2 = encoder(input_ids_2, attention_mask_2).cpu().numpy()
+            
+            # Compute cosine similarity for each pair in the batch
+            batch_similarities = []
+            for i in range(len(emb_1)):
+                sim = cosine_similarity([emb_1[i]], [emb_2[i]])[0][0]
+                batch_similarities.append(sim)
+            
+            similarities.extend(batch_similarities)
+    
+    return np.array(similarities)
+
+def create_augmented_smiles_file(smiles_list, output_path, num_augmentations=1):
+    """
+    Create a parquet file with pre-computed augmented SMILES pairs
+    """
+    enumerator = SmilesEnumerator()
+    pairs = []
+    
+    print(f"Generating {num_augmentations} augmentations for {len(smiles_list)} SMILES...")
+    
+    for smiles in tqdm(smiles_list):
+        for _ in range(num_augmentations):
+            augmented = enumerator.randomize_smiles(smiles)
+            pairs.append({
+                'smiles_1': smiles,
+                'smiles_2': augmented
+            })
+    
+    df = pd.DataFrame(pairs)
+    df.to_parquet(output_path, index=False)
+    print(f"Saved {len(pairs)} augmented pairs to {output_path}")
+    return output_path
+
+# --- 1. Data Loading ---
+def load_lists_from_url(data):
+    # Datasets and their splits, all configurations carried over
+    if data == 'bbbp':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/BBBP.csv')
+        smiles, labels = df.smiles, df.p_np
+    elif data == 'clintox':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/clintox.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif data == 'hiv':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/HIV.csv')
+        smiles, labels = df.smiles, df.HIV_active
+    elif data == 'sider':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/sider.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif data == 'esol':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/delaney-processed.csv')
+        smiles = df.smiles
+        labels = df['ESOL predicted log solubility in mols per litre']
+    elif data == 'freesolv':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/SAMPL.csv')
+        smiles = df.smiles
+        labels = df.calc
+    elif data == 'lipophicility':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/Lipophilicity.csv')
+        smiles, labels = df.smiles, df['exp']
+    elif data == 'tox21':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/tox21.csv.gz', compression='gzip')
+        df = df.dropna(axis=0, how='any').reset_index(drop=True)
+        smiles = df.smiles
+        labels = df.drop(['mol_id', 'smiles'], axis=1)
+    elif data == 'bace':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/bace.csv')
+        smiles, labels = df.mol, df.Class
+    elif data == 'qm8':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/qm8.csv')
+        df = df.dropna(axis=0, how='any').reset_index(drop=True)
+        smiles = df.smiles
+        labels = df.drop(['smiles', 'E2-PBE0.1', 'E1-PBE0.1', 'f1-PBE0.1', 'f2-PBE0.1'], axis=1)
+    return smiles, labels
+
+# --- 2. Scaffold Splitting ---
+class ScaffoldSplitter:
+    def __init__(self, data, seed, train_frac=0.8, val_frac=0.1, test_frac=0.1, include_chirality=True):
+        self.data = data
+        self.seed = seed
+        self.include_chirality = include_chirality
+        self.train_frac = train_frac
+        self.val_frac = val_frac
+        self.test_frac = test_frac
+
+    def generate_scaffold(self, smiles):
+        mol = Chem.MolFromSmiles(smiles)
+        scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol, includeChirality=self.include_chirality)
+        return scaffold
+
+    def scaffold_split(self):
+        smiles, labels = load_lists_from_url(self.data)
+        non_null = np.ones(len(smiles)) == 0
+
+        if self.data in {'tox21', 'sider', 'clintox'}:
+            for i in range(len(smiles)):
+                if Chem.MolFromSmiles(smiles[i]) and labels.loc[i].isnull().sum() == 0:
+                    non_null[i] = 1
+        else:
+            for i in range(len(smiles)):
+                if Chem.MolFromSmiles(smiles[i]):
+                    non_null[i] = 1
+
+        smiles_list = list(compress(enumerate(smiles), non_null))
+        rng = np.random.RandomState(self.seed)
+
+        scaffolds = defaultdict(list)
+        for i, sms in smiles_list:
+            scaffold = self.generate_scaffold(sms)
+            scaffolds[scaffold].append(i)
+
+        scaffold_sets = list(scaffolds.values())
+        rng.shuffle(scaffold_sets)
+        n_total_val = int(np.floor(self.val_frac * len(smiles_list)))
+        n_total_test = int(np.floor(self.test_frac * len(smiles_list)))
+        train_idx, val_idx, test_idx = [], [], []
+
+        for scaffold_set in scaffold_sets:
+            if len(val_idx) + len(scaffold_set) <= n_total_val:
+                val_idx.extend(scaffold_set)
+            elif len(test_idx) + len(scaffold_set) <= n_total_test:
+                test_idx.extend(scaffold_set)
+            else:
+                train_idx.extend(scaffold_set)
+        return train_idx, val_idx, test_idx
+
+# --- 2a. Normal Random Split ---
+def random_split_indices(n, seed=42, train_frac=0.8, val_frac=0.1, test_frac=0.1):
+    np.random.seed(seed)
+    indices = np.random.permutation(n)
+    n_train = int(n * train_frac)
+    n_val = int(n * val_frac)
+    train_idx = indices[:n_train]
+    val_idx = indices[n_train:n_train+n_val]
+    test_idx = indices[n_train+n_val:]
+    return train_idx.tolist(), val_idx.tolist(), test_idx.tolist()
+
+# --- 3. PyTorch Dataset ---
+class MoleculeDataset(Dataset):
+    def __init__(self, smiles_list, labels, tokenizer, max_len=512):
+        self.smiles_list = smiles_list
+        self.labels = labels
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.smiles_list)
+
+    def __getitem__(self, idx):
+        smiles = self.smiles_list[idx]
+        label = self.labels.iloc[idx]
+
+        encoding = self.tokenizer(
+            smiles,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_len,
+            return_tensors='pt'
+        )
+        item = {key: val.squeeze(0) for key, val in encoding.items()}
+        if isinstance(label, pd.Series):
+            label_values = label.values.astype(np.float32)
+        else:
+            label_values = np.array([label], dtype=np.float32)
+        item['labels'] = torch.tensor(label_values, dtype=torch.float)
+        return item
+
+# --- 4. Model Architecture ---
+def global_ap(x):
+    return torch.mean(x.view(x.size(0), x.size(1), -1), dim=1)
+
+class SimSonEncoder(nn.Module):
+    def __init__(self, config: BertConfig, max_len: int, dropout: float = 0.1):
+        super(SimSonEncoder, self).__init__()
+        self.config = config
+        self.max_len = max_len
+        self.bert = BertModel(config, add_pooling_layer=False)
+        self.linear = nn.Linear(config.hidden_size, max_len)
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, input_ids, attention_mask=None):
+        if attention_mask is None:
+            attention_mask = input_ids.ne(self.config.pad_token_id)
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        hidden_states = self.dropout(outputs.last_hidden_state)
+        pooled = global_ap(hidden_states)
+        return self.linear(pooled)
+
+class SimSonClassifier(nn.Module):
+    def __init__(self, encoder: SimSonEncoder, num_labels: int, dropout=0.1):
+        super(SimSonClassifier, self).__init__()
+        self.encoder = encoder
+        self.clf = nn.Linear(encoder.max_len, num_labels)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, input_ids, attention_mask=None):
+        x = self.encoder(input_ids, attention_mask)
+        x = self.relu(self.dropout(x))
+        logits = self.clf(x)
+        return logits
+
+    def load_encoder_params(self, state_dict_path):
+        self.encoder.load_state_dict(torch.load(state_dict_path))
+
+# --- 5. Training, Validation, and Testing Loops ---
+def get_criterion(task_type, num_labels):
+    if task_type == 'classification':
+        return nn.BCEWithLogitsLoss()
+    elif task_type == 'regression':
+        return nn.MSELoss()
+    else:
+        raise ValueError(f"Unknown task type: {task_type}")
+
+def train_epoch(model, dataloader, optimizer, scheduler, criterion, device):
+    model.train()
+    total_loss = 0
+    for batch in dataloader:
+        inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+        labels = batch['labels'].to(device)
+        optimizer.zero_grad()
+        outputs = model(**inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+        if scheduler is not None:
+            scheduler.step()
+        total_loss += loss.item()
+    return total_loss / len(dataloader)
+
+def calc_val_metrics(model, dataloader, criterion, device, task_type):
+    model.eval()
+    all_labels, all_preds = [], []
+    total_loss = 0
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels'].to(device)
+            outputs = model(**inputs)
+            loss = criterion(outputs, labels)
+            total_loss += loss.item()
+            if task_type == 'classification':
+                pred_probs = torch.sigmoid(outputs).cpu().numpy()
+                all_preds.append(pred_probs)
+                all_labels.append(labels.cpu().numpy())
+            else:
+                # Regression
+                preds = outputs.cpu().numpy()
+                all_preds.append(preds)
+                all_labels.append(labels.cpu().numpy())
+    avg_loss = total_loss / len(dataloader)
+    if task_type == 'classification':
+        y_true = np.concatenate(all_labels)
+        y_pred = np.concatenate(all_preds)
+        try:
+            score = roc_auc_score(y_true, y_pred, average='macro')
+        except Exception:
+            score = 0.0
+        return avg_loss, score
+    else:
+        return avg_loss, None
+
+def test_model(model, dataloader, device, task_type):
+    model.eval()
+    all_preds, all_labels = [], []
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels']
+            outputs = model(**inputs)
+            if task_type == 'classification':
+                preds = torch.sigmoid(outputs)
+            else:
+                preds = outputs
+            all_preds.append(preds.cpu().numpy())
+            all_labels.append(labels.numpy())
+    return np.concatenate(all_preds), np.concatenate(all_labels)
+
+# --- 6. Optuna Objective Function ---
+def create_objective(name, info, train_smiles, train_labels, val_smiles, val_labels, 
+                    test_smiles, test_labels, scaler, tokenizer, encoder_config, device):
+    """Creates objective function for Optuna optimization"""
+    
+    def objective(trial):
+        # Suggest hyperparameters
+        lr = trial.suggest_float('lr', 1e-6, 1e-4, log=True)
+        batch_size = trial.suggest_categorical('batch_size', [16, 32, 64, 128, 256])
+        dropout = trial.suggest_float('dropout', 0.1, 0.5)
+        weight_decay = trial.suggest_float('weight_decay', 0.0, 0.1)
+        scheduler_type = trial.suggest_categorical('scheduler', ['plateau', 'cosine', 'step'])
+        
+        # Additional hyperparameters for optimization
+        patience_lr = trial.suggest_int('patience_lr', 3, 10)
+        gamma = trial.suggest_float('gamma', 0.5, 0.9) if scheduler_type == 'step' else 0.1
+        
+        try:
+            # Create datasets and dataloaders
+            train_dataset = MoleculeDataset(train_smiles, train_labels, tokenizer, 512)
+            val_dataset = MoleculeDataset(val_smiles, val_labels, tokenizer, 512)
+            test_dataset = MoleculeDataset(test_smiles, test_labels, tokenizer, 512)
+            
+            train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+            val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
+            test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
+
+            # Create model
+            encoder = SimSonEncoder(encoder_config, 512, dropout=dropout)
+            encoder = torch.compile(encoder)
+            model = SimSonClassifier(encoder, num_labels=info['num_labels'], dropout=dropout).to(device)
+            model.load_encoder_params('../simson_checkpoints/checkpoint_best_model.bin')
+
+            criterion = get_criterion(info['task_type'], info['num_labels'])
+            optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)
+            
+            # Create scheduler based on trial suggestion
+            if scheduler_type == 'plateau':
+                scheduler = optim.lr_scheduler.ReduceLROnPlateau(
+                    optimizer, mode='max', factor=gamma, patience=patience_lr
+                )
+            elif scheduler_type == 'cosine':
+                scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
+            else:  # step
+                scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=gamma)
+
+            # Training loop
+            best_val_metric = -np.inf
+            patience_counter = 0
+            patience = 15
+            
+            for epoch in range(50):  # Max epochs
+                train_loss = train_epoch(model, train_loader, optimizer, 
+                                       scheduler if scheduler_type == 'cosine' else None, 
+                                       criterion, device)
+                val_loss, val_metric = calc_val_metrics(model, val_loader, criterion, device, info['task_type'])
+                
+                # Update scheduler
+                if scheduler_type == 'plateau':
+                    scheduler.step(val_loss if val_loss is not None else -val_loss)
+                elif scheduler_type == 'step':
+                    scheduler.step()
+                
+                # Determine metric to optimize
+                if info['task_type'] == 'classification':
+                    current_metric = val_loss if val_loss is not None else 0.0
+                else:
+                    current_metric = -val_loss  # For regression, minimize loss
+
+                # Early stopping and best model tracking
+                if current_metric <= val_loss:
+                    best_val_metric = current_metric
+                    patience_counter = 0
+                else:
+                    patience_counter += 1
+                    if patience_counter >= patience:
+                        break
+
+                # Optuna pruning
+                trial.report(current_metric, epoch)
+                if trial.should_prune():
+                    raise optuna.TrialPruned()
+
+            return best_val_metric
+            
+        except Exception as e:
+            print(f"Trial failed with error: {e}")
+            return -np.inf  # Return worst possible score for failed trials
+    
+    return objective
+
+# --- 7. Main Execution Block ---
+def main():
+    DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Using device: {DEVICE}")
+
+    DATASETS_TO_RUN = {
+        #'esol': {'task_type': 'regression', 'num_labels': 1, 'split': 'random'},
+        # Add more datasets here, e.g. 'bbbp': {'task_type': 'classification', 'num_labels': 1, 'split': 'random'},
+        #'sider': {'task_type': 'classification', 'num_labels': 27, 'split': 'random'},
+        #'bace': {'task_type': 'classification', 'num_labels': 1, 'split': 'random'},
+        'clintox': {'task_type': 'classification', 'num_labels': 2, 'split': 'scaffold'},
+        'tox21': {'task_type': 'classification', 'num_labels': 12, 'split': 'random'},
+        'bbbp': {'task_type': 'classification', 'num_labels': 1, 'split': 'scaffold'},
+        'hiv': {'task_type': 'classification', 'num_labels': 1, 'split': 'scaffold'},
+    }
+    
+    MAX_LEN = 512
+    N_TRIALS = 100  # Number of Optuna trials to run
+    
+    TOKENIZER = AutoTokenizer.from_pretrained('DeepChem/ChemBERTa-77M-MTR')
+    ENCODER_CONFIG = BertConfig(
+        vocab_size=TOKENIZER.vocab_size,
+        hidden_size=768,
+        num_hidden_layers=4,
+        num_attention_heads=12,
+        intermediate_size=2048,
+        max_position_embeddings=512
+    )
+
+    aggregated_results = {}
+
+    for name, info in DATASETS_TO_RUN.items():
+        print(f"\n{'='*20} Processing Dataset: {name.upper()} ({info['split']} split) {'='*20}")
+        smiles, labels = load_lists_from_url(name)
+
+        # For regression tasks, scale labels and remember scaling transform
+        scaler = None
+        if info["task_type"] == "regression":
+            scaler = StandardScaler()
+            all_labels = labels.values.reshape(-1, 1)
+            scaler.fit(all_labels)
+            labels = pd.Series(scaler.transform(all_labels).flatten(), index=labels.index)
+
+        # Data split
+        if info.get('split', 'scaffold') == 'scaffold':
+            splitter = ScaffoldSplitter(data=name, seed=42)
+            train_idx, val_idx, test_idx = splitter.scaffold_split()
+        elif info['split'] == 'random':
+            train_idx, val_idx, test_idx = random_split_indices(len(smiles), seed=42)
+        else:
+            raise ValueError(f"Unknown split type for {name}: {info['split']}")
+
+        train_smiles = smiles.iloc[train_idx].reset_index(drop=True)
+        train_labels = labels.iloc[train_idx].reset_index(drop=True)
+        val_smiles = smiles.iloc[val_idx].reset_index(drop=True)
+        val_labels = labels.iloc[val_idx].reset_index(drop=True)
+        test_smiles = smiles.iloc[test_idx].reset_index(drop=True)
+        test_labels = labels.iloc[test_idx].reset_index(drop=True)
+        print(f"Data split - Train: {len(train_smiles)}, Val: {len(val_smiles)}, Test: {len(test_smiles)}")
+
+        # Create Optuna study
+        study = optuna.create_study(
+            direction='maximize',
+            pruner=optuna.pruners.MedianPruner(n_startup_trials=5, n_warmup_steps=10)
+        )
+        
+        # Create objective function
+        objective_func = create_objective(
+            name, info, train_smiles, train_labels, val_smiles, val_labels,
+            test_smiles, test_labels, scaler, TOKENIZER, ENCODER_CONFIG, DEVICE
+        )
+        
+        # Run optimization
+        print(f"Starting Optuna optimization with {N_TRIALS} trials...")
+        study.optimize(objective_func, n_trials=N_TRIALS, timeout=None)
+        
+        # Get best parameters
+        best_params = study.best_params
+        best_score = study.best_value
+        print(f"Best parameters: {best_params}")
+        print(f"Best validation score: {0:.4f}")
+        
+        # Train final model with best parameters
+        print("Training final model with best parameters...")
+        train_dataset = MoleculeDataset(train_smiles, train_labels, TOKENIZER, MAX_LEN)
+        val_dataset = MoleculeDataset(val_smiles, val_labels, TOKENIZER, MAX_LEN)
+        test_dataset = MoleculeDataset(test_smiles, test_labels, TOKENIZER, MAX_LEN)
+        
+        train_loader = DataLoader(train_dataset, batch_size=best_params['batch_size'], shuffle=True)
+        val_loader = DataLoader(val_dataset, batch_size=best_params['batch_size'], shuffle=False)
+        test_loader = DataLoader(test_dataset, batch_size=best_params['batch_size'], shuffle=False)
+
+        # Final model training
+        encoder = SimSonEncoder(ENCODER_CONFIG, 512, dropout=best_params['dropout'])
+        encoder = torch.compile(encoder)
+        model = SimSonClassifier(encoder, num_labels=info['num_labels'], dropout=best_params['dropout']).to(DEVICE)
+        model.load_encoder_params('../simson_checkpoints/checkpoint_best_model.bin')
+
+        criterion = get_criterion(info['task_type'], info['num_labels'])
+        optimizer = optim.Adam(model.parameters(), lr=best_params['lr'], weight_decay=best_params['weight_decay'])
+        
+        # Set up best scheduler
+        if best_params['scheduler'] == 'plateau':
+            scheduler = optim.lr_scheduler.ReduceLROnPlateau(
+                optimizer, mode='max', factor=best_params.get('gamma', 0.7), 
+                patience=best_params.get('patience_lr', 5)
+            )
+        elif best_params['scheduler'] == 'cosine':
+            scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
+        else:
+            scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=best_params.get('gamma', 0.1))
+
+        # Train with best parameters
+        best_val_metric = -np.inf
+        best_model_state = None
+        patience_counter = 0
+        patience = 15
+        
+        for epoch in range(50):
+            train_loss = train_epoch(model, train_loader, optimizer, 
+                                   scheduler if best_params['scheduler'] == 'cosine' else None, 
+                                   criterion, DEVICE)
+            val_loss, val_metric = calc_val_metrics(model, val_loader, criterion, DEVICE, info['task_type'])
+            
+            if best_params['scheduler'] == 'plateau':
+                scheduler.step(val_loss if val_loss is not None else -val_loss)
+            elif best_params['scheduler'] == 'step':
+                scheduler.step()
+            
+            if info['task_type'] == 'classification':
+                print(f"Epoch {epoch+1}/50 | Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f} | ROC AUC: {val_metric:.4f}")
+                current_metric = val_metric if val_metric is not None else 0.0
+            else:
+                print(f"Epoch {epoch+1}/50 | Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f}")
+                current_metric = -val_loss
+
+            if current_metric <= val_loss:
+                best_val_metric = current_metric
+                best_model_state = copy.deepcopy(model.state_dict())
+                patience_counter = 0
+            else:
+                patience_counter += 1
+                if patience_counter >= patience:
+                    print(f'Early stopping at epoch {epoch+1}')
+                    break
+
+        # Test final model
+        if best_model_state is not None:
+            model.load_state_dict(best_model_state)
+        
+        test_preds, test_true = test_model(model, test_loader, DEVICE, info['task_type'])
+        
+        # Calculate final metrics
+        if info['task_type'] == 'regression' and scaler is not None:
+            test_preds = scaler.inverse_transform(test_preds.reshape(-1, 1)).flatten()
+            test_true = scaler.inverse_transform(test_true.reshape(-1, 1)).flatten()
+            rmse = root_mean_squared_error(test_true, test_preds)
+            mae = mean_absolute_error(test_true, test_preds)
+            final_score = -rmse
+            print(f"Test RMSE: {rmse:.4f}, MAE: {mae:.4f}")
+        else:
+            try:
+                final_score = roc_auc_score(test_true, test_preds, average='macro')
+                print(f"Test ROC AUC: {final_score:.4f}")
+            except Exception:
+                final_score = 0.0
+
+        # Compute embedding similarity using pre-computed augmented SMILES
+        print("Creating pre-computed augmented SMILES for similarity computation...")
+        test_smiles_list = list(test_smiles)
+        similarity_file_path = f"{name}_test_augmented.parquet"
+        create_augmented_smiles_file(test_smiles_list, similarity_file_path, num_augmentations=1)
+        
+        # Load pre-computed dataset for similarity computation
+        similarity_dataset = PrecomputedContrastiveSmilesDataset(
+            TOKENIZER, similarity_file_path, max_length=MAX_LEN
+        )
+        
+        similarities = compute_embedding_similarity_precomputed(
+            model.encoder, similarity_dataset, DEVICE
+        )
+        print(f"Similarity score: {similarities.mean():.4f}")
+        
+        # Clean up temporary file
+        if os.path.exists(similarity_file_path):
+            os.remove(similarity_file_path)
+
+        aggregated_results[name] = {
+            'best_score': final_score,
+            'best_params': best_params,
+            'optuna_trials': len(study.trials),
+            'study': study,
+            'similarity_score': similarities.mean()
+        }
+
+        if name == 'do_not_save':
+            torch.save(model.encoder.state_dict(), 'moleculenet_clintox_encoder.bin')
+
+    print(f"\n{'='*20} AGGREGATED RESULTS {'='*20}")
+    for name, result in aggregated_results.items():
+        print(f"{name}: Best score: {result['best_score']:.4f}")
+        print(f"  Best parameters: {result['best_params']}")
+        print(f"  Total trials: {result['optuna_trials']}")
+        print(f"  Similarity score: {result['similarity_score']:.4f}")
+
+    print("\nScript finished.")
+
+if __name__ == '__main__':
+    main()

simson_modeling/moleculenet_eval/eval.py

@@ -0,0 +1,457 @@
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from transformers import BertConfig, BertModel, AutoTokenizer
+from rdkit import Chem, RDLogger
+from rdkit.Chem.Scaffolds import MurckoScaffold
+import copy
+from tqdm import tqdm
+import os
+from sklearn.metrics import roc_auc_score, root_mean_squared_error, mean_absolute_error
+from itertools import compress
+from collections import defaultdict
+from sklearn.metrics.pairwise import cosine_similarity
+RDLogger.DisableLog('rdApp.*')
+
+
+torch.set_float32_matmul_precision('high')
+
+# --- 0. Smiles enumeration
+class SmilesEnumerator:
+    """Generates randomized SMILES strings for data augmentation."""
+    def randomize_smiles(self, smiles):
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            return Chem.MolToSmiles(mol, doRandom=True, canonical=False) if mol else smiles
+        except:
+            return smiles
+
+
+def compute_embedding_similarity(encoder, smiles_list, tokenizer, device, max_len=256):
+    encoder.eval()
+    enumerator = SmilesEnumerator()
+
+    embeddings_orig = []
+    embeddings_aug = []
+
+    with torch.no_grad():
+        for smi in smiles_list:
+            # Original SMILES encoding
+            encoding_orig = tokenizer(
+                smi,
+                truncation=True,
+                padding='max_length',
+                max_length=max_len,
+                return_tensors='pt'
+            )
+            # Augmented SMILES encoding
+            smi_aug = enumerator.randomize_smiles(smi)
+            encoding_aug = tokenizer(
+                smi_aug,
+                truncation=True,
+                padding='max_length',
+                max_length=max_len,
+                return_tensors='pt'
+            )
+
+            input_ids_orig = encoding_orig.input_ids.to(device)
+            attention_mask_orig = encoding_orig.attention_mask.to(device)
+            input_ids_aug = encoding_aug.input_ids.to(device)
+            attention_mask_aug = encoding_aug.attention_mask.to(device)
+
+            emb_orig = encoder(input_ids_orig, attention_mask_orig).cpu().numpy().flatten()
+            emb_aug = encoder(input_ids_aug, attention_mask_aug).cpu().numpy().flatten()
+
+            embeddings_orig.append(emb_orig)
+            embeddings_aug.append(emb_aug)
+
+    embeddings_orig = np.array(embeddings_orig)
+    embeddings_aug = np.array(embeddings_aug)
+
+    # Cosine similarity between each original and its augmented version
+    similarities = np.array([cosine_similarity([embeddings_orig[i]], [embeddings_aug[i]])[0][0] for i in range(len(embeddings_orig))])
+    return similarities
+
+# --- 1. Data Loading ---
+def load_lists_from_url(data):
+    if data == 'bbbp':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/BBBP.csv')
+        smiles, labels = df.smiles, df.p_np
+    elif data == 'clintox':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/clintox.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif data == 'hiv':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/HIV.csv')
+        smiles, labels = df.smiles, df.HIV_active
+    elif data == 'sider':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/sider.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif data == 'esol':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/delaney-processed.csv')
+        smiles = df.smiles
+        labels = df['ESOL predicted log solubility in mols per litre']
+    elif data == 'freesolv':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/SAMPL.csv')
+        smiles = df.smiles
+        labels = df.calc
+    elif data == 'lipophicility':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/Lipophilicity.csv')
+        smiles, labels = df.smiles, df['exp']
+    elif data == 'tox21':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/tox21.csv.gz', compression='gzip')
+        df = df.dropna(axis=0, how='any').reset_index(drop=True)
+        smiles = df.smiles
+        labels = df.drop(['mol_id', 'smiles'], axis=1)
+    elif data == 'bace':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/bace.csv')
+        smiles, labels = df.mol, df.Class
+    elif data == 'qm8':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/qm8.csv')
+        df = df.dropna(axis=0, how='any').reset_index(drop=True)
+        smiles = df.smiles
+        labels = df.drop(['smiles', 'E2-PBE0.1', 'E1-PBE0.1', 'f1-PBE0.1', 'f2-PBE0.1'], axis=1)
+    return smiles, labels
+
+# --- 2. Scaffold Splitting ---
+class ScaffoldSplitter:
+    def __init__(self, data, seed, train_frac=0.8, val_frac=0.1, test_frac=0.1, include_chirality=True):
+        self.data = data
+        self.seed = seed
+        self.include_chirality = include_chirality
+        self.train_frac = train_frac
+        self.val_frac = val_frac
+        self.test_frac = test_frac
+
+    def generate_scaffold(self, smiles):
+        mol = Chem.MolFromSmiles(smiles)
+        scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol, includeChirality=self.include_chirality)
+        return scaffold
+
+    def scaffold_split(self):
+        smiles, labels = load_lists_from_url(self.data)
+        non_null = np.ones(len(smiles)) == 0
+
+        if self.data in {'tox21', 'sider', 'clintox'}:
+            for i in range(len(smiles)):
+                if Chem.MolFromSmiles(smiles[i]) and labels.loc[i].isnull().sum() == 0:
+                    non_null[i] = 1
+        else:
+            for i in range(len(smiles)):
+                if Chem.MolFromSmiles(smiles[i]):
+                    non_null[i] = 1
+
+        smiles_list = list(compress(enumerate(smiles), non_null))
+        rng = np.random.RandomState(self.seed)
+
+        scaffolds = defaultdict(list)
+        for i, sms in smiles_list:
+            scaffold = self.generate_scaffold(sms)
+            scaffolds[scaffold].append(i)
+
+        scaffold_sets = list(scaffolds.values())
+        rng.shuffle(scaffold_sets)
+        n_total_val = int(np.floor(self.val_frac * len(smiles_list)))
+        n_total_test = int(np.floor(self.test_frac * len(smiles_list)))
+        train_idx, val_idx, test_idx = [], [], []
+
+        for scaffold_set in scaffold_sets:
+            if len(val_idx) + len(scaffold_set) <= n_total_val:
+                val_idx.extend(scaffold_set)
+            elif len(test_idx) + len(scaffold_set) <= n_total_test:
+                test_idx.extend(scaffold_set)
+            else:
+                train_idx.extend(scaffold_set)
+        return train_idx, val_idx, test_idx
+
+# --- 2a. Normal Random Split ---
+def random_split_indices(n, seed=42, train_frac=0.8, val_frac=0.1, test_frac=0.1):
+    np.random.seed(seed)
+    indices = np.random.permutation(n)
+    n_train = int(n * train_frac)
+    n_val = int(n * val_frac)
+    train_idx = indices[:n_train]
+    val_idx = indices[n_train:n_train+n_val]
+    test_idx = indices[n_train+n_val:]
+    return train_idx.tolist(), val_idx.tolist(), test_idx.tolist()
+
+# --- 3. PyTorch Dataset ---
+class MoleculeDataset(Dataset):
+    def __init__(self, smiles_list, labels, tokenizer, max_len=512):
+        self.smiles_list = smiles_list
+        self.labels = labels
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.smiles_list)
+
+    def __getitem__(self, idx):
+        smiles = self.smiles_list[idx]
+        label = self.labels.iloc[idx]
+
+        encoding = self.tokenizer(
+            smiles,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_len,
+            return_tensors='pt'
+        )
+        item = {key: val.squeeze(0) for key, val in encoding.items()}
+        if isinstance(label, pd.Series):
+            label_values = label.values.astype(np.float32)
+        else:
+            label_values = np.array([label], dtype=np.float32)
+        item['labels'] = torch.tensor(label_values, dtype=torch.float)
+        return item
+
+# --- 4. Model Architecture ---
+def global_ap(x):
+    return torch.mean(x.view(x.size(0), x.size(1), -1), dim=1)
+
+class SimSonEncoder(nn.Module):
+    def __init__(self, config: BertConfig, max_len: int, dropout: float = 0.1):
+        super(SimSonEncoder, self).__init__()
+        self.config = config
+        self.max_len = max_len
+        self.bert = BertModel(config, add_pooling_layer=False)
+        self.linear = nn.Linear(config.hidden_size, max_len)
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, input_ids, attention_mask=None):
+        if attention_mask is None:
+            attention_mask = input_ids.ne(self.config.pad_token_id)
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        hidden_states = self.dropout(outputs.last_hidden_state)
+        pooled = global_ap(hidden_states)
+        return self.linear(pooled)
+
+class SimSonClassifier(nn.Module):
+    def __init__(self, encoder: SimSonEncoder, num_labels: int, dropout=0.1):
+        super(SimSonClassifier, self).__init__()
+        self.encoder = encoder
+        self.clf = nn.Linear(encoder.max_len, num_labels)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, input_ids, attention_mask=None):
+        x = self.encoder(input_ids, attention_mask)
+        x = self.relu(self.dropout(x))
+        logits = self.clf(x)
+        return logits
+
+    def load_encoder_params(self, state_dict_path):
+        self.encoder.load_state_dict(torch.load(state_dict_path))
+        print("Pretrained encoder parameters loaded.")
+
+# --- 5. Training, Validation, and Testing Loops ---
+def get_criterion(task_type, num_labels):
+    if task_type == 'classification':
+        return nn.BCEWithLogitsLoss()
+    elif task_type == 'regression':
+        return nn.MSELoss()
+    else:
+        raise ValueError(f"Unknown task type: {task_type}")
+
+def train_epoch(model, dataloader, optimizer, scheduler, criterion, device):
+    model.train()
+    total_loss = 0
+    for batch in dataloader:
+        inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+        labels = batch['labels'].to(device)
+        optimizer.zero_grad()
+        outputs = model(**inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+        #scheduler.step()
+        total_loss += loss.item()
+    return total_loss / len(dataloader)
+
+def eval_epoch(model, dataloader, criterion, device):
+    model.eval()
+    total_loss = 0
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels'].to(device)
+            outputs = model(**inputs)
+            loss = criterion(outputs, labels)
+            total_loss += loss.item()
+    return total_loss / len(dataloader)
+
+def test_model(model, dataloader, device):
+    model.eval()
+    all_preds, all_labels = [], []
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels']
+            outputs = model(**inputs)
+            preds = torch.sigmoid(outputs)
+            all_preds.append(preds.cpu().numpy())
+            all_labels.append(labels.numpy())
+    return np.concatenate(all_preds), np.concatenate(all_labels)
+
+def calc_val_metrics(model, dataloader, criterion, device, task_type):
+    model.eval()
+    all_labels, all_preds = [], []
+    total_loss = 0
+    with torch.no_grad():
+        for batch in dataloader:
+            inputs = {k: v.to(device) for k, v in batch.items() if k != 'labels'}
+            labels = batch['labels'].to(device)
+            outputs = model(**inputs)
+            loss = criterion(outputs, labels)
+            total_loss += loss.item()
+            if task_type == 'classification':
+                pred_probs = torch.sigmoid(outputs).cpu().numpy()
+                all_preds.append(pred_probs)
+                all_labels.append(labels.cpu().numpy())
+            else:
+                # Regression
+                preds = outputs.cpu().numpy()
+                all_preds.append(preds)
+                all_labels.append(labels.cpu().numpy())
+    avg_loss = total_loss / len(dataloader)
+    if task_type == 'classification':
+        y_true = np.concatenate(all_labels)
+        y_pred = np.concatenate(all_preds)
+        try:
+            score = roc_auc_score(y_true, y_pred, average='macro')
+        except Exception:
+            score = 0.0
+        return avg_loss, score
+    else:
+        return avg_loss, None
+
+# --- 6. Main Execution Block ---
+def main():
+    DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Using device: {DEVICE}")
+
+    DATASETS_TO_RUN = {
+        # 'esol': {'task_type': 'regression', 'num_labels': 1, 'split': 'random'},
+        #'tox21': {'task_type': 'classification', 'num_labels': 12, 'split': 'random'},
+        #'hiv': {'task_type': 'classification', 'num_labels': 1, 'split': 'scaffold'},
+        # Add more datasets here, e.g. 'bbbp': {'task_type': 'classification', 'num_labels': 1, 'split': 'random'},
+        #'sider': {'task_type': 'classification', 'num_labels': 27, 'split': 'random'},
+        #'bace': {'task_type': 'classification', 'num_labels': 1, 'split': 'random'},
+        'clintox': {'task_type': 'classification', 'num_labels': 2, 'split': 'random'},
+        #'bbbp': {'task_type': 'classification', 'num_labels': 1, 'split': 'scaffold'}
+    }
+    PATIENCE = 15
+    EPOCHS = 50
+    LEARNING_RATE = 1e-4
+    BATCH_SIZE = 16
+    MAX_LEN = 512
+
+    TOKENIZER = AutoTokenizer.from_pretrained('DeepChem/ChemBERTa-77M-MTR')
+    ENCODER_CONFIG = BertConfig(
+        vocab_size=TOKENIZER.vocab_size,
+        hidden_size=768,
+        num_hidden_layers=4,
+        num_attention_heads=12,
+        intermediate_size=2048,
+        max_position_embeddings=512
+    )
+
+    aggregated_results = {}
+
+    for name, info in DATASETS_TO_RUN.items():
+        print(f"\n{'='*20} Processing Dataset: {name.upper()} ({info['split']} split) {'='*20}")
+        smiles, labels = load_lists_from_url(name)
+
+        # Split selection
+        if info.get('split', 'scaffold') == 'scaffold':
+            splitter = ScaffoldSplitter(data=name, seed=42)
+            train_idx, val_idx, test_idx = splitter.scaffold_split()
+        elif info['split'] == 'random':
+            train_idx, val_idx, test_idx = random_split_indices(len(smiles), seed=42)
+        else:
+            raise ValueError(f"Unknown split type for {name}: {info['split']}")
+
+        train_smiles = smiles.iloc[train_idx].reset_index(drop=True)
+        train_labels = labels.iloc[train_idx].reset_index(drop=True)
+        val_smiles = smiles.iloc[val_idx].reset_index(drop=True)
+        val_labels = labels.iloc[val_idx].reset_index(drop=True)
+        test_smiles = smiles.iloc[test_idx].reset_index(drop=True)
+        test_labels = labels.iloc[test_idx].reset_index(drop=True)
+        print(f"Data split - Train: {len(train_smiles)}, Val: {len(val_smiles)}, Test: {len(test_smiles)}")
+
+        train_dataset = MoleculeDataset(train_smiles, train_labels, TOKENIZER, MAX_LEN)
+        val_dataset = MoleculeDataset(val_smiles, val_labels, TOKENIZER, MAX_LEN)
+        test_dataset = MoleculeDataset(test_smiles, test_labels, TOKENIZER, MAX_LEN)
+
+        train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+        val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False)
+        test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+        encoder = SimSonEncoder(ENCODER_CONFIG, 512)
+        encoder = torch.compile(encoder)
+        model = SimSonClassifier(encoder, num_labels=info['num_labels']).to(DEVICE)
+        model.load_encoder_params('../simson_checkpoints/checkpoint_best_model.bin')
+        criterion = get_criterion(info['task_type'], info['num_labels'])
+        optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE, weight_decay=0.0024)
+        scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.59298)
+
+        best_val_loss = float('-inf')
+        best_model_state = None
+        current_patience = 0
+        for epoch in range(EPOCHS):
+            train_loss = train_epoch(model, train_loader, optimizer, scheduler, criterion, DEVICE)
+            val_loss, val_metric = calc_val_metrics(model, val_loader, criterion, 'cuda', info['task_type'])
+            print(f"Epoch {epoch+1}/{EPOCHS} | Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f} | ROC AUC: {val_metric:.4f}")
+
+            if val_metric <= val_loss:
+                best_val_loss = val_loss
+                best_model_state = copy.deepcopy(model.state_dict())
+                print(f"  -> New best model saved with validation loss: {best_val_loss:.4f}")
+                current_patience = 0
+            else:
+                current_patience += 1
+                if current_patience >= PATIENCE:
+                    print(f'Early stopping at {PATIENCE} epochs')
+                    break
+
+        print("\nTesting with the best model...")
+        if not best_model_state is None:
+            model.load_state_dict(best_model_state)
+        test_loss = eval_epoch(model, test_loader, criterion, DEVICE)
+        print(f'Test loss: {test_loss}')
+        test_preds, test_true = test_model(model, test_loader, DEVICE)
+
+        aggregated_results[name] = {
+            'best_val_loss': best_val_loss,
+            'test_predictions': test_preds,
+            'test_labels': test_true
+        }
+        print(f"Finished testing for {name}.")
+        test_smiles_list = list(test_smiles)
+        similarities = compute_embedding_similarity(
+            model.encoder, test_smiles_list, TOKENIZER, DEVICE, MAX_LEN
+        )
+        print(f"Similarity score: {similarities.mean():.4f}")
+        if name == 'do_not_save':
+            torch.save(model.encoder.state_dict(), 'moleculenet_clintox_encoder.bin')
+
+
+
+    print(f"\n{'='*20} AGGREGATED RESULTS {'='*20}")
+    for name, result in aggregated_results.items():
+        if name in ['bbbp', 'tox21', 'sider', 'clintox', 'hiv', 'bace']:
+            auc = roc_auc_score(result['test_labels'], result['test_predictions'], average='macro')
+            print(f'{name} ROC AUC: {auc}')
+
+        if name in ['lipophicility', 'esol', 'qm8']:
+            rmse = root_mean_squared_error(result['test_labels'], result['test_predictions'])
+            mae = mean_absolute_error(result['test_labels'], result['test_predictions'])
+            print(f'{name} MAE: {mae}')
+            print(f'{name} RMSE: {rmse}')
+
+    print("\nScript finished.")
+
+if __name__ == '__main__':
+    main()

simson_modeling/moleculenet_eval/eval.py.save

@@ -0,0 +1,360 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+import pandas as pd
+import numpy as np
+from sklearn.metrics import roc_auc_score, average_precision_score
+from transformers import BertModel, BertConfig
+import os
+import json
+from collections import defaultdict
+from rdkit import Chem
+from rdkit.Chem import Scaffolds
+import warnings
+warnings.filterwarnings('ignore')
+from transformers import AutoTokenizer
+
+# Global average pooling function (assuming this exists in your codebase)
+def global_ap(x, dim=1):
+    return torch.mean(x, dim=dim)
+
+class SimSonClassifier(nn.Module):
+    def __init__(self, config: BertConfig, max_len: int, num_labels: int, dropout: float = 0.1):
+        super(SimSonClassifier, self).__init__()
+        self.config = config
+        self.max_len = max_len
+        self.num_labels = num_labels
+        
+        # BERT encoder (same as SimSonEncoder)
+        self.bert = BertModel(config, add_pooling_layer=False)
+        self.dropout = nn.Dropout(dropout)
+        
+        # Classification head
+        self.classifier = nn.Linear(config.hidden_size, num_labels)
+        
+    def forward(self, input_ids, attention_mask=None):
+        if attention_mask is None:
+            attention_mask = input_ids.ne(0)
+            
+        outputs = self.bert(
+            input_ids=input_ids,
+            attention_mask=attention_mask
+        )
+        
+        hidden_states = outputs.last_hidden_state
+        hidden_states = self.dropout(hidden_states)
+        
+        # Global average pooling
+        pooled = global_ap(hidden_states)
+        
+        # Classification output
+        logits = self.classifier(pooled)
+        
+        return logits
+    
+    def load_encoder_weights(self, encoder_path):
+        """Load pretrained SimSonEncoder weights into the classifier"""
+        encoder_state = torch.load(encoder_path, map_location='cpu')
+        
+        # Create mapping from encoder to classifier state dict
+        classifier_state = {}
+        for key, value in encoder_state.items():
+            if key.startswith('bert.') or key.startswith('dropout.'):
+                classifier_state[key] = value
+        
+        # Load only the matching weights
+        self.load_state_dict(classifier_state, strict=False)
+        print(f"Loaded encoder weights from {encoder_path}")
+
+
+
+def load_moleculenet_data(dataset_name):
+    """Load MoleculeNet dataset and return SMILES and labels"""
+    if dataset_name == 'bbbp':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/BBBP.csv')
+        smiles, labels = df.smiles, df.p_np
+    elif dataset_name == 'clintox':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/clintox.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif dataset_name == 'hiv':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/HIV.csv')
+        smiles, labels = df.smiles, df.HIV_active
+    elif dataset_name == 'sider':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/sider.csv.gz', compression='gzip')
+        smiles = df.smiles
+        labels = df.drop(['smiles'], axis=1)
+    elif dataset_name == 'tox21':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/tox21.csv.gz', compression='gzip')
+        df = df.dropna(axis=0, how='any').reset_index(drop=True)
+        smiles = df.smiles
+        labels = df.drop(['mol_id', 'smiles'], axis=1)
+    elif dataset_name == 'bace':
+        df = pd.read_csv('https://deepchemdata.s3-us-west-1.amazonaws.com/datasets/bace.csv')
+        smiles, labels = df.mol, df.Class
+    else:
+        raise ValueError(f"Dataset {dataset_name} not supported")
+    
+    return smiles, labels
+
+class MoleculeDataset(Dataset):
+    def __init__(self, smiles_list, labels, tokenizer, max_length=512):
+        self.smiles = smiles_list
+        self.labels = labels
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+    
+    def __len__(self):
+        return len(self.smiles)
+    
+    def __getitem__(self, idx):
+        smiles = self.smiles[idx]
+        
+        # Tokenize SMILES
+        encoding = self.tokenizer(
+            smiles,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_length,
+            return_tensors='pt'
+        )
+        
+        # Handle labels
+        if isinstance(self.labels, pd.Series):
+            label = torch.tensor(self.labels.iloc[idx], dtype=torch.float32)
+        else:  # DataFrame (multi-label)
+            label = torch.tensor(self.labels.iloc[idx].values, dtype=torch.float32)
+        
+        return {
+            'input_ids': encoding['input_ids'].flatten(),
+            'attention_mask': encoding['attention_mask'].flatten(),
+            'labels': label
+        }
+
+def get_loss_fn(num_labels):
+    """Get appropriate loss function based on number of labels"""
+    if num_labels == 1:
+        return nn.BCEWithLogitsLoss()
+    else:
+        return nn.BCEWithLogitsLoss()  # Multi-label classification
+
+def compute_metrics(predictions, labels, num_labels):
+    """Compute ROC-AUC for single or multi-label classification"""
+    predictions = torch.sigmoid(predictions).cpu().numpy()
+    labels = labels.cpu().numpy()
+    
+    if num_labels == 1:
+        # Single label
+        try:
+            auc = roc_auc_score(labels, predictions)
+            return {'roc_auc': auc}
+        except:
+            return {'roc_auc': 0.5}
+    else:
+        # Multi-label
+        aucs = []
+        for i in range(num_labels):
+            try:
+                auc = roc_auc_score(labels[:, i], predictions[:, i])
+                aucs.append(auc)
+            except:
+                aucs.append(0.5)
+        return {'roc_auc': np.mean(aucs), 'individual_aucs': aucs}
+
+def train_epoch(model, dataloader, optimizer, loss_fn, device):
+    model.train()
+    total_loss = 0
+    
+    for batch in dataloader:
+        input_ids = batch['input_ids'].to(device)
+        attention_mask = batch['attention_mask'].to(device)
+        labels = batch['labels'].to(device)
+        
+        optimizer.zero_grad()
+        
+        outputs = model(input_ids, attention_mask)
+        loss = loss_fn(outputs, labels)
+        
+        loss.backward()
+        optimizer.step()
+        
+        total_loss += loss.item()
+    
+    return total_loss / len(dataloader)
+
+def evaluate(model, dataloader, loss_fn, num_labels, device):
+    model.eval()
+    total_loss = 0
+    all_predictions = []
+    all_labels = []
+    
+    with torch.no_grad():
+        for batch in dataloader:
+            input_ids = batch['input_ids'].to(device)
+            attention_mask = batch['attention_mask'].to(device)
+            labels = batch['labels'].to(device)
+            
+            outputs = model(input_ids, attention_mask)
+            loss = loss_fn(outputs, labels)
+            
+            total_loss += loss.item()
+            all_predictions.append(outputs)
+            all_labels.append(labels)
+    
+    all_predictions = torch.cat(all_predictions)
+    all_labels = torch.cat(all_labels)
+    
+    metrics = compute_metrics(all_predictions, all_labels, num_labels)
+    avg_loss = total_loss / len(dataloader)
+    
+    return avg_loss, metrics
+
+def run_experiment(dataset_name, config, tokenizer, encoder_path=None, 
+                  batch_size=32, learning_rate=1e-4, epochs=50, device='cuda'):
+    """Run complete experiment for one dataset"""
+    print(f"\n=== Running experiment for {dataset_name.upper()} ===")
+    
+    # Load data
+    smiles, labels = load_moleculenet_data(dataset_name)
+    print(f"Loaded {len(smiles)} samples")
+    
+    # Determine number of labels
+    if isinstance(labels, pd.Series):
+        num_labels = 1
+    else:
+        num_labels = labels.shape[1]
+    print(f"Number of labels: {num_labels}")
+    
+    # Scaffold split
+    smiles_list = smiles.tolist()
+    train_idx, valid_idx, test_idx = scaffold_split(smiles_list)
+        
+    print(f"Split sizes - Train: {len(train_idx)}, Valid: {len(valid_idx)}, Test: {len(test_idx)}")
+    # Create datasets
+    train_smiles = [smiles_list[i] for i in train_idx]
+    valid_smiles = [smiles_list[i] for i in valid_idx]
+    test_smiles = [smiles_list[i] for i in test_idx]
+    
+    if isinstance(labels, pd.Series):
+        train_labels = labels.iloc[list(train_idx)]
+        valid_labels = labels.iloc[list(valid_idx)]
+        test_labels = labels.iloc[list(test_idx)]
+    else:
+        train_labels = labels.iloc[list(train_idx)]
+        valid_labels = labels.iloc[list(valid_idx)]
+        test_labels = labels.iloc[list(test_idx)]
+    
+    # Create data loaders
+    train_dataset = MoleculeDataset(train_smiles, train_labels, tokenizer)
+    valid_dataset = MoleculeDataset(valid_smiles, valid_labels, tokenizer)
+    test_dataset = MoleculeDataset(test_smiles, test_labels, tokenizer)
+    
+    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+    valid_loader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False)
+    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
+    
+    # Initialize model
+    model = SimSonClassifier(config, max_len=512, num_labels=num_labels).to(device)
+    
+    # Load encoder weights if provided
+    if encoder_path:
+        model.load_encoder_weights(encoder_path)
+    
+    # Setup training
+    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+    loss_fn = get_loss_fn(num_labels)
+    
+    best_valid_loss = float('inf')
+    best_model_path = f'best_{dataset_name}_model.pth'
+    
+    # Training loop
+    for epoch in range(epochs):
+        train_loss = train_epoch(model, train_loader, optimizer, loss_fn, device)
+        valid_loss, valid_metrics = evaluate(model, valid_loader, loss_fn, num_labels, device)
+        
+        # Save best model
+        if valid_loss < best_valid_loss:
+            best_valid_loss = valid_loss
+            torch.save(model.state_dict(), best_model_path)
+        
+        if epoch % 10 == 0:
+            print(f"Epoch {epoch}: Train Loss = {train_loss:.4f}, "
+                  f"Valid Loss = {valid_loss:.4f}, Valid AUC = {valid_metrics['roc_auc']:.4f}")
+    
+    # Load best model and test
+    model.load_state_dict(torch.load(best_model_path))
+    test_loss, test_metrics = evaluate(model, test_loader, loss_fn, num_labels, device)
+    
+    print(f"Final Test Results - Loss: {test_loss:.4f}, ROC-AUC: {test_metrics['roc_auc']:.4f}")
+    
+    # Cleanup
+    os.remove(best_model_path)
+    
+    return {
+        'dataset': dataset_name,
+        'num_labels': num_labels,
+        'test_loss': test_loss,
+        'test_roc_auc': test_metrics['roc_auc'],
+        'individual_aucs': test_metrics.get('individual_aucs', None)
+    }
+
+def main():
+    """Main function to run all experiments"""
+    # Setup
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    print(f"Using device: {device}")
+    
+    # Initialize tokenizer and config (you need to provide these)
+    # tokenizer = your_tokenizer  # Replace with your tokenizer
+    # config = BertConfig(...)     # Your config from above
+    tokenizer_path = 'DeepChem/ChemBERTa-77M-MTR'
+    tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
+
+    # Only the hidden size is slightly larger, everything else is the same
+    config = BertConfig(
+            vocab_size=tokenizer.vocab_size,
+            hidden_size=768,
+            num_hidden_layers=4,
+            num_attention_heads=12,
+            intermediate_size=2048,
+            max_position_embeddings=512
+    )
+    # Datasets to test
+    datasets = ['bbbp', 'tox21', 'sider', 'clintox', 'hiv', 'bace']
+    
+    # Path to your pretrained encoder (optional)
+    encoder_path = 'simson_checkpoints_small/simson_model_single_gpu.bin'
+    
+    # Run experiments
+    all_results = []
+    for dataset in datasets:
+        try:
+            result = run_experiment(
+                dataset, 
+                config, 
+                tokenizer, 
+                encoder_path=encoder_path,
+                device=device
+            )
+            all_results.append(result)
+        except Exception as e:
+            print(f"Error with {dataset}: {e}")
+    
+    # Aggregate and display results
+    print("\n" + "="*60)
+    print("FINAL RESULTS SUMMARY")
+    print("="*60)
+    
+    results_df = pd.DataFrame(all_results)
+    print(results_df.to_string(index=False))
+    
+    # Save results
+    results_df.to_csv('moleculenet_results.csv', index=False)
+    print(f"\nResults saved to moleculenet_results.csv")
+    
+    return results_df
+
+if __name__ == "__main__":
+    
+    results = main()