robert 1.1.2__tar.gz → 1.2.0__tar.gz

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

@@ -1,36 +1,36 @@
-Metadata-Version: 2.1
-Name: robert
-Version: 1.1.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/1.1.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
-Requires-Python: >=3.0
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: PyYAML==6.0.1
-Requires-Dist: matplotlib==3.9.1
-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: 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

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

@@ -15,10 +15,14 @@ var_dict = {
     "aqme": False,
     "report": False,
     "cheers": False,
+    "evaluate": False,
     "seed": [],
     "generate_acc": 'mid',
     "destination": None,
     "csv_name" : '',
+    "csv_train": '',
+    "csv_valid": '',
+    "csv_test": '',
     "y" : '',
     "discard" : [],
     "ignore" : [],
@@ -31,9 +35,11 @@ var_dict = {
     "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,
@@ -43,8 +49,7 @@ var_dict = {
     "pfi_threshold" : 0.04,
     "pfi_filter" : True,
     "pfi_max" : 0,
-    "thres_test" : 0.25,
-    "kfold" : 5,
+    "kfold" : 'auto',
     "alpha" : 0.05,
     "params_dir" : '',
     "csv_test" : '',

{robert-1.1.2 → robert-1.2.0}/robert/curate.py

@@ -13,6 +13,8 @@ Parameters
         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
@@ -36,6 +38,11 @@ Parameters
     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).
+    kfold : int, default='auto'
+        Number of random data splits for the cross-validation of the RFECV feature selector. If 'auto', the program uses 5 splits 
+    auto_type : bool, default=True
+        If there are only two y values, the program automatically changes the type of problem to classification.
+
 
 """
 #####################################################.
@@ -46,15 +53,11 @@ Parameters
 import time
 import os
 import pandas as pd
-import numpy as np
 from scipy import stats
-from matplotlib import pyplot as plt
-import seaborn as sb
-from robert.utils import load_variables, finish_print, load_database
-from sklearn.feature_selection import SelectKBest, f_regression
+from robert.utils import load_variables, finish_print, load_database, pearson_map, check_clas_problem
 from sklearn.feature_selection import RFECV
 from sklearn.model_selection import KFold
-from sklearn.ensemble import RandomForestRegressor
+from sklearn.ensemble import RandomForestRegressor,RandomForestClassifier
 
 
 class curate:
@@ -77,18 +80,23 @@ class curate:
         # load database, discard user-defined descriptors and perform data checks
         csv_df = load_database(self,self.args.csv_name,"curate")
 
-        # transform categorical descriptors
-        csv_df = self.categorical_transform(csv_df,'curate')
+        # 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)
+
+        if not self.args.evaluate:
+            # transform categorical descriptors
+            csv_df = self.categorical_transform(csv_df,'curate')
 
-        # apply duplicate filters (i.e., duplication of datapoints or descriptors)
-        csv_df = self.dup_filter(csv_df)
+            # 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:
-            csv_df = self.correlation_filter(csv_df)
+            # apply the correlation filters and returns the database without correlated descriptors
+            if self.args.corr_filter:
+                csv_df = self.correlation_filter(csv_df)
 
         # create Pearson heatmap
-        _ = self.pearson_map(csv_df)
+        _ = pearson_map(self,csv_df,'curate')
 
         # save the curated CSV
         _ = self.save_curate(csv_df)
@@ -226,7 +234,7 @@ class curate:
         # Check if descriptors are more than one third of datapoints
         n_descps = len(csv_df_filtered.columns)-len(self.args.ignore)-1 # all columns - ignored - y
         if len(csv_df[self.args.y]) > 50 and self.args.auto_test ==True:
-           datapoints= len(csv_df[self.args.y])*0.9
+           datapoints = len(csv_df[self.args.y])*0.9
         else:
             datapoints = len(csv_df[self.args.y])
         if n_descps > datapoints / 3:
@@ -234,10 +242,26 @@ class curate:
             # Avoid situations where the number of descriptors is equal to the number of datapoints/3
             if len(csv_df[self.args.y]) / 3 == num_descriptors:
                 num_descriptors -= 1
-            txt_corr += f'\n\no  Descriptors reduced to one third of datapoints using RFECV: {num_descriptors} descriptors remaining'
-            # Use RFECV with RandomForestRegressor to select the most important descriptors
-            estimator = RandomForestRegressor(random_state=0, n_estimators=30, max_depth=10,  n_jobs=None)
-            selector = RFECV(estimator, min_features_to_select=num_descriptors, cv=KFold(n_splits=5, shuffle=True, random_state=0), n_jobs=None)
+            # Use RFECV with a simple RandomForestRegressor to select the most important descriptors
+            if self.args.type.lower() == 'reg':
+                estimator = RandomForestRegressor(random_state=0, n_estimators=30, max_depth=10,  n_jobs=None)
+            elif self.args.type.lower() == 'clas':
+                estimator = RandomForestClassifier(random_state=0, n_estimators=30, max_depth=10,  n_jobs=None)
+            if self.args.kfold == 'auto':
+                # LOOCV for relatively small datasets (less than 50 datapoints)
+                if len(csv_df[self.args.y]) < 50:
+                    n_splits = len(csv_df[self.args.y])
+                    cv_type = 'LOOCV'
+                # k-fold CV with the same training/validation proportion used for fitting the model, using 5 splits
+                else:
+                    n_splits = 5
+                    cv_type = '5-fold CV'
+            else:
+                n_splits = self.args.kfold
+                cv_type = f'{n_splits}-fold CV'
+            txt_corr += f'\n\no  Descriptors reduced to one third of datapoints using RFECV with {cv_type}: {num_descriptors} descriptors remaining'
+
+            selector = RFECV(estimator, min_features_to_select=num_descriptors, cv=KFold(n_splits=n_splits, shuffle=True, random_state=0), n_jobs=None)
             X = csv_df_filtered.drop([self.args.y] + self.args.ignore, axis=1)
             y = csv_df_filtered[self.args.y]
             # Convert column names to strings to avoid any issues
@@ -285,63 +309,3 @@ class curate:
         options_df['names'] = [self.args.names]
         options_df['csv_name'] = [csv_curate_name]
         _ = options_df.to_csv(f'{options_name}', index = None, header=True)
-
-
-    def pearson_map(self,csv_df_pearson):
-        '''
-        Creates Pearson heatmap
-        '''
-
-        csv_df_pearson = csv_df_pearson.drop([self.args.y] + self.args.ignore, axis=1)
-        corr_matrix = csv_df_pearson.corr()
-        mask = np.zeros_like(corr_matrix, dtype=bool)
-        mask[np.triu_indices_from(mask)]= True
-        
-        # these size ranges avoid matplot errors
-        if len(csv_df_pearson.columns) > 30:
-            disable_plot = True
-        else:
-            disable_plot = False
-            _, ax = plt.subplots(figsize=(7.45,6))
-            size_title = 14
-            size_font = 14-2*((len(csv_df_pearson.columns)/5))
-
-        if disable_plot:
-            self.args.log.write(f'\nx  The Pearson heatmap was not generated because the number of features and the y value ({len(csv_df_pearson.columns)}) is higher than 30.')
-        else:
-            sb.set(font_scale=1.2, style='ticks')
-
-            # determines size of the letters inside the boxes (approx.)
-            annot = True
-            if len(csv_df_pearson.columns) > 30:
-                annot = False
-
-            _ = sb.heatmap(corr_matrix,
-                            mask = mask,
-                            square = True,
-                            linewidths = .5,
-                            cmap = 'coolwarm',
-                            cbar = False,
-                            cbar_kws = {'shrink': .4,
-                                        'ticks' : [-1, -.5, 0, 0.5, 1]},
-                            vmin = -1,
-                            vmax = 1,
-                            annot = annot,
-                            annot_kws = {'size': size_font})
-
-            plt.tick_params(labelsize=size_font)
-            #add the column names as labels
-            ax.set_yticklabels(corr_matrix.columns, rotation = 0)
-            ax.set_xticklabels(corr_matrix.columns)
-
-            title_fig = 'Pearson\'s r heatmap'
-            plt.title(title_fig, y=1.04, fontsize = size_title, fontweight="bold")
-            sb.set_style({'xtick.bottom': True}, {'ytick.left': True})
-
-            heatmap_name = 'Pearson_heatmap.png'
-            heatmap_path = self.args.destination.joinpath(heatmap_name)
-            plt.savefig(f'{heatmap_path}', dpi=300, bbox_inches='tight')
-            plt.clf()
-            path_reduced = '/'.join(f'{heatmap_path}'.replace('\\','/').split('/')[-2:])
-            self.args.log.write(f'\no  The Pearson heatmap was stored in {path_reduced}.')
-        

robert-1.2.0/robert/evaluate.py

@@ -0,0 +1,179 @@
+"""
+Parameters
+----------
+
+GENERAL
++++++++
+
+    csv_train : str, default=''
+        Name of the CSV file containing the train set. A path can be provided (i.e. 'C:/Users/FOLDER/FILE.csv'). 
+    csv_valid : str, default=''
+        Name of the CSV file containing the validation set. A path can be provided (i.e. 'C:/Users/FOLDER/FILE.csv'). 
+    csv_test : str, default=''
+        Name of the CSV file containing the test set (if any). 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)
+    destination : str, default=None,
+        Directory to create the output file(s).
+    
+Affect VERIFY
++++++++++++++
+
+    error_type : str, default: rmse (regression), mcc (classification)
+        Target value used during the VERIFY evaluation. 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)
+
+Affect PREDICT
+++++++++++++++
+
+    t_value : float, default=2
+        t-value that will be the threshold to identify outliers (check tables for t-values elsewhere).
+        The higher the t-value the more restrictive the analysis will be (i.e. there will be more 
+        outliers with t-value=1 than with t-value = 4).
+    alpha : float, default=0.05
+        Significance level, or probability of making a wrong decision. This parameter is related to
+        the confidence intervals (i.e. 1-alpha is the confidence interval). By default, an alpha value
+        of 0.05 is used, which corresponds to a confidence interval of 95%.
+    shap_show : int, default=10,
+        Number of descriptors shown in the plot of the SHAP analysis.
+    pfi_show : int, default=10,
+        Number of descriptors shown in the plot of the PFI analysis.
+
+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 
+
+"""
+#####################################################.
+#        This file stores the EVALUATE class        #
+#          used to evaluate existing models         #
+#####################################################.
+
+import os
+import sys
+import shutil
+import time
+import pandas as pd
+from pathlib import Path
+from robert.utils import load_variables, finish_print, load_database
+
+
+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")
+
+        # load databases, merge them and save CSV for ROBERT workflow
+        csv_df_train,csv_df_valid = self.load_sets()
+
+        # saves database and model params in the /GENERATE/Best_model/No_PFI folder
+        _ = self.save_generate(csv_df_train,csv_df_valid)
+
+        # finish the printing of the EVALUATE info file
+        _ = finish_print(self,start_time,'EVALUATE')
+
+
+    def load_sets(self):
+        '''
+        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['Set'] = ['Training'] * len(csv_df_train[self.args.y])
+        csv_df_valid = load_database(self,self.args.csv_valid,"evaluate")
+        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['Set'] = ['Test'] * len(csv_df_test[self.args.y])
+
+        self.args.ignore.append('Set')
+
+        # ensure that the datasets have the same number of columns and save combined database
+        if len(csv_df_train.columns) != len(csv_df_valid.columns):
+            self.args.log.write(f"\nx  Training and validation CSV files do not have the same number of columns!")
+            self.args.log.finalize()
+            sys.exit()
+        elif self.args.csv_test != '' and len(csv_df_train.columns) != len(csv_df_test.columns):
+            self.args.log.write(f"\nx  Training and test CSV files do not have the same number of columns!")
+            self.args.log.finalize()
+            sys.exit()
+
+        csv_df = pd.concat([csv_df_train,csv_df_valid], axis=0).reset_index(drop=True)
+        if self.args.csv_test != '':
+            csv_df = pd.concat([csv_df,csv_df_test], axis=0).reset_index(drop=True)
+        
+        csv_basename = os.path.basename(f'{self.args.csv_train}').split('.')[0]
+        self.args.csv_name = f'{csv_basename}_EVAL_db.csv'
+        _ = csv_df.to_csv(f'{self.args.csv_name}', index = None, header=True)
+
+        return csv_df_train,csv_df_valid
+
+
+    def save_generate(self,csv_df_train,csv_df_valid):
+        '''
+        Saves database and model params in the /GENERATE/Best_model/No_PFI folder
+        '''
+        
+        # copy database
+        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)
+
+        train_points = len(csv_df_train[self.args.y])
+        valid_points = len(csv_df_valid[self.args.y])
+        train_proportion = round((train_points/(train_points+valid_points))*100)
+        adapted_name = f'{self.args.eval_model}_{train_proportion}'
+
+        shutil.copy(f"{self.args.csv_name}", f"{generate_folder}/{adapted_name}_db.csv")
+
+        # save all the parameters of the model
+        df_params = pd.DataFrame()
+        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['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['y'] = [self.args.y]
+        df_params['names'] = [self.args.names]
+        df_params['error_type'] = [self.args.error_type]
+        # self.arg.names and "Set" are already in self.args.ignore
+        descriptors = csv_df_train.drop(self.args.ignore+[self.args.y], axis=1).columns
+        df_params['X_descriptors'] = [list(descriptors)]
+
+        _ = df_params.to_csv(f'{generate_folder}/{adapted_name}.csv', index = None, header=True)

{robert-1.1.2 → robert-1.2.0}/robert/generate.py

@@ -21,7 +21,9 @@ Parameters
         Proportions of the training set to use in the ML scan. The numbers are relative to the training 
         set proportion (i.e. 40 = 40% training data).
     auto_kn : bool, default=True
-        Changes random splitting to KN splitting in databases with less than 100 datapoints.
+        Changes random splitting to KN splitting in databases with less than 250 datapoints.
+    auto_type : bool, default=True
+        If there are only two y values, the program automatically changes the type of problem to classification.
     filter_train : bool, default=True
         Disables the 90% training size in databases with less than 50 datapoints, and the 80% in less than 30.
     split : str, default='RND'
@@ -81,8 +83,8 @@ Parameters
         filter are used.
     test_set : float, default=0.1
         Amount of datapoints to separate as external test set. These points will not be used during the
-        hyperoptimization, and PREDICT will be used the points as test set during ROBERT workflows. The separation
-        of test points occurs at random before any data splits are carried out inside the GENErATE screening.
+        hyperoptimization, and PREDICT will use the points as test set during ROBERT workflows. Select
+        --test_set 0 to use only training and validation.
     auto_test : bool, default=True
         Removes test sets in databases with less than 50 datapoints and raises % of test points to 10% if 
         test_set is lower than that.
@@ -100,6 +102,7 @@ from robert.utils import (
     load_variables, 
     finish_print,
     load_database,
+    check_clas_problem
 )
 from robert.generate_utils import (
     prepare_sets,
@@ -131,6 +134,10 @@ class generate:
         # load database, discard user-defined descriptors and perform data checks
         csv_df, csv_X, csv_y = 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)
+
         # separates an external test set (if applicable)
         csv_df, csv_X, csv_y, csv_df_test = self.separate_test(csv_df, csv_X, csv_y)
   
@@ -219,28 +226,49 @@ class generate:
             if self.args.test_set != 0:
                 if len(csv_df[self.args.y]) < 50:
                     self.args.test_set = 0
-                    self.args.log.write(f'\nx    WARNING! The database contains {len(csv_df[self.args.y])} datapoints, the data will be split in training and validation with no points separated as external test set (too few points to reach a reliable splitting). You can bypass this option and include test points with "--auto_test False".')
-                    self.args.test_set
+                    self.args.log.write(f'\nx  WARNING! The database contains {len(csv_df[self.args.y])} datapoints, the data will be split into training and validation sets with no points separated as external test set (too few points to reach a reliable splitting). You can bypass this option and include test points with "--auto_test False".')
                 elif self.args.test_set < 0.1:
                     self.args.test_set = 0.1
-                    self.args.log.write(f'\nx    WARNING! The test_set option was set to {self.args.test_set}, this value will be raised to 0.1 to include a meaningful amount of points in the test set. You can bypass this option and include less test points with "--auto_test False".')
-
-                if self.args.test_set > 0:
-                    n_of_points = int(len(csv_X)*(self.args.test_set))
-                    
-                    # this number must be 0 always, as it changes everything related to random seeds across the generate module
-                    random.seed(0)
-                    test_points = random.sample(range(len(csv_X)), n_of_points)
-
-                    # separates the test set and reset_indexes
-                    csv_df_test = csv_df.iloc[test_points].reset_index(drop=True)
-                    csv_df = csv_df.drop(test_points, axis=0).reset_index(drop=True)
-                    csv_X = csv_X.drop(test_points, axis=0).reset_index(drop=True)
-                    csv_y = csv_y.drop(test_points, axis=0).reset_index(drop=True)
-        
-        else:
-            self.args.test_set = 0
-
+                    self.args.log.write(f'\nx  WARNING! The test_set option was set to {self.args.test_set}, this value will be raised to 0.1 to include a meaningful amount of points in the test set. You can bypass this option and include less test points with "--auto_test False".')
+
+        if self.args.test_set > 0:
+            self.args.log.write(f'\no  Before hyproptimization, {int(self.args.test_set*100)}% of the data was separated as test set, using an even distribution of data points across the range of y values. The remaining data points will be split into training and validation.')
+
+            n_of_points = int(len(csv_X)*(self.args.test_set))
+
+            # this number must be 0 always, as it changes everything related to random seeds across the generate module
+            random.seed(0)
+            
+            # sometimes, using random selection leads to a test set with values that are not evenly
+            # distributed across the range of y values. In this part, we aim to create a test set 
+            # whose values cover a significant range of the y values
+            test_points = []
+
+            # first, we divide the y values into different sections (even separations, using the number of
+            # datapoints that go into the test set)
+            sorted_csv_y = csv_y.sort_values()
+            indexes = list(sorted_csv_y.index)
+            range_section = round(len(indexes)/n_of_points) # do not use int(), the last section might get too many numbers
+            sections = {}
+            for section in range(n_of_points):
+                if section == n_of_points-1:
+                    sections[section] = indexes[section*range_section:]
+                else:
+                    sections[section] = indexes[section*range_section:(section+1)*range_section]
+
+            while len(test_points) < n_of_points:
+                for section in sections:
+                    if len(test_points) < n_of_points:
+                        new_point = random.sample(sections[section],1)[0]
+                        sections[section].remove(new_point)
+                        test_points.append(new_point)
+
+            # separates the test set and reset_indexes
+            csv_df_test = csv_df.iloc[test_points].reset_index(drop=True)
+            csv_df = csv_df.drop(test_points, axis=0).reset_index(drop=True)
+            csv_X = csv_X.drop(test_points, axis=0).reset_index(drop=True)
+            csv_y = csv_y.drop(test_points, axis=0).reset_index(drop=True)
+    
         return csv_df, csv_X, csv_y, csv_df_test
 
 
@@ -249,11 +277,13 @@ class generate:
         Changes the split to KN when small or imbalanced databases are used
         '''
         
-        # when using databases with a small number of points
-        if len(csv_df[self.args.y]) < 100 and self.args.split.lower() == 'rnd':
+        # when using databases with a small number of points (less than 250 datapoints)
+        if len(csv_df[self.args.y]) < 250 and self.args.split.lower() == 'rnd':
             self.args.split = 'KN'
-            self.args.log.write(f'\nx    WARNING! The database contains {len(csv_df[self.args.y])} datapoints, KN data splitting will replace the default random splitting (too few points to reach a reliable splitting). You can use random splitting with "--auto_kn False".')
-        
+            self.args.log.write(f'\no  The database contains {len(csv_df[self.args.y])} datapoints, k-means data splitting will replace the default random splitting to select training and validation sets (too few points to reach a reliable splitting). You can use random splitting with "--auto_kn False".')
+        elif self.args.split.lower() == 'rnd':
+            self.args.log.write(f'\no  The database contains {len(csv_df[self.args.y])} datapoints, the default random splitting will be used to select training and validation sets.')
+
         # when using unbalanced databases (using an arbitrary imbalance ratio of 10 with the two halves of the data)
         mid_value = max(csv_df[self.args.y])-((max(csv_df[self.args.y])-min(csv_df[self.args.y]))/2)
         high_vals = len([i for i in csv_df[self.args.y] if i >= mid_value])