robert 1.2.0__tar.gz → 2.0.0__tar.gz

{robert-1.2.0 → robert-2.0.0}/PKG-INFO

@@ -1,36 +1,35 @@
-Metadata-Version: 2.1
-Name: robert
-Version: 1.2.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/1.2.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.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: PyYAML==6.0.1
-Requires-Dist: matplotlib==3.9.2
-Requires-Dist: pandas==2.2.2
-Requires-Dist: numpy==1.26.4
-Requires-Dist: progress==1.6
-Requires-Dist: seaborn==0.13.2
-Requires-Dist: scipy==1.14.0
-Requires-Dist: scikit-learn==1.5.1
-Requires-Dist: hyperopt==0.2.7
-Requires-Dist: numba==0.60.0
-Requires-Dist: shap==0.45.1
-Requires-Dist: mapie==0.8.6
-Requires-Dist: weasyprint==62.3
-
-Documentation in Read The Docs: https://robert.readthedocs.io
+Metadata-Version: 2.1
+Name: robert
+Version: 2.0.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.0.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.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+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
+
+Documentation in Read The Docs: https://robert.readthedocs.io

{robert-1.2.0 → robert-2.0.0}/README.md

@@ -7,15 +7,22 @@
 [![Codecov](https://img.shields.io/codecov/c/github/jvalegre/robert?label=Codecov&logo=codecov)](https://codecov.io/gh/jvalegre/robert)
 [![Downloads](https://img.shields.io/pepy/dt/robert?label=Downloads&logo=pypi)](https://www.pepy.tech/projects/robert)
 [![Read the Docs](https://img.shields.io/readthedocs/robert?label=Read%20the%20Docs&logo=readthedocs)](https://robert.readthedocs.io/)
-
-ROBERT is an ensemble of automated machine learning protocols that can be run sequentially 
-through a single command line or a graphical user interface. The program works for **regression and classification problems**.
-Comprehensive workflows have been designed to meet state-of-the-art standards for cheminformatics studies, including:
+[![PyPI](https://img.shields.io/pypi/v/robert)](https://pypi.org/project/robert/)
 
 ## Documentation  
 Full documentation with installation instructions, technical details and examples can be found in [Read the Docs](https://robert.readthedocs.io).  
 
-Don't miss out the latest hands-on tutorials from our [YouTube channel](https://www.youtube.com/channel/UCHRqI8N61bYxWV9BjbUI4Xw)!  
+Don't miss out the latest hands-on tutorials from our [YouTube channel](https://www.youtube.com/channel/UCHRqI8N61bYxWV9BjbUI4Xw)!
+
+## Recommended installation
+1. (Only once) Create new conda environment: `conda create -n robert python=3.10`  
+2. Activate conda environment: `conda activate robert`  
+3. Install ROBERT using pip: `pip install robert` 
+4. Install libraries for the PDF report `conda install -y -c conda-forge glib gtk3 pango mscorefonts`
+5. (Only for compatible devices) Install Intelex accelerator: `pip install scikit-learn-intelex==2025.0.1`  
+* 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`  
 
 ## Developers and help desk  
 List of main developers and contact emails:  
@@ -32,6 +39,8 @@ J.V.A.R. - The acronym ROBERT is dedicated to **ROBERT Paton**, who was a mentor
 
 D.D.G. - The style of the ROBERT_report.pdf file was created with the help of **Oliver Lee** (2023, Zysman-Colman group at University of St Andrews).
 
+J.V.A.R. and D.D.G. - The improvements from v1.0 to v1.2 are largely the result of insightful discussions with **Matthew Sigman** and his students, **Jamie Cadge** and **Simone Gallarati** (2024, University of Utah).
+
 We really THANK all the testers for their feedback and for participating in the reproducibility tests, including:
 
 * **David Valiente** (2022-2023, Universidad Miguel Hernández)
@@ -44,11 +53,11 @@ We really THANK all the testers for their feedback and for participating in the
 
 ## How to cite ROBERT
 If you use any of the ROBERT modules, please include this citation:  
-* Dalmau, D.; Alegre Requena, J. V. ChemRxiv, 2023, DOI: 10.26434/chemrxiv-2023-k994h.  
+* Dalmau, D.; Alegre Requena, J. V. ROBERT: Bridging the Gap between Machine Learning and Chemistry. *Wiley Interdiscip. Rev. Comput. Mol. Sci.* **2024**, *14*, e1733.
 
 If you use the AQME module, please include this citation:  
-* Alegre-Requena et al., AQME: Automated Quantum Mechanical Environments for Researchers and Educators. Wiley Interdiscip. Rev. Comput. Mol. Sci. 2023, 13, e1663.
+* Alegre-Requena et al., AQME: Automated Quantum Mechanical Environments for Researchers and Educators. *Wiley Interdiscip. Rev. Comput. Mol. Sci.* **2023**, *13*, e1663.
 
 Additionally, please include the corresponding reference for Scikit-learn and SHAP:  
-* Pedregosa et al., Scikit-learn: Machine Learning in Python, J. Mach. Learn. Res. 2011, 12, 2825-2830.  
-* Lundberg et al., From local explanations to global understanding with explainable AI for trees, Nat. Mach. Intell. 2020, 2, 56–67.  
+* Pedregosa et al., Scikit-learn: Machine Learning in Python. *J. Mach. Learn. Res.* **2011**, *12*, 2825-2830.  
+* Lundberg et al., From local explanations to global understanding with explainable AI for trees. *Nat. Mach. Intell.* **2020**, *2*, 56–67.  

{robert-1.2.0 → robert-2.0.0}/robert/__main__.py

@@ -13,7 +13,7 @@ from robert import robert
 # This allows the usage python pip-*.whl/pip install pip-*.whl
 
 if __package__ != 'robert':
-    print('ROBERT is not installed! Use: pip install robert or conda install -c conda-forge robert.')
+    print('ROBERT is not installed! Use: pip install robert or conda install -y -c conda-forge robert.')
 
 if __name__ == '__main__':
     robert.main()

{robert-1.2.0 → robert-2.0.0}/robert/aqme.py

@@ -12,9 +12,8 @@ Parameters
         Name of the column containing the response variable in the input CSV file (i.e. 'solubility'). 
     qdescp_keywords : str, default=''    
         Add extra keywords to the AQME-QDESCP run (i.e. qdescp_keywords="--qdescp_atoms ['Ir']")
-    csearch_keywords : str, default='--sample 50'
-        Add extra keywords to the AQME-CSEARCH run (i.e. csearch_keywords='--sample 10'). CREST can be
-        used instead of RDKit by adding "--program crest".
+    descp_lvl : str, default='interpret'
+        Type of descriptor to be used in the AQME-ROBERT workflow. Options are 'interpret', 'denovo' or 'full'.
 
 """
 #####################################################.
@@ -95,8 +94,15 @@ class aqme:
                     os.remove(new_sdf)
                 shutil.move(sdf_file, new_sdf)
                       
-        #Load database
-        csv_df = load_database(self,csv_target,job_type)
+        # Load database
+        csv_df,_,_ = load_database(self,csv_target,job_type,print_info=False)
+
+         # avoid running calcs with special signs (i.e. *)
+        for name_csv_indiv in csv_df['code_name']:
+            if '*' in f'{name_csv_indiv}':
+                self.args.log.write(f"\nx  WARNING! The names provided in the CSV contain * (i.e. {name_csv_indiv}). Please, remove all the * characters.")
+                self.args.log.finalize()
+                sys.exit()
 
         # find if there is more than one SMILES column in the CSV file
         for column in csv_df.columns:
@@ -118,48 +124,36 @@ class aqme:
                     csv_temp.to_csv(f'AQME_indiv_{smi_suffix}.csv', index=False)
                     aqme_indv_name = f'AQME_indiv_{smi_suffix}'
 
-                # run the initial AQME-CSEARCH conformational search with RDKit (default) or CREST
-                if '--program crest' not in self.args.csearch_keywords.lower():
-                    cmd_csearch = ['python', '-m', 'aqme', '--csearch', '--program', 'rdkit', '--input', f'{aqme_indv_name}.csv', '--nprocs', f'{self.args.nprocs}']
-                else:
-                    self.args.log.write(f"\no  CREST detected in the csearch_keywords option, it will be used for conformer sampling")
-                    cmd_csearch = ['python', '-m', 'aqme', '--csearch', '--input', f'{aqme_indv_name}.csv', '--nprocs', f'{self.args.nprocs}']
-                _ = self.run_aqme(cmd_csearch, self.args.csearch_keywords)
-
-                sdf_files = 'CSEARCH/*.sdf'
-                if smi_suffix is not None:
-                    sdf_files = f'CSEARCH/*_{smi_suffix}_*.sdf'
-
-                # run QDESCP to generate descriptors
-                cmd_qdescp = ['python', '-m', 'aqme', '--qdescp', '--files', sdf_files, '--program', 'xtb', '--csv_name', f'{aqme_indv_name}.csv', '--nprocs', f'{self.args.nprocs}', '--robert']
+                # run AQME-QDESCP to generate descriptors
+                cmd_qdescp = ['python', '-m', 'aqme', '--qdescp', '--input', f'{aqme_indv_name}.csv', '--program', 'xtb', '--csv_name', f'{aqme_indv_name}.csv', '--nprocs', f'{self.args.nprocs}', '--robert']
                 _ = self.run_aqme(cmd_qdescp, self.args.qdescp_keywords)
 
                 if smi_suffix is not None:
                     # Change column names by adding suffix
                     try:
-                        df_temp = pd.read_csv(f'AQME-ROBERT_{aqme_indv_name}.csv', encoding='utf-8')
+                        df_temp = pd.read_csv(f'AQME-ROBERT_{self.args.descp_lvl}_{aqme_indv_name}.csv', encoding='utf-8')
                     except FileNotFoundError:
                         self.args.log.write("x  WARNING! ROBERT stopped due to a problem with the AQME job. Please, check the previous AQME warnings.")
                         sys.exit()
                     df_temp.columns = [f'{col}_{smi_suffix}' if col not in ['code_name','SMILES'] and col not in aqme_args else col for col in df_temp.columns]
-                    df_temp.to_csv(f'AQME-ROBERT_{aqme_indv_name}.csv', index=False)
+                    df_temp.to_csv(f'AQME-ROBERT_{self.args.descp_lvl}_{aqme_indv_name}.csv', index=False)
 
                     # Check if there are missing rows in the AQME-ROBERT_{aqme_indv_name}.csv
                     if len(df_temp) < len(csv_temp):
                         missing_rows = csv_temp.loc[~csv_temp['code_name'].isin(df_temp['code_name'])]
-                        missing_rows[['code_name', 'SMILES']].to_csv(f'AQME-ROBERT_{aqme_indv_name}.csv', mode='a', header=False, index=False)
+                        missing_rows[['code_name', 'SMILES']].to_csv(f'AQME-ROBERT_{self.args.descp_lvl}_{aqme_indv_name}.csv', mode='a', header=False, index=False)
 
                     # Get the order of code_name in aqme_indv_name
                     order = csv_temp['code_name'].tolist()
 
                     # Sort the rows in 'AQME-ROBERT_{aqme_indv_name}.csv' based on the order
-                    df_temp = pd.read_csv(f'AQME-ROBERT_{aqme_indv_name}.csv', encoding='utf-8')
+                    df_temp = pd.read_csv(f'AQME-ROBERT_{self.args.descp_lvl}_{aqme_indv_name}.csv', encoding='utf-8')
                     df_temp = df_temp.sort_values(by='code_name', key=lambda x: x.map({v: i for i, v in enumerate(order)}))
 
                     # Fill missing values with corresponding SMILES row
                     df_temp = df_temp.fillna(df_temp.groupby('SMILES').transform('first'))
 
-                    df_temp.to_csv(f'AQME-ROBERT_{aqme_indv_name}.csv', index=False)
+                    df_temp.to_csv(f'AQME-ROBERT_{self.args.descp_lvl}_{aqme_indv_name}.csv', index=False)
 
                 # return SDF files after csv_test
                 if aqme_test:
@@ -169,23 +163,23 @@ class aqme:
                         shutil.rmtree(path_sdf)
 
         # if AQME-ROBERT_AQME_indiv_n.csv >0 in folder:
-        if len(glob.glob('AQME-ROBERT_AQME_indiv*.csv')) > 0:
+        if len(glob.glob(f'AQME-ROBERT_{self.args.descp_lvl}_AQME_indiv*.csv')) > 0:
 
             df_concat = pd.DataFrame()
 
             # Read and concatenate CSV files 
-            for file in sorted(glob.glob('AQME-ROBERT_AQME_indiv*.csv'), key=os.path.getmtime,reverse=True):
+            for file in sorted(glob.glob(f'AQME-ROBERT_{self.args.descp_lvl}_AQME_indiv*.csv'), key=os.path.getmtime,reverse=True):
                 columns_to_drop = ['code_name', 'SMILES'] + aqme_args
                 df_temp = pd.read_csv(file, encoding='utf-8')
                 columns_to_drop = [col for col in columns_to_drop if col in df_temp.columns]
                 df_temp = df_temp.drop(columns=columns_to_drop)
                 df_concat = pd.concat([df_temp, df_concat], axis=1)
             df_concat = pd.concat([csv_df, df_concat], axis=1)
-            df_concat.to_csv(f'AQME-ROBERT_{csv_target}', index=False)
+            df_concat.to_csv(f'AQME-ROBERT_{self.args.descp_lvl}_{csv_target}', index=False)
 
 
         # if no qdesc_atom is set, only keep molecular properties and discard atomic properties
-        aqme_db = f'AQME-ROBERT_{csv_target}'
+        aqme_db = f'AQME-ROBERT_{self.args.descp_lvl}_{csv_target}'
 
         # ensure that the AQME database was successfully created
         if not os.path.exists(aqme_db):
@@ -226,7 +220,7 @@ class aqme:
         try:
             from aqme.qprep import qprep
         except ModuleNotFoundError:
-            self.args.log.write("x  AQME is not installed (required for the --aqme option)! You can install the program with 'conda install -c conda-forge aqme'")
+            self.args.log.write("x  AQME is not installed (required for the --aqme option)! The program is typically installed within 2-5 minutes (https://aqme.readthedocs.io, see the Installation section)")
             sys.exit()
 
 

{robert-1.2.0 → robert-2.0.0}/robert/argument_parser.py

@@ -16,8 +16,7 @@ var_dict = {
     "report": False,
     "cheers": False,
     "evaluate": False,
-    "seed": [],
-    "generate_acc": 'mid',
+    "seed": 0,
     "destination": None,
     "csv_name" : '',
     "csv_train": '',
@@ -27,29 +26,31 @@ var_dict = {
     "discard" : [],
     "ignore" : [],
     "categorical" : "onehot",
-    "corr_filter" : True,
+    "corr_filter_x" : True,
+    "corr_filter_y" : False,
+    "std" : True,
     "desc_thres" : 25,
     "thres_y" : 0.001,
-    "thres_x" : 0.9,
-    "test_set" : 0.1,
+    "thres_x" : 0.7,
+    "test_set" : 0.2,
     "auto_test" : True,
-    "train" : [60,70,80,90],
-    "auto_kn" : True,
     "auto_type": True,
-    "filter_train" : True,
-    "split" : "RND",
     "model" : ['RF','GB','NN','MVL'],
     "eval_model" : 'MVL',
     "custom_params" : None,
     "type" : "reg",
-    "epochs" : 0,
+    "split" : "even",
     "nprocs": 8,
     "error_type" : "rmse",
     "pfi_epochs" : 5,
-    "pfi_threshold" : 0.04,
+    "pfi_threshold" : 0.2,
     "pfi_filter" : True,
     "pfi_max" : 0,
-    "kfold" : 'auto',
+    "init_points" : 10,
+    "n_iter" : 10,
+    "expect_improv" : 0.05,
+    "kfold" : 5,
+    "repeat_kfolds" : 10,
     "alpha" : 0.05,
     "params_dir" : '',
     "csv_test" : '',
@@ -58,7 +59,7 @@ var_dict = {
     "pfi_show" : 10,
     "names" : '',
     "qdescp_keywords" : '',
-    "csearch_keywords": '--sample 10',
+    "descp_lvl": "interpret",
     "report_modules" : ['AQME','CURATE','GENERATE','VERIFY','PREDICT'],
     "debug_report": False
 }
@@ -83,5 +84,5 @@ def set_options(kwargs):
         else:
             print("Warning! Option: [", key,":",kwargs[key],"] provided but no option exists, try the online documentation to see available options for each module.",)
             sys.exit()
-            
+ 
     return options

robert-2.0.0/robert/curate.py

@@ -0,0 +1,160 @@
+"""
+Parameters
+----------
+
+    csv_name : str, default=''
+        Name of the CSV file containing the database. 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'). 
+    discard : list, default=[]
+        List containing the columns of the input CSV file that will not be included as descriptors
+        in the curated CSV file (i.e. ['name','SMILES']).
+    ignore : list, default=[]
+        List containing the columns of the input CSV file that will be ignored during the curation process
+        (i.e. ['name','SMILES']). The descriptors will be included in the curated CSV file. The y value
+        is automatically ignored.
+    names : str, default=''
+        Column of the names for each datapoint. Names are used to print outliers.
+    destination : str, default=None,
+        Directory to create the output file(s).
+    varfile : str, default=None
+        Option to parse the variables using a yaml file (specify the filename, i.e. varfile=FILE.yaml).  
+    categorical : str, default='onehot'
+        Mode to convert data from columns with categorical variables. As an example, a variable containing 4
+        types of C atoms (i.e. primary, secondary, tertiary, quaternary) will be converted into categorical
+        variables. Options: 
+        1. 'onehot' (for one-hot encoding, ROBERT will create a descriptor for each type of
+        C atom using 0s and 1s to indicate whether the C type is present)
+        2. 'numbers' (to describe the C atoms with numbers: 1, 2, 3, 4).
+    corr_filter_x : bool, default=True
+        Activate the correlation filters of descriptors, based on the correlation
+        of the descriptors with other descriptors (x filter).
+    corr_filter_y : bool, default=False
+        Activate the correlation filters of descriptors, based on the correlation
+        of the descriptors with the y values (y filter, for noise). This filter is only 
+        suggested for MVL.
+    desc_thres : float, default=25
+        Threshold for the descriptor-to-datapoints ratio to loose the correlation filter. By default,
+        the correlation filter is loosen if there are 25 times more datapoints than descriptors.
+    thres_x : float, default=0.7
+        Thresolhold to discard descriptors based on high R**2 correlation with other descriptors (i.e. 
+        if thres_x=0.7, variables that show R**2 > 0.7 will be discarded).
+    thres_y : float, default=0.001
+        Thresolhold to discard descriptors with poor correlation with the y values based on R**2 (i.e.
+        if thres_y=0.001, variables that show R**2 < 0.001 will be discarded).
+    seed : int, default=0
+        Random seed used in RFECV feature selector and other protocols.
+    kfold : int, default=5
+        Number of random data splits for the cross-validation of the RFECV feature selector. 
+    repeat_kfolds : int, default=10
+        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.
+
+
+"""
+#####################################################.
+#         This file stores the CURATE class         #
+#               used in data curation               #
+#####################################################.
+
+import time
+import os
+import pandas as pd
+from robert.utils import (load_variables, finish_print, load_database, pearson_map,
+                          check_clas_problem, categorical_transform, correlation_filter)
+
+
+class curate:
+    """
+    Class containing all the functions from the CURATE module.
+
+    Parameters
+    ----------
+    kwargs : argument class
+        Specify any arguments from the CURATE 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, "curate")
+
+        # load database, discard user-defined descriptors and perform data checks
+        csv_df,_,_ = load_database(self,self.args.csv_name,"curate")
+
+        # adjust options of classification problems and detects whether the right type of problem was used
+        self = check_clas_problem(self,csv_df)
+
+        if not self.args.evaluate:
+            # transform categorical descriptors
+            csv_df = categorical_transform(self,csv_df,'curate')
+
+            # apply duplicate filters (i.e., duplication of datapoints or descriptors)
+            csv_df = self.dup_filter(csv_df)
+
+            # 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)
+            
+            # save the curated CSV
+            _ = self.save_curate(csv_df)
+
+        # create Pearson heatmap
+        _ = pearson_map(self,csv_df,'curate')
+
+        # finish the printing of the CURATE info file
+        _ = finish_print(self,start_time,'CURATE')
+
+
+    def dup_filter(self,csv_df_dup):
+        '''
+        Removes duplicated datapoints and descriptors
+        '''
+
+        txt_dup = f'\no  Duplication filters activated'
+        txt_dup += f'\n   Excluded datapoints:'
+
+        # remove duplicated entries
+        datapoint_drop = []
+        for i,datapoint in enumerate(csv_df_dup.duplicated()):
+            if datapoint:
+                datapoint_drop.append(i)
+        for datapoint in datapoint_drop:
+            txt_dup += f'\n   - Datapoint number {datapoint}'
+
+        if len(datapoint_drop) == 0:
+            txt_dup += f'\n   -  No datapoints were removed'
+
+        csv_df_dup = csv_df_dup.drop(datapoint_drop, axis=0)
+
+        csv_df_dup.reset_index(drop=True)
+        self.args.log.write(txt_dup)
+
+        return csv_df_dup
+
+
+    def save_curate(self,csv_df):
+        '''
+        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
+        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)

{robert-1.2.0 → robert-2.0.0}/robert/evaluate.py

@@ -22,6 +22,8 @@ GENERAL
         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).
     
@@ -58,9 +60,10 @@ Affect PREDICT
 Affect VERIFY and PREDICT
 +++++++++++++++++++++++++
 
-    kfold : int, default='auto',
-        Number of folds for the k-fold cross-validation. If 'auto', the program does 
-        a LOOCV for databases with less than 50 points, and 5-fold CV for larger databases 
+    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.
 
 """
 #####################################################.
@@ -109,12 +112,12 @@ class evaluate:
         Load databases, merge them and save CSV (tracking the test types using the Set column)
         '''
         
-        csv_df_train = load_database(self,self.args.csv_train,"evaluate")
+        csv_df_train,_,_ = load_database(self,self.args.csv_train,"evaluate",print_info=False)
         csv_df_train['Set'] = ['Training'] * len(csv_df_train[self.args.y])
-        csv_df_valid = load_database(self,self.args.csv_valid,"evaluate")
+        csv_df_valid,_,_ = load_database(self,self.args.csv_valid,"evaluate",print_info=False)
         csv_df_valid['Set'] = ['Validation'] * len(csv_df_valid[self.args.y])
         if self.args.csv_test != '':
-            csv_df_test = load_database(self,self.args.csv_test,"evaluate")
+            csv_df_test,_,_ = load_database(self,self.args.csv_test,"evaluate",print_info=False)
             csv_df_test['Set'] = ['Test'] * len(csv_df_test[self.args.y])
 
         self.args.ignore.append('Set')
@@ -163,12 +166,11 @@ class evaluate:
         train_points = len(csv_df_train[self.args.y])
         valid_points = len(csv_df_valid[self.args.y])
         df_params['train'] = [train_proportion]
-        df_params['split'] = ['user-defined']
+        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]
-        if self.args.seed == []:
-            self.args.seed = [0]
-        df_params['seed'] = [self.args.seed[0]]
+        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]