robert 2.0.2__tar.gz → 2.1.0__tar.gz

{robert-2.0.2 → robert-2.1.0}/PKG-INFO

@@ -1,41 +1,54 @@
-Metadata-Version: 2.1
-Name: robert
-Version: 2.0.2
-Summary: Refiner and Optimizer of a Bunch of Existing Regression Tools
-Home-page: https://github.com/jvalegre/robert
-Download-URL: https://github.com/jvalegre/robert/archive/refs/tags/2.0.2.tar.gz
-Author: Juan V. Alegre Requena, David Dalmau
-Author-email: jv.alegre@csic.es
-License: MIT
-Keywords: workflows,machine learning,cheminformatics,data curation,prediction,automated
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Build Tools
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: PyYAML==6.0.2
-Requires-Dist: matplotlib==3.10.0
-Requires-Dist: pandas==2.2.3
-Requires-Dist: numpy==1.26.4
-Requires-Dist: progress==1.6
-Requires-Dist: seaborn==0.13.2
-Requires-Dist: scipy==1.15.0
-Requires-Dist: scikit-learn==1.6.0
-Requires-Dist: bayesian-optimization==3.0.0b1
-Requires-Dist: numba==0.60.0
-Requires-Dist: shap==0.46.0
-Requires-Dist: weasyprint==63.1
-Requires-Dist: PySide6
-Requires-Dist: PyMuPDF
-Requires-Dist: ansi2html
-Requires-Dist: rdkit==2024.3.3
-
-Documentation in Read The Docs: https://robert.readthedocs.io
+Metadata-Version: 2.4
+Name: robert
+Version: 2.1.0
+Summary: Refiner and Optimizer of a Bunch of Existing Regression Tools
+Home-page: https://github.com/jvalegre/robert
+Download-URL: https://github.com/jvalegre/robert/archive/refs/tags/2.1.0.tar.gz
+Author: Juan V. Alegre Requena, David Dalmau
+Author-email: jv.alegre@csic.es
+License: MIT
+Keywords: workflows,machine learning,cheminformatics,data curation,prediction,automated
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML==6.0.3
+Requires-Dist: matplotlib==3.10.0
+Requires-Dist: pandas==2.3.3
+Requires-Dist: numpy==2.3.4
+Requires-Dist: progress==1.6.1
+Requires-Dist: seaborn==0.13.2
+Requires-Dist: scipy==1.15.0
+Requires-Dist: scikit-learn==1.7.2
+Requires-Dist: bayesian-optimization==3.1.0
+Requires-Dist: numba==0.62.1
+Requires-Dist: shap==0.49.1
+Requires-Dist: weasyprint==63.1
+Requires-Dist: PySide6==6.9.2
+Requires-Dist: PyMuPDF
+Requires-Dist: ansi2html
+Requires-Dist: rdkit==2025.9.1
+Requires-Dist: psutil==7.0.0
+Requires-Dist: requests==2.32.5
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Documentation in Read The Docs: https://robert.readthedocs.io

{robert-2.0.2 → robert-2.1.0}/README.md

@@ -20,7 +20,6 @@ Don't miss out the latest hands-on tutorials from our [YouTube channel](https://
 3. Install ROBERT using pip: `pip install robert`
 4. Install RDKit (only if you plan to use easyROB): `pip install rdkit`
 5. Install libraries for the PDF report `conda install -y -c conda-forge glib gtk3 pango mscorefonts`
