robert 1.2.1__tar.gz → 2.0.1__tar.gz

{robert-1.2.1 → robert-2.0.1}/PKG-INFO

@@ -1,36 +1,38 @@
-Metadata-Version: 2.1
-Name: robert
-Version: 1.2.1
-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.1.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.1
+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.1.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
+Requires-Dist: PySide6
+Requires-Dist: PyMuPDF
+Requires-Dist: ansi2html
+
+Documentation in Read The Docs: https://robert.readthedocs.io

{robert-1.2.1 → robert-2.0.1}/README.md

@@ -17,17 +17,20 @@ Don't miss out the latest hands-on tutorials from our [YouTube channel](https://
 ## 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`  
+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`  
+1. Update to the latest version: `pip install robert --upgrade`
 
 ## Developers and help desk  
 List of main developers and contact emails:  
   - [ ] [Juan V. Alegre-Requena](https://orcid.org/0000-0002-0769-7168). Contact: [jv.alegre@csic.es](mailto:jv.alegre@csic.es)  
-  - [ ] [David Dalmau Ginesta](https://orcid.org/0000-0002-2506-6546). Contact: [ddalmau@unizar.es](mailto:ddalmau@unizar.es)  
+  - [ ] [David Dalmau Ginesta](https://orcid.org/0000-0002-2506-6546). Contact: [ddalmau@unizar.es](mailto:ddalmau@unizar.es)
+  - [ ] [Miguel Martinez Fernandez](https://orcid.org/0009-0002-8538-7250). Contact [miguel.martinez@csic.es](mailto:miguel.martinez@csic.es)
+  - [ ] [Luis Giner Tendero](https://github.com/LlGinerT/). Contact [lginertendero@gmail.com](mailto:lginertendero@gmail.com)
 
 For suggestions and improvements of the code (greatly appreciated!), please reach out through the issues and pull requests options of Github.  
 
@@ -53,11 +56,12 @@ 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. ROBERT: Bridging the Gap between Machine Learning and Chemistry. *Wiley Interdiscip. Rev. Comput. Mol. Sci.* **2024**, *accepted*. DOI: 10.1002/WCMS.1733.  
+* 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.
 
-Additionally, please include the corresponding reference for Scikit-learn and SHAP:  
+Additionally, please include the corresponding reference for Scikit-learn, SHAP and BayesianOptimization:  
 * 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.  
+* Lundberg et al., From local explanations to global understanding with explainable AI for trees. *Nat. Mach. Intell.* **2020**, *2*, 56–67.
+* Fernando Nogueira, {Bayesian Optimization}: Open source constrained global optimization tool for {Python}, **2014**, https://github.com/bayesian-optimization/BayesianOptimization  

{robert-1.2.1 → robert-2.0.1}/robert/aqme.py

@@ -12,9 +12,6 @@ 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'.
 
@@ -98,7 +95,14 @@ class aqme:
                 shutil.move(sdf_file, new_sdf)
                       
         # Load database
-        csv_df = load_database(self,csv_target,job_type)
+        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:
@@ -120,20 +124,8 @@ 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:

{robert-1.2.1 → robert-2.0.1}/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.7,
-    "test_set" : 0.1,
+    "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" : '',
@@ -59,7 +60,6 @@ var_dict = {
     "names" : '',
     "qdescp_keywords" : '',
     "descp_lvl": "interpret",
-    "csearch_keywords": '--sample 10',
     "report_modules" : ['AQME','CURATE','GENERATE','VERIFY','PREDICT'],
     "debug_report": False
 }
@@ -84,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.1/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.1 → robert-2.0.1}/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]

robert-2.0.1/robert/generate.py

@@ -0,0 +1,184 @@
+"""
+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.
+    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).  
+    auto_type : bool, default=True
+        If there are only two y values, the program automatically changes the type of problem to classification.
+    model : list, default=['RF','GB','NN','MVL'] (regression) and default=['RF','GB','NN','AdaB'] (classification) 
+        ML models available: 
+        1. 'RF' (Random forest)
+        2. 'MVL' (Multivariate lineal models)
+        3. 'GB' (Gradient boosting)
+        4. 'NN' (MLP neural network)
+        5. 'GP' (Gaussian Process)
+        6. 'AdaB' (AdaBoost)
+    custom_params : str, default=None
+        Define new parameters for the ML models used in the hyperoptimization workflow. The path
+        to the folder containing all the yaml files should be specified (i.e. custom_params='YAML_FOLDER')
+    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.
+    error_type : str, default: rmse (regression), mcc (classification)
+        Target value used during the hyperopt optimization. Options:
+        Regression:
+        1. rmse (root-mean-square error)
+        2. mae (mean absolute error)
+        3. r2 (R-squared, not recommended since R2 might be good even with high errors in small datasets)
+        Classification:
+        1. mcc (Matthew's correlation coefficient)
+        2. f1 (F1 score)
+        3. acc (accuracy, fraction of correct predictions)
+    init_points : int, default=10
+        Number of initial points for Bayesian optimization (exploration)
+    n_iter : int, default=10
+        Number of iterations for Bayesian optimization (exploitation)
+    expect_improv : int, default=0.05
+        Expected improvement for Bayesian optimization
+    pfi_filter : bool, default=True
+        Activate the PFI filter of descriptors.
+    pfi_epochs : int, default=5
+        Sets the number of times a feature is randomly shuffled during the PFI analysis
+        (standard from sklearn webpage: 5).
+    pfi_threshold : float, default=0.2
+        The PFI filter is X% of the model's score (% adjusted, 0.2 = 20% of the total score during PFI).
+    pfi_max : int, default=0
+        Number of features to keep after the PFI filter. If pfi_max is 0, all the features that pass the PFI
+        filter are used.
+    auto_test : bool, default=True
+        Raises % of test points to 20% if test_set is lower than that.
+    test_set : float, default=0.2
+        Amount of datapoints to separate as external test set (0.2 = 20%). These points will not be used during the
+        hyperoptimization, and PREDICT will use the points as test set during ROBERT workflows. Select
+        --test_set 0 to use only training and validation.
+    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.
+    split : str, default='even'
+        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.
+        
+"""
+#####################################################.
+#        This file stores the GENERATE class        #
+#             used in model generation              #
+#####################################################.
+
+import time
+from robert.utils import (
+    load_variables, 
+    finish_print,
+    load_database,
+    check_clas_problem,
+    prepare_sets
+)
+from robert.generate_utils import (
+    BO_workflow,
+    PFI_workflow,
+    heatmap_workflow,
+    detect_best
+)
+
+
+class generate:
+    """
+    Class containing all the functions from the GENERATE module.
+
+    Parameters
+    ----------
+    kwargs : argument class
+        Specify any arguments from the GENERATE 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, "generate")
+
+        # load database, discard user-defined descriptors and perform data checks
+        csv_df, _, _ = load_database(self,self.args.csv_name,"generate")
+
+        # changes type to classification if there are only two different y values
+        if self.args.type.lower() == 'reg' and self.args.auto_type:
+            self = check_clas_problem(self,csv_df)
+        
+        # scan different ML models
+        txt_heatmap = f"\no  Starting heatmap scan with {len(self.args.model)} ML models ({self.args.model})."
+
+        # scan different training partition sizes
+        cycle = 1
+        txt_heatmap += f'\n   Heatmap generation:'
+        self.args.log.write(txt_heatmap)
+
+        # scan different ML models
+        self.args.log.write(f'''   o Starting BO-based hyperoptimization using the combined target:
+                    \n     1. 50% = {self.args.error_type.upper()} from a {self.args.repeat_kfolds}x repeated {self.args.kfold}-fold CV (interpoplation)
+                    \n     2. 50% = {self.args.error_type.upper()} from the bottom or top (worst performing) fold in a sorted {self.args.kfold}-fold CV (extrapolation)
+                    \n''')
+
+        for ML_model in self.args.model:
+
+            self.args.log.write(f'   - {cycle}/{len(self.args.model)} - ML model: {ML_model} ')
+
+            # 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)
+
+            # hyperopt process for ML models
+            _ = BO_workflow(self, Xy_data, csv_df, ML_model)
+
+            # 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)
+
+                # 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)
+
+            cycle += 1
+
+        # detects best combinations
+        dir_csv = self.args.destination.joinpath(f"Raw_data")
+        _ = detect_best(f'{dir_csv}/No_PFI')
+
+        # create heatmap plot(s)
+        _ = heatmap_workflow(self,"No_PFI")
+
+        # detect best and create heatmap for PFI models
+        if self.args.pfi_filter:
+            try: # if no models were found
+                _ = detect_best(f'{dir_csv}/PFI')
+                _ = heatmap_workflow(self,"PFI")
+            except UnboundLocalError:
+                pass
+
+        _ = finish_print(self,start_time,'GENERATE')