-6. (Only for compatible devices) Install Intelex accelerator: `pip install scikit-learn-intelex==2025.2.0`  
 * Inexperienced users should visit the *Users with no Python experience* section in [Read the Docs](https://robert.readthedocs.io).
 ## Update the program
 1. Update to the latest version: `pip install robert --upgrade`

{robert-2.0.2 → robert-2.1.0}/robert/aqme.py

@@ -35,7 +35,7 @@ from robert.utils import (load_variables,
     )
 
 # list of potential arguments from CSV inputs in AQME
-aqme_args = ['charge','mult','complex_type','geom','constraints_atoms','constraints_dist','constraints_angle','constraints_dihedral']
+aqme_args = ['charge','mult','complex_type','geom','constraints_atoms','constraints_dist','constraints_angle','constraints_dihedral','sample']
 
 class aqme:
     """
@@ -79,13 +79,15 @@ class aqme:
         # load database just to perform data checks (i.e. no need to run AQME if the specified y is not
         # in the database, since the program would crush in the subsequent CURATE job)
         job_type = 'aqme'
+        path_sdf = Path(f'{os.getcwd()}/CSEARCH/sdf_temp')
         if aqme_test:
             job_type = 'aqme_test'
+            if not path_sdf.exists():
+                path_sdf.mkdir(exist_ok=True, parents=True)
 
         # move the SDF files from the csv_name run (otherwise, the xTB calcs are repeated in csv_test)
         else:
-            path_sdf = Path(f'{os.getcwd()}/CSEARCH/sdf_temp')
-            if os.path.exists(path_sdf):
+            if path_sdf.exists():
                 shutil.rmtree(path_sdf)
             path_sdf.mkdir(exist_ok=True, parents=True)
             for sdf_file in glob.glob(f'{os.getcwd()}/CSEARCH/*.sdf'):
@@ -120,7 +122,7 @@ class aqme:
                     aqme_indv_name = 'AQME_indiv'
                 else:
                     smi_suffix = column.split("_")[1]
-                    csv_temp['code_name'] = csv_temp['code_name'] + '_' + smi_suffix
+                    csv_temp['code_name'] = csv_temp['code_name'].astype(str) + '_' + smi_suffix
                     csv_temp.to_csv(f'AQME_indiv_{smi_suffix}.csv', index=False)
                     aqme_indv_name = f'AQME_indiv_{smi_suffix}'
 

{robert-2.0.2 → robert-2.1.0}/robert/argument_parser.py

@@ -19,8 +19,6 @@ var_dict = {
     "seed": 0,
     "destination": None,
     "csv_name" : '',
-    "csv_train": '',
-    "csv_valid": '',
     "csv_test": '',
     "y" : '',
     "discard" : [],
@@ -35,11 +33,12 @@ var_dict = {
     "test_set" : 0.2,
     "auto_test" : True,
     "auto_type": True,
+    "auto_fill": True,
     "model" : ['RF','GB','NN','MVL'],
     "eval_model" : 'MVL',
     "custom_params" : None,
     "type" : "reg",
-    "split" : "even",
+    "split" : "auto",
     "nprocs": 8,
     "error_type" : "rmse",
     "pfi_epochs" : 5,
@@ -53,7 +52,6 @@ var_dict = {
     "repeat_kfolds" : 10,
     "alpha" : 0.05,
     "params_dir" : '',
-    "csv_test" : '',
     "t_value" : 2,
     "shap_show" : 10,
     "pfi_show" : 10,

{robert-2.0.2 → robert-2.1.0}/robert/curate.py

@@ -50,7 +50,8 @@ Parameters
         Number of repetitions for the k-fold cross-validation of the RFECV feature selector.
     auto_type : bool, default=True
         If there are only two y values, the program automatically changes the type of problem to classification.
-
+    auto_fill : bool, default = True
+        Complete missing values in columns with descriptors of "float" type using a KNN imputer
 
 """
 #####################################################.
@@ -97,12 +98,23 @@ class curate:
 
             # apply the correlation filters and returns the database without correlated descriptors
             if self.args.corr_filter_x or self.args.corr_filter_y:
-                csv_df = correlation_filter(self,csv_df)
+                csv_df_result = correlation_filter(self,csv_df)
+                # Check if result is a tuple (model-specific CSVs) or single dataframe
+                if isinstance(csv_df_result, tuple):
+                    csv_df, csv_df_per_model = csv_df_result
+                else:
+                    csv_df = csv_df_result
+                    csv_df_per_model = None
+            else:
+                csv_df_per_model = None
             
-            # save the curated CSV
-            _ = self.save_curate(csv_df)
+            # save the curated CSVs (one per model if RFECV is applied)
+            if csv_df_per_model is not None:
+                _ = self.save_curate((csv_df, csv_df_per_model))
+            else:
+                _ = self.save_curate(csv_df)
 
-        # create Pearson heatmap
+        # create Pearson heatmap (use the general filtered dataframe)
         _ = pearson_map(self,csv_df,'curate')
 
         # finish the printing of the CURATE info file
@@ -140,21 +152,59 @@ class curate:
         '''
         Saves the curated database and options used in CURATE
         '''
-        
-        # saves curated database
-        csv_basename = os.path.basename(f'{self.args.csv_name}').split('.')[0]
-        csv_curate_name = f'{csv_basename}_CURATE.csv'
-        csv_curate_name = self.args.destination.joinpath(csv_curate_name)
-        _ = csv_df.to_csv(f'{csv_curate_name}', index = None, header=True)
-        path_reduced = '/'.join(f'{csv_curate_name}'.replace('\\','/').split('/')[-2:])
-        self.args.log.write(f'\no  The curated database was stored in {path_reduced}.')
 
-        # saves important options used in CURATE
+        csv_basename = os.path.basename(f'{self.args.csv_name}').split('.')[0]
+        
+        # Check if csv_df is a tuple (csv_df_filtered, csv_df_per_model) from correlation_filter
+        if isinstance(csv_df, tuple):
+            csv_df_filtered, csv_df_per_model = csv_df
+            
+            # Save model-specific curated databases (sorted for reproducibility)
+            for model in csv_df_per_model:
+                csv_curate_name = f'{csv_basename}_CURATE_{model}.csv'
+                csv_curate_name = self.args.destination.joinpath(csv_curate_name)
+                # Sort rows by y value for reproducibility
+                csv_df_to_save = csv_df_per_model[model].reset_index(drop=True).sort_values(by=self.args.y).reset_index(drop=True)
+                _ = csv_df_to_save.to_csv(f'{csv_curate_name}', index=None, header=True)
+
+                # y values to predict, considering that ROBERT will work with multiple values of y in future versions
+                if not isinstance(self.args.y,list):
+                    count_y = 1
+                else:
+                    count_y = len(self.args.y)
+                
+                txt_csv = f'\n   o Model {model}: {len(csv_df_per_model[model].columns)-len(self.args.ignore)-count_y} descriptors remaining:\n'
+                txt_csv += '      ' + ', '.join(f'{var}' for var in csv_df_per_model[model].columns if var not in self.args.ignore and var != self.args.y)
+                self.args.log.write(txt_csv)
+            
+            self.args.log.write(f'\no  Model-specific curated databases were stored in {self.args.destination}')
+            
+            # Save general curated database (for reference/Pearson map, sorted for reproducibility)
+            csv_curate_name_general = f'{csv_basename}_CURATE.csv'
+            csv_curate_name_general = self.args.destination.joinpath(csv_curate_name_general)
+            csv_df_to_save_general = csv_df_filtered.reset_index(drop=True).sort_values(by=self.args.y).reset_index(drop=True)
+            _ = csv_df_to_save_general.to_csv(f'{csv_curate_name_general}', index=None, header=True)
+
+        else:
+            # Original behavior: save single curated database
+            csv_curate_name_general = f'{csv_basename}_CURATE.csv'
+            csv_curate_name_general = self.args.destination.joinpath(csv_curate_name_general)
+            _ = csv_df.to_csv(f'{csv_curate_name_general}', index=None, header=True)
+            path_reduced = '/'.join(f'{csv_curate_name_general}'.replace('\\','/').split('/')[-2:])
+            self.args.log.write(f'\no  The curated database was stored in {path_reduced}.')
+
+        # Save important options used in CURATE
         options_name = f'CURATE_options.csv'
         options_name = self.args.destination.joinpath(options_name)
         options_df = pd.DataFrame()
         options_df['y'] = [self.args.y]
         options_df['ignore'] = [self.args.ignore]
         options_df['names'] = [self.args.names]
-        options_df['csv_name'] = [csv_curate_name]
-        _ = options_df.to_csv(f'{options_name}', index = None, header=True)
+        options_df['csv_name'] = [csv_curate_name_general]
+        
+        # Save class label mapping if it exists (for classification with string labels)
+        if hasattr(self.args, 'class_0_label'):
+            options_df['class_0_label'] = [self.args.class_0_label]
+            options_df['class_1_label'] = [self.args.class_1_label]
+        
+        _ = options_df.to_csv(f'{options_name}', index=None, header=True)

robert-2.1.0/robert/evaluate.py

@@ -0,0 +1,121 @@
+"""
+Parameters
+----------
+
+GENERAL
++++++++
+
+    csv_name : str, default=''
+        Name of the CSV file containing all the points used in the model (combining train + valid + test).
+        A path can be provided (i.e. 'C:/Users/FOLDER/FILE.csv'). 
+    y : str, default=''
+        Name of the column containing the response variable in the input CSV file (i.e. 'solubility'). 
+    names : str, default=''
+        Column of the names for each datapoint. Names are used to print outliers.
+    eval_model : str, default='MVL'
+        ML models that can be evaluated (for now, only models from sklearn are accepted, more options will be added): 
+        1. 'MVL' (Multivariate lineal models, LinearRegression() in sklearn)
+    type : str, default='reg'
+        Type of the pedictions. Options: 
+        1. 'reg' (Regressor)
+        2. 'clas' (Classifier)
+    seed : int, default=0
+        Random seed used in the ML predictor models and other protocols.
+    destination : str, default=None,
+        Directory to create the output file(s).
+
+Affect VERIFY and PREDICT
++++++++++++++++++++++++++
+
+    kfold : int, default=5
+        Number of random data splits for the cross-validation of the models. 
+    repeat_kfolds : int, default=10
+        Number of repetitions for the k-fold cross-validation of the models.
+
+"""
+#####################################################.
+#        This file stores the EVALUATE class        #
+#          used to evaluate existing models         #
+#####################################################.
+
+import os
+import shutil
+import time
+import pandas as pd
+from pathlib import Path
+from robert.utils import load_variables, finish_print, load_database, prepare_sets
+from robert.generate_utils import set_sets
+
+
+class evaluate:
+    """
+    Class containing all the functions from the EVALUATE module.
+
+    Parameters
+    ----------
+    kwargs : argument class
+        Specify any arguments from the EVALUATE module (for a complete list of variables, visit the ROBERT documentation)
+    """
+
+    def __init__(self, **kwargs):
+
+        start_time = time.time()
+
+        # load default and user-specified variables
+        self.args = load_variables(kwargs, "evaluate")
+
+        # clean folders from previous runs
+        _ = self.clean_eval()
+
+        # load database, discard user-defined descriptors and perform data checks
+        csv_df, csv_X, csv_y = load_database(self,self.args.csv_name,"generate",print_info=False)
+
+        # standardizes and separates an external test set
+        Xy_data = prepare_sets(self,csv_df,csv_X,csv_y,None,self.args.names,None,None,None,BO_opt=True)
+
+        # saves database and model params in the /GENERATE/Best_model/No_PFI folder
+        _ = self.save_generate(csv_df,Xy_data)
+
+        # finish the printing of the EVALUATE info file
+        _ = finish_print(self,start_time,'EVALUATE')
+
+    def clean_eval(self):
+        '''
+        Cleans folders from previous runs
+        '''
+
+        for folder in ['CURATE','GENERATE','VERIFY','PREDICT']:
+            eval_folder = f'{Path(os.getcwd()).joinpath(folder)}'
+            if os.path.exists(eval_folder):
+                shutil.rmtree(eval_folder)
+
+    def save_generate(self,csv_df,Xy_data):
+        '''
+        Saves database and model params in the /GENERATE/Best_model/No_PFI folder
+        '''
+
+        # copy database with Set column
+        generate_folder = Path('GENERATE/Best_model/No_PFI')
+        if os.path.exists(generate_folder):
+            shutil.rmtree(generate_folder)
+        Path(generate_folder).mkdir(exist_ok=True, parents=True)
+
+        # include the Set column to differentiate between train and test sets (and external test, if any)
+        csv_df = set_sets(csv_df,Xy_data)
+
+        _ = csv_df.to_csv(f'{generate_folder}/{self.args.eval_model}_db.csv', index = None, header=True)
+
+        # save all the parameters of the model
+        df_params = pd.DataFrame()
+        df_params['kfold'] = [self.args.kfold]
+        df_params['repeat_kfolds'] = [self.args.repeat_kfolds]
+        df_params['model'] = [self.args.eval_model]
+        df_params['type'] = [self.args.type]
+        df_params['seed'] = [self.args.seed]
+        df_params['y'] = [self.args.y]
+        df_params['names'] = [self.args.names]
+        df_params['error_type'] = [self.args.error_type]
+        df_params['params'] = '{}'
+        df_params['X_descriptors'] = [list(Xy_data['X_descriptors'])]
+
+        _ = df_params.to_csv(f'{generate_folder}/{self.args.eval_model}.csv', index = None, header=True)

{robert-2.0.2 → robert-2.1.0}/robert/generate.py

@@ -72,14 +72,14 @@ Parameters
         Number of random data splits for the cross-validation of the models. 
     repeat_kfolds : int, default=10
         Number of repetitions for the k-fold cross-validation of the models.
-    split : str, default='even'
+    split : str, default= 'even' (regression) or 'rnd' (classification)
         Specifies how the data is split into training and test sets. Options:
         1. 'even': splits the data evenly into training and test sets.
         2. 'RND': randomly splits the data.
         3. 'stratified': splits the data while preserving the distribution of the target variable.
-        4. 'KN': uses a k-means approach to select representative samples.
-        5. 'EXTRA_Q1': selects the 10% lowest values.
-        6. 'EXTRA_Q5': selects the 10% highest values.
+        4. 'KN': uses a k-means approach to select representative samples for training (good for intrapolation, bad for extrapolation).
+        5. 'extra_q1': selects the 20% lowest values.
+        6. 'extra_q5': selects the 20% highest values.
         
 """
 #####################################################.
@@ -87,6 +87,7 @@ Parameters
 #             used in model generation              #
 #####################################################.
 
+import os
 import time
 from robert.utils import (
     load_variables, 
@@ -145,8 +146,32 @@ class generate:
 
             self.args.log.write(f'   - {cycle}/{len(self.args.model)} - ML model: {ML_model} ')
 
+            # Try to load model-specific curated CSV first, fall back to general CSV
+            # Get the base name from the original csv_name (remove path if any)
+            if 'CURATE' in str(self.args.csv_name):
+                # If csv_name is already a CURATE file, extract the original base name
+                csv_basename = os.path.basename(f'{self.args.csv_name}').replace('_CURATE.csv', '').replace('.csv', '')
+            else:
+                csv_basename = os.path.basename(f'{self.args.csv_name}').split('.')[0]
+            
+            curate_folder = self.args.initial_dir.joinpath('CURATE')
+            csv_model_specific = curate_folder.joinpath(f'{csv_basename}_CURATE_{ML_model}.csv')
+            
+            # Store the original csv_name temporarily
+            original_csv_name = self.args.csv_name
+            
+            if os.path.exists(csv_model_specific):
+                csv_to_load = csv_model_specific
+                # Temporarily update csv_name to the model-specific CSV
+                self.args.csv_name = str(csv_model_specific)
+                self.args.log.write(f'      o Using model-specific curated database: {os.path.basename(csv_model_specific)}')
+            else:
+                csv_to_load = self.args.csv_name
+                self.args.log.write(f'      x Using general database (model-specific not found): {os.path.basename(self.args.csv_name)}')
+            
             # load database, discard user-defined descriptors and perform data checks
-            csv_df, csv_X, csv_y = load_database(self,self.args.csv_name,"generate",print_info=False)
+            csv_df, csv_X, csv_y = load_database(self,csv_to_load,"generate",print_info=False)
+            
 
             # standardizes and separates an external test set
             Xy_data = prepare_sets(self,csv_df,csv_X,csv_y,None,self.args.names,None,None,None,BO_opt=True)
@@ -157,12 +182,15 @@ class generate:
             # apply the PFI descriptor filter if it's activated
             if self.args.pfi_filter:
                 # load database, discard user-defined descriptors and perform data checks
-                csv_df, csv_X, csv_y = load_database(self,self.args.csv_name,"generate",print_info=False)
+                csv_df, csv_X, csv_y = load_database(self,csv_to_load,"generate",print_info=False)
 
                 # standardizes and separates an external test set
                 Xy_data = prepare_sets(self,csv_df,csv_X,csv_y,None,self.args.names,None,None,None,BO_opt=True)
 
                 _ = PFI_workflow(self, csv_df, ML_model, Xy_data)
+            
+            # Restore the original csv_name
+            self.args.csv_name = original_csv_name
 
             cycle += 1
 

{robert-2.0.2 → robert-2.1.0}/robert/generate_utils.py

@@ -7,6 +7,7 @@ import shutil
 import pandas as pd
 import numpy as np
 import glob
+import json
 from robert.utils import (
     load_params,
     PFI_filter,
@@ -50,7 +51,23 @@ def BO_workflow(self, Xy_data, csv_df, ML_model):
     db_name = self.args.destination.joinpath(f"Raw_data/No_PFI/{ML_model}_db")
     params_name = self.args.destination.joinpath(f"Raw_data/No_PFI/{ML_model.upper()}")
     _ = csv_df.to_csv(f'{db_name}.csv', index = None, header=True)
-    bo_data_df = pd.DataFrame([bo_data])
+    
+    # Convert params dict to string to avoid serialization issues
+    bo_data_to_save = bo_data.copy()
+    if 'params' in bo_data_to_save:
+        bo_data_to_save['params'] = json.dumps(bo_data_to_save['params'])
+    if 'X_descriptors' in bo_data_to_save:
+        bo_data_to_save['X_descriptors'] = json.dumps(bo_data_to_save['X_descriptors'])
+    
+    # Save class label mapping if it exists (for classification with string labels)
+    if hasattr(self.args, 'class_0_label'):
+        bo_data_to_save['class_0_label'] = self.args.class_0_label
+        bo_data_to_save['class_1_label'] = self.args.class_1_label
+
+    # Save split type
+    bo_data_to_save['split'] = self.args.split
+ 
+    bo_data_df = pd.DataFrame([bo_data_to_save])
     _ = bo_data_df.to_csv(f'{params_name}.csv', index = None, header=True)
 
     return bo_data
@@ -133,6 +150,12 @@ def save_pfi_csv(self,csv_df,name_csv_hyperopt,PFI_dict,Xy_data_PFI,ML_model):
 
     name_csv_hyperopt_PFI = name_csv_hyperopt.replace('No_PFI','PFI')
     path_csv_PFI = self.args.destination.joinpath(f'{name_csv_hyperopt_PFI}_PFI')
+    
+    # Save class label mapping if it exists (for classification with string labels)
+    if hasattr(self.args, 'class_0_label'):
+        PFI_dict['class_0_label'] = self.args.class_0_label
+        PFI_dict['class_1_label'] = self.args.class_1_label
+    
     csv_PFI_df = pd.DataFrame([PFI_dict])
     _ = csv_PFI_df.to_csv(f'{path_csv_PFI}.csv', index = None, header=True)