teradataml 17.20.0.6__py3-none-any.whl → 20.0.0.0__py3-none-any.whl

teradataml/hyperparameter_tuner/optimizer.py

@@ -17,7 +17,9 @@ import numpy as np
 import pandas as pd
 import random
 import time
+import threading
 from itertools import product
+from collections import defaultdict
 from teradataml import DataFrame, valib, TeradataMlException
 from teradataml.common.messages import Messages, MessageCodes
 from teradataml.hyperparameter_tuner.utils import _ProgressBar
@@ -171,7 +173,9 @@ class _BaseSearch:
         self.__progress_bar = None
         # '__model_err_records' holds error messages of failed model.
         self.__model_err_records = dict()
-
+        # '__parallel_stop_event' is used to stop threads in parallel execution.
+        self.__parallel_stop_event = None
+        
         # Get the function name.
         self.__func_name = func._tdml_valib_name if "_VALIB" in str(func.__class__) \
                                                  else func.__name__
@@ -227,6 +231,9 @@ class _BaseSearch:
                                    if self.__func_comparator[self.__evaluation_metric] \
                                    else self.__best_score_ <= self.__early_stop
         
+        # '_is_time_stoppable' function is to check whether HPT execution reached self.__timeout value.
+        self._is_time_stoppable = lambda : True if time.time() - self.__start_time >= self.__timeout else False
+        
         # Special case comparator for "MPE" metrics.
         # When "curr_score" argument is 'None' then lambda function checks 
         # for '_is_early_stoppable'. Otherwise, it checks for '_is_best_metrics'.
@@ -876,10 +883,6 @@ class _BaseSearch:
             self.__sampled_df_mapper[_data_id] = [{train_data_arg:_train_data}, 
                                                  {test_data_arg:_test_data}]
 
-        # Update model trainer function parameter grid.
-        self.__update_model_parameters()
-
-
     def __update_model_parameters(self):
         """
         DESCRIPTION:
@@ -924,16 +927,13 @@ class _BaseSearch:
                     'data_id': 'DF_1'}
                 ]
         """
-
         # Get data identifiers.
-        _model_ids = self.__sampled_df_mapper.keys()
-
+        _model_ids = self.__sampled_df_mapper.keys()    
         # Update '_parameter_grid' with data identifiers by performing 
         # cartesian product.
         self._parameter_grid = [{"param":param[0] , self.__DATA_ID:param[1]} for \
                                 param in product(self._parameter_grid, _model_ids)]
-
-
+        
     def __validate_model_trainer_input_data_argument(self, data, is_optional_arg=True):
         """
         DESCRIPTION:
@@ -1006,6 +1006,7 @@ class _BaseSearch:
             stratify_column=None, 
             sample_id_column=None, 
             sample_seed=None,
+            max_time=None,
             **kwargs):
         """
         DESCRIPTION:
@@ -1146,6 +1147,12 @@ class _BaseSearch:
                     * Mandatory when "sample_seed" argument is present.
                 Types: str
 
+            max_time:
+                Optional Argument.
+                Specifies the maximum time for the completion of Hyperparameter tuning execution.
+                Default Value: None
+                Types: int or float
+
             kwargs:
                 Optional Argument.
                 Specifies the keyword arguments. Accepts additional arguments 
@@ -1225,24 +1232,6 @@ class _BaseSearch:
         # Set the flag to notify fit method is called.
         self.__is_fit_called = True
 
-        if self.__is_trainable:
-            # "data" argument is a required argument for model trainer function 
-            # when data argument is not passed with hyperparameters. On other side,
-            # "data" argument will be optional argument when data argument 
-            # is passed with hyperparameters.
-            _is_optional_arg = self.__model_trainer_input_data is not None
-            # validate the model trainer function 'data' argument.
-            self.__validate_model_trainer_input_data_argument(data, _is_optional_arg)
-            
-            if not data is None:
-                # '__model_trainer_input_data' is assigned with "data" argument,
-                # when user passes data argument in fit() method.
-                # Note: if user attempts to pass data argument in both "params" 
-                # argument as hyperparameters or "data" argument in fit() 
-                # method, then latest "data" argument value is considered 
-                # for model training.
-                self.__model_trainer_input_data = data
-
         # Validate "early_stop".
         arg_info_matrix = []
         arg_info_matrix.append(["early_stop", early_stop, True, (int, float)])
@@ -1251,24 +1240,29 @@ class _BaseSearch:
         arg_info_matrix.append(["wait", wait, True, (bool)])
         arg_info_matrix.append(["evaluation_metric", evaluation_metric, True, 
                                 (str), True, list(self.__func_comparator)])
+        arg_info_matrix.append(["verbose", verbose, True, (int), True, [0,1,2]])
+        arg_info_matrix.append(["max_time", max_time, True, (int, float)])
  
         _Validators._validate_function_arguments(arg_info_matrix)
 
+        # set timeout value.
+        self.__timeout = max_time
+
+        self._setting_model_trainer_data(data)
+
         # Set the evaluation metrics.
         if evaluation_metric is not None:
             self.__evaluation_metric = evaluation_metric.upper()
         self.__early_stop = early_stop
-
         if self.__is_trainable and self.__is_evaluatable and self.__is_sqle_function:
+                                                           
             # When "evaluation_metric" is 'MPE' then use the spl comparators.
             if self.__evaluation_metric == "MPE":
                 self._is_best_metrics = self._is_early_stoppable = self._spl_abs_comparator 
     
             if not isinstance(self.__model_trainer_input_data, dict):
-                # Label the data with unique IDs.
-                _labeled_data = self._add_data_label()
                 # Sample all the labeled data for model training and testing.
-                self.__perform_train_test_sampling(_labeled_data, frac, stratify_column, 
+                self.__perform_train_test_sampling(self._labeled_data, frac, stratify_column, 
                                                    sample_id_column, sample_seed)
 
             elif isinstance(self.__model_trainer_input_data, dict):
@@ -1276,6 +1270,8 @@ class _BaseSearch:
                 self.__perform_train_test_sampling(self.__model_trainer_input_data, frac, 
                                                    stratify_column, sample_id_column, 
                                                    sample_seed)
+            # Update model trainer function parameter grid.
+            self.__update_model_parameters()
 
             self.__eval_params = kwargs if self.__is_evaluatable else None
 
@@ -1287,11 +1283,13 @@ class _BaseSearch:
             self.__sampled_df_mapper = self._add_data_label("data")
             # Update model trainer function parameter grid.
             self.__update_model_parameters()
-
+        
         # Initialize logging.
         if verbose > 0:
             self.__progress_bar = _ProgressBar(jobs=len(self._parameter_grid), verbose=verbose)
         if not run_parallel:
+            # Setting start time of Sequential execution.
+            self.__start_time = time.time() if self.__timeout is not None else None
             # TODO: Factorize the code once parallel execution part is completed in ELE-6154 JIRA.
             # Execute all parameters from populated parameter grid for both trainable 
             # and non trainable function.
@@ -1302,8 +1300,8 @@ class _BaseSearch:
                 # trainer function.
                 if self.__early_stop is not None and self.__is_evaluatable:
                     if self.__is_finite and self._is_early_stoppable():
-                        # Terminate HPT execution when the trained model attains the 
-                        # specified "__early_stop" value.
+                        # Terminate HPT execution when the trained model attains the
+                        # given "early_stop" value.
                         break
                     elif not self.__is_finite:
                         # Raise error because non-finite values cannot be compared 
@@ -1316,6 +1314,10 @@ class _BaseSearch:
                             " when '{metric}' metric results inconsistent value.".format(
                             metric=self.__evaluation_metric))
                         raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+                if self.__timeout is not None and self._is_time_stoppable():
+                    # Terminate HPT execution when the execution time exceeds the
+                    # given time limit.
+                    break
                     
         else:
             # TODO: Added support for early_stop feature along with concurrency in ELE-6154 JIRA.
@@ -1328,9 +1330,13 @@ class _BaseSearch:
                 _temp_params["model_param"] = param
                 _temp_params.update(kwargs)
                 async_exec_params.append(_temp_params)
-
+            
+            # Initialize the stopping event
+            self.__parallel_stop_event = threading.Event()
             # let's initialize "_AsyncDBExecutor".
             self._async_executor = _AsyncDBExecutor(wait=wait)
+            # Setting start time of Parallel execution.
+            self.__start_time = time.time() if self.__timeout is not None else None
             # Trigger parallel thread execution.
             self._async_executor.submit(self._execute_fit, *async_exec_params)
 
@@ -1377,15 +1383,24 @@ class _BaseSearch:
         EXAMPLES:
             >>> self.__model_trainer_routine(param=param, iter=iter, **kwargs)
         """
+        
         # Define model name used for model metadata.
         model_name = self._generate_model_name(iter)
         # Get the unique data identifier present in "model_param".
         _data_id = model_param[self.__DATA_ID]
-        # Retrieve the train and test data using data identifier.
-        _train_data, _test_data =  self.__sampled_df_mapper[_data_id]
         # 'param' variable holds model training parameters and train dataframe. 
         # Get the model training parameters.
         param = model_param["param"]
+        
+        # Check the stop_event set or not
+        if self.__parallel_stop_event is not None and self.__parallel_stop_event.is_set():
+            # Update the model metadata for Skip execution.
+            self.__update_model_metadata(model_name, param, "SKIP", 0, _data_id)
+            return
+        
+        # Retrieve the train and test data using data identifier.
+        _train_data, _test_data =  self.__sampled_df_mapper[_data_id]
+        
         # Update model training argument with train DataFrame.
         param.update(_train_data)
         # Update the test DataFrame for model evaluation.
@@ -1418,6 +1433,7 @@ class _BaseSearch:
                 # Default evaluation metric is set to "MAE" for Regression models.
                 if self.__evaluation_metric is None:
                     self.__evaluation_metric = "MAE"
+                    
             else:
                 # ClassificationEvaluator results are stored under "output_data" 
                 # attribute. "output_data" dataframe 'column 1' contains metrics
@@ -1431,11 +1447,21 @@ class _BaseSearch:
                 # classification models.
                 if self.__evaluation_metric is None:
                     self.__evaluation_metric = "ACCURACY"
+                    
             # Update the model metadata for successful model training.
-
             self.__update_model_metadata(model_name, param, "PASS", 
                                          training_time, _data_id,
                                          columns, eval_values)
+            
+            # Check whether self.__parallel_stop_event is None or not
+            if self.__parallel_stop_event is not None:
+                # SET the self.__parallel_stop_event 
+                # When trained model evaluation metric value exceeds self.__early_stop
+                # or When execution time exceeds self.__timeout
+                if (self.__early_stop is not None and self._is_early_stoppable())\
+                    or (self.__timeout is not None and self._is_time_stoppable()):
+                    self.__parallel_stop_event.set()
+            
         except Exception as _err_msg:
             # Record error message with corresponding "model_name".
             self.__model_err_records[model_name] = str(_err_msg)
@@ -1513,7 +1539,11 @@ class _BaseSearch:
         else:
             # Initialize param for non-model trainer functions. 
             param = model_param
-
+        # Check the stop_event set or not
+        if self.__parallel_stop_event is not None and self.__parallel_stop_event.is_set():
+            # Update the model metadata for Skip execution.
+            self.__update_model_metadata(model_name, param, "SKIP", 0, _data_id)
+            return
         try:
             # Record starting time of model training.
             start_time = time.perf_counter()
@@ -1541,6 +1571,13 @@ class _BaseSearch:
             # Update the model metadata for failed execution.
             self.__update_model_metadata(model_name, param, "FAIL", training_time, _data_id)
             pass
+
+        if self.__parallel_stop_event is not None:
+            # SET the self.__parallel_stop_event 
+            # When execution time exceeds self.__timeout
+            if self.__timeout is not None and self._is_time_stoppable():
+                self.__parallel_stop_event.set()
+
     
 
     def __update_model_metadata(self, model_name, 
@@ -1573,6 +1610,7 @@ class _BaseSearch:
                 Permitted Values: 
                     * PASS: Function result present in the vantage.
                     * FAIL: Function execution failed for the chosen parameters.
+                    * SKIP: Function execution skipped for the chosen parameters.
                 Types: str
             
             data_id:
@@ -1622,7 +1660,6 @@ class _BaseSearch:
         model_metadata = {"MODEL_ID" : model_name,
                           "PARAMETERS" : param,
                           "STATUS" : status}
-        
         if self.__is_trainable:
             # Update "data_id" for model trainer functions. 
             model_metadata[self.__DATA_ID.upper()] = data_id
@@ -1664,7 +1701,7 @@ class _BaseSearch:
                 # training best model.
                 self.__best_data_id = data_id
 
-        if not self.__progress_bar is None:
+        if not self.__progress_bar is None and status != 'SKIP':
             # Update progress bar when logging is required.
             self.__progress_bar.update(msg=_msg)
         # Update "__model_eval_records" with the formatted metadata.
@@ -2057,6 +2094,160 @@ class _BaseSearch:
 
         # Return list of dictionary containing all possible combinations.
         return [dict(param) for param in product(*param_pairs)]
+    
+    def _data_mapping(self):
+        """
+            DESCRIPTION:
+                Internal function to create a Cartesian product of data mapped with input columns 
+                and parameter grid.
+
+            PARAMETERS:
+                None
+            
+            RETURNS:
+                None
+        """
+        # Get the input columns from the params.
+        input_columns = self.__params.pop("input_columns")
+        # Create a list of dictionaries with data_id and input_columns
+        data_mapping_list = []
+        # Iterate over the labeled data and create a list of dictionaries
+        for data_ids, data in self._labeled_data.items():
+            # Check if all input columns are present in the data
+            for input_cols in input_columns:
+                if all(col in data.columns for col in input_cols):
+                    data_mapping_list.append({'data_id': data_ids,
+                                            'input_columns': input_cols})
+
+        self._parameter_grid = self.__populate_parameter_grid()
+
+        cartesian_product = product(self._parameter_grid, data_mapping_list)
+
+        result_list = []
+
+        # Iterate over the Cartesian product and construct the desired dictionaries
+        for params, data_mapping in cartesian_product:
+            result_dict = {
+                'param': {**params, 'input_columns': data_mapping['input_columns']},
+                self.__DATA_ID: data_mapping['data_id']
+            }
+            result_list.append(result_dict)
+
+        self._parameter_grid = result_list
+
+    
+    def _setting_model_trainer_data(self,
+                                    data=None):
+        """
+        DESCRIPTION:
+            Internal function to set the model trainer input data for model 
+            training. 
+
+        PARAMETERS:
+            data:
+                Optional Argument.
+                Specifies the input data used for model training. 
+                Note:
+                    * "data" argument is a required argument for model trainer 
+                      function when data argument is not passed with hyperparameters.
+                    * When data argument is passed with hyperparameters then 
+                      "data" argument is optional.
+                Types: teradataml DataFrame
+        
+        RETURNS:
+            None
+
+        Example:
+            >>> print(self.__model_trainer_input_data)
+                (   id  admitted       gpa  stats  programming  masters
+                0  19         0  0.051643    0.0          0.0      1.0
+                1   6         1  0.765258    0.5          0.0      1.0
+                2  15         1  1.000000    0.0          0.0      1.0
+                3  32         0  0.746479    0.0          0.5      1.0
+                4  12         1  0.835681    1.0          1.0      0.0
+                5  40         0  0.976526    1.0          0.5      1.0
+                6   7         1  0.215962    1.0          1.0      1.0
+                7  36         0  0.530516    0.0          1.0      0.0
+                8  28         1  0.967136    0.0          0.0      0.0
+                9  17         1  0.920188    0.0          0.0      0.0,    
+                    id  admitted       gpa  stats  programming  masters
+                0   4         1  0.765258    0.5          1.0      1.0
+                1   6         1  0.765258    0.5          0.0      1.0
+                2   7         1  0.215962    1.0          1.0      1.0
+                3   8         1  0.812207    0.5          0.0      0.0
+                4  10         1  0.863850    0.0          0.0      0.0
+                5  11         1  0.591549    0.0          0.0      0.0
+                6   9         1  0.915493    0.0          0.0      0.0
+                7   5         0  0.737089    1.0          1.0      0.0
+                8   3         1  0.859155    1.0          0.5      0.0
+                9   2         0  0.887324    0.5          0.5      1.0,   
+                    id  admitted       gpa  stats  programming  masters
+                0  23         1  0.807512    0.0          1.0      1.0
+                1  25         1  0.981221    0.0          0.0      0.0
+                2  26         1  0.798122    0.0          0.0      1.0
+                3  27         0  0.981221    0.0          0.0      1.0
+                4  29         0  1.000000    1.0          0.5      1.0
+                5  30         0  0.901408    0.0          1.0      1.0
+                6  28         1  0.967136    0.0          0.0      0.0
+                7  24         1  0.000000    0.0          1.0      0.0
+                8  22         0  0.746479    1.0          0.5      1.0
+                9  21         1  0.938967    1.0          0.5      0.0)
+            
+            >>> print(self._labeled_data)
+                {'DF_0':        id  admitted       gpa  stats  programming  masters
+                            0  26         1  0.798122    0.0          0.0      1.0
+                            1  40         0  0.976526    1.0          0.5      1.0
+                            2   7         1  0.215962    1.0          1.0      1.0
+                            3  19         0  0.051643    0.0          0.0      1.0
+                            4  15         1  1.000000    0.0          0.0      1.0
+                            5  32         0  0.746479    0.0          0.5      1.0
+                            6  38         1  0.366197    0.0          0.5      1.0
+                            7  12         1  0.835681    1.0          1.0      0.0
+                            8   6         1  0.765258    0.5          0.0      1.0
+                            9  36         0  0.530516    0.0          1.0      0.0, 
+                'DF_1':         id  admitted       gpa  stats  programming  masters
+                            0   4         1  0.765258    0.5          1.0      1.0
+                            1   6         1  0.765258    0.5          0.0      1.0
+                            2   7         1  0.215962    1.0          1.0      1.0
+                            3   8         1  0.812207    0.5          0.0      0.0
+                            4  10         1  0.863850    0.0          0.0      0.0
+                            5  11         1  0.591549    0.0          0.0      0.0
+                            6   9         1  0.915493    0.0          0.0      0.0
+                            7   5         0  0.737089    1.0          1.0      0.0
+                            8   3         1  0.859155    1.0          0.5      0.0
+                            9   2         0  0.887324    0.5          0.5      1.0, 
+                'DF_2':        id  admitted       gpa  stats  programming  masters
+                            0  23         1  0.807512    0.0          1.0      1.0
+                            1  25         1  0.981221    0.0          0.0      0.0
+                            2  26         1  0.798122    0.0          0.0      1.0
+                            3  27         0  0.981221    0.0          0.0      1.0
+                            4  29         0  1.000000    1.0          0.5      1.0
+                            5  30         0  0.901408    0.0          1.0      1.0
+                            6  28         1  0.967136    0.0          0.0      0.0
+                            7  24         1  0.000000    0.0          1.0      0.0
+                            8  22         0  0.746479    1.0          0.5      1.0
+                            9  21         1  0.938967    1.0          0.5      0.0}
+        """
+        if self.__is_trainable:
+            # "data" argument is a required argument for model trainer function 
+            # when data argument is not passed with hyperparameters. On other side,
+            # "data" argument will be optional argument when data argument 
+            # is passed with hyperparameters.
+            _is_optional_arg = self.__model_trainer_input_data is not None
+            # validate the model trainer function 'data' argument.
+            self.__validate_model_trainer_input_data_argument(data, _is_optional_arg)
+            
+            if not data is None:
+                # '__model_trainer_input_data' is assigned with "data" argument,
+                # when user passes data argument in fit() method.
+                # Note: if user attempts to pass data argument in both "params" 
+                # argument as hyperparameters or "data" argument in fit() 
+                # method, then latest "data" argument value is considered 
+                # for model training.
+                self.__model_trainer_input_data = data
+
+        if self.__is_trainable and self.__is_evaluatable and self.__is_sqle_function:
+            self._labeled_data = self._add_data_label()
 
 
 class GridSearch(_BaseSearch):
@@ -2659,9 +2850,8 @@ class GridSearch(_BaseSearch):
 
         """
 
-        self.__params = params
+        self.__params = params.copy()
         super().__init__(func=func, params=self.__params)
- 
         # Populate parameter grid from provided parameter space.
         self.__populate_params_grid()
 
@@ -2688,87 +2878,381 @@ class GridSearch(_BaseSearch):
         # Since GridSearch works on all parameter combinations. Set 
         # all the parameter combinations to the parameter grid.
         self._parameter_grid = self._BaseSearch__populate_parameter_grid()
+        
 
-
-class RandomSearch(_BaseSearch):
-    def __init__(self, func, params, n_iter=10):
+    def fit(self, 
+            data=None,
+            evaluation_metric=None, 
+            early_stop=None,
+            frac=0.8,
+            run_parallel=True,
+            wait=True,
+            verbose=0,
+            stratify_column=None, 
+            sample_id_column=None, 
+            sample_seed=None,
+            max_time=None,
+            **kwargs):
         """
         DESCRIPTION:
-            RandomSearch algorithm performs random sampling on hyperparameter 
-            space to identify optimal hyperparameters. It works for
-            teradataml analytic functions from SQLE, BYOM, VAL and UAF features.
-            teradataml RandomSearch allows user to perform hyperparameter tuning for 
-            all model trainer and non-model trainer functions.
-            When used for model trainer functions:
-                * Based on evaluation metrics search determines best model.
-                * All methods and properties can be used.
-            When used for non-model trainer functions:
-                * Only fit() method is supported.
-                * User can choose the best output as they see fit to use this.
-
-            teradataml RandomSearch also allows user to use input data as the 
-            hyperparameter. This option can be suitable when the user wants to
-            identify the best models for a set of input data. When user passes
-            set of data as hyperparameter for model trainer function, the search
-            determines the best data along with the best model based on the 
-            evaluation metrics.
+            Function to perform hyperparameter tuning using GridSearch algorithm.
+            Notes:
+                * In the Model trainer function, the best parameters are 
+                  selected based on training results.
+                * In the Non model trainer function, First execution parameter
+                  set is selected as the best parameters.
 
         PARAMETERS:
-            func:
-                Required Argument.
-                Specifies a teradataml analytic function from SQLE, VAL, and UAF.
-                Types:
-                    teradataml Analytic Functions
-                        * Advanced analytic functions
-                        * UAF
-                        * VAL
-                    Refer to display_analytic_functions() function for list of functions.
+            data:
+                Optional Argument.
+                Specifies the input teradataml DataFrame for model trainer function.
+                Notes:
+                    * DataFrame need not to be passed in fit() methods, when "data" is 
+                      passed as a model hyperparameters ("params"). 
+                    * "data" is a required argument for model trainer functions.
+                    * "data" is ignored for non-model trainer functions.
+                    * "data" can be contain single DataFrame or multiple DataFrame.
+                    * One can pass multiple dataframes to "data". Hyperparameter 
+                      tuning is performed on all the dataframes for every model 
+                      parameter.
+                    * "data" can be either a dictionary OR a tuple OR a dataframe.
+                        * If it is a dictionary then Key represents the label for 
+                          dataframe and Value represents the dataframe.
+                        * If it is a tuple then teradataml converts it to dictionary
+                          by generating the labels internally.
+                        * If it is a dataframe then teradataml label it as "DF_0".
+                Types: teradataml DataFrame, dictionary, tuples
 
-            params:
-                Required Argument.
-                Specifies the parameter(s) of a teradataml analytic function. 
-                The parameter(s) must be in dictionary. keys refers to the 
-                argument names and values refers to argument values for corresponding
-                arguments. 
+            evaluation_metric:
+                Optional Argument.
+                Specifies the evaluation metrics to considered for model 
+                evaluation.
                 Notes:
-                    * One can specify the argument value in a tuple to run HPT 
-                      with different arguments.
-                    * Model trainer function arguments "id_column", "input_columns",
-                      and "target_columns" must be passed in fit() method.
-                    * All required arguments of non-model trainer function must be
-                      passed while RandomSearch object creation.
-                Types: dict
-            
-            n_iter:
+                    * evaluation_metric applicable for model trainer functions.
+                    * Best model is not selected when evaluation returns 
+                      non-finite values.
+                Permitted Values:
+                    * Classification: Accuracy, Micro-Precision, Micro-Recall,
+                                      Micro-F1, Macro-Precision, Macro-Recall,
+                                      Macro-F1, Weighted-Precision, 
+                                      Weighted-Recall,
+                                      Weighted-F1.
+                    * Regression: MAE, MSE, MSLE, MAPE, MPE, RMSE, RMSLE, ME, 
+                                  R2, EV, MPD, MGD
+                    
+                Default Value:
+                    * Classification: Accuracy
+                    * Regression: MAE
+                Types: str
+
+            early_stop:
                 Optional Argument.
-                Specifies the number of iterations random search need to be performed.
+                Specifies the early stop mechanism value for model trainer 
+                functions. Hyperparameter tuning ends model training when 
+                the training model evaluation metric attains "early_stop" value.
                 Note:
-                    * n_iter must be less than the size of parameter populations.
-                Default Value: 10
-                Types: int
-
-        RETURNS:
-            None
+                    * Early stopping supports only when evaluation returns 
+                      finite value.
+                Types: int or float
 
-        RAISES:
-            TeradataMlException, TypeError, ValueError
-        
-        EXAMPLES:
-            >>> # Example 1: Model trainer function. Performing hyperparameter-tuning
-            >>> #            on SVM model trainer function using random search algorithm.
-  
-            >>> # Load the example data.
-            >>> load_example_data("teradataml", ["cal_housing_ex_raw"])
-            
-            >>> # Create teradataml DataFrame objects.
-            >>> data_input = DataFrame.from_table("cal_housing_ex_raw")
+            frac:
+                Optional Argument.
+                Specifies the split percentage of rows to be sampled for training 
+                and testing dataset. "frac" argument value must range between (0, 1).
+                Notes: 
+                    * This "frac" argument is not supported for non-model trainer 
+                      function.
+                    * The "frac" value is considered as train split percentage and 
+                      The remaining percentage is taken into account for test splitting.
+                Default Value: 0.8
+                Types: float
             
-            >>> # Scale "target_columns" with respect to 'STD' value of the column.
-            >>> fit_obj = ScaleFit(data=data_input,
-                                   target_columns=['MedInc', 'HouseAge', 'AveRooms',
-                                                   'AveBedrms', 'Population', 'AveOccup',
-                                                   'Latitude', 'Longitude'],
-                                   scale_method="STD")
+            run_parallel:
+                Optional Argument.
+                Specifies the parallel execution functionality of hyperparameter 
+                tuning. When "run_parallel" set to true, model functions are 
+                executed concurrently. Otherwise, model functions are executed 
+                sequentially.
+                Default Value: True
+                Types: bool
+            
+            wait:
+                Optional Argument.
+                Specifies whether to wait for the completion of execution 
+                of hyperparameter tuning or not. When set to False, hyperparameter 
+                tuning is executed in the background and user can use "is_running()" 
+                method to check the status. Otherwise it waits until the execution 
+                is complete to return the control back to user.
+                Default Value: True
+                Type: bool
+
+            verbose:
+                Optional Argument.
+                Specifies whether to log the model training information and display 
+                the logs. When it is set to 1, progress bar alone logged in the 
+                console. When it is set to 2, along with progress bar, execution 
+                steps and execution time is logged in the console. When it is set 
+                to 0, nothing is logged in the console. 
+                Note:
+                    * verbose is not significant when "wait" is 'False'.
+                Default Value: 0
+                Type: bool
+            
+            sample_seed:
+                Optional Argument.
+                Specifies the seed value that controls the shuffling applied
+                to the data before applying the Train-Test split. Pass an int for 
+                reproducible output across multiple function calls.
+                Notes:
+                    * When the argument is not specified, different
+                      runs of the query generate different outputs.
+                    * It must be in the range [0, 2147483647]
+                    * Seed is supported for stratify column.
+                Types: int
+
+            stratify_column:
+                Optional Argument.
+                Specifies column name that contains the labels indicating
+                which data needs to be stratified for TrainTest split. 
+                Notes:
+                    * seed is supported for stratify column.
+                Types: str
+            
+            sample_id_column:
+                Optional Argument.
+                Specifies the input data column name that has the
+                unique identifier for each row in the input.
+                Note:
+                    * Mandatory when "sample_seed" argument is present.
+                Types: str
+
+            max_time:
+                Optional Argument.
+                Specifies the maximum time for the completion of Hyperparameter tuning execution.
+                Default Value: None
+                Types: int or float
+
+            kwargs:
+                Optional Argument.
+                Specifies the keyword arguments. Accepts additional arguments 
+                required for the teradataml analytic function.
+
+        RETURNS:
+            None
+
+        RAISES:
+            TeradataMlException, TypeError, ValueError
+
+        EXAMPLES:
+            >>> # Create an instance of the GridSearch algorithm called "optimizer_obj" 
+            >>> optimizer_obj = GridSearch(func=SVM, params=params)
+
+            >>> eval_params = {"id_column": "id",
+                               "accumulate": "MedHouseVal"}
+            >>> # Example 1: Passing single DataFrame for model trainer function.
+            >>> optimizer_obj.fit(data=train_df,
+                                  evaluation_metric="MAE",
+                                  early_stop=70.9,
+                                  **eval_params)
+            
+            >>> # Example 2: Passing multiple datasets as tuple of DataFrames for 
+            >>> #            model trainer function.
+            >>> optimizer_obj.fit(data=(train_df_1, train_df_2),
+                                  evaluation_metric="MAE",
+                                  early_stop=70.9,
+                                  **eval_params)  
+            
+            >>> # Example 3: Passing multiple datasets as dictionary of DataFrames 
+            >>> #            for model trainer function.
+            >>> optimizer_obj.fit(data={"Data-1":train_df_1, "Data-2":train_df_2},
+                                  evaluation_metric="MAE",
+                                  early_stop=70.9,
+                                  **eval_params)  
+
+            >>> # Example 4: No data argument passed in fit() method for model trainer function.
+            >>> #            Note: data argument must be passed while creating HPT object as 
+            >>> #                  model hyperparameters.
+            
+            >>> # Define parameter space for model training with "data" argument.
+            >>> params = {"data":(df1, df2),
+                          "input_columns":['MedInc', 'HouseAge', 'AveRooms',
+                                           'AveBedrms', 'Population', 'AveOccup',
+                                           'Latitude', 'Longitude'],
+                          "response_column":"MedHouseVal",
+                          "model_type":"regression",
+                          "batch_size":(11, 50, 75),
+                          "iter_max":(100, 301),
+                          "intercept":False,
+                          "learning_rate":"INVTIME",
+                          "nesterov_optimization":True,
+                          "local_sgd_iterations":1}
+            
+            >>> # Create "optimizer_obj" using GridSearch algorithm and perform 
+            >>> # fit() method without any "data" argument for model trainer function.
+            >>> optimizer_obj.fit(evaluation_metric="MAE",
+                                  early_stop=70.9,
+                                  **eval_params) 
+
+            >>> # Example 5: Do not pass data argument in fit() method for 
+            >>> #            non-model trainer function.
+            >>> #            Note: data argument must be passed while creating HPT  
+            >>> #                  object as model hyperparameters.
+            >>> optimizer_obj.fit() 
+
+            >>> # Example 6: Passing "verbose" argument value '1' in fit() method to 
+            >>> #            display model log.
+            >>> optimizer_obj.fit(data=train_df, evaluation_metric="R2",
+                                  verbose=1, **eval_params)
+                completed: |████████████████████████████████████████████████████████████| 100% - 6/6
+
+            >>> # Example 7: max_time argument is passed in fit() method.
+            >>> # Model training parameters
+            >>> model_params = {"input_columns":['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],
+            ...                 "response_column" :'species',
+            ...                 "max_depth":(5,10,15),
+            ...                 "lambda1" :(1000.0,0.001),
+            ...                 "model_type" :"Classification",
+            ...                 "seed":32,
+            ...                 "shrinkage_factor":0.1,
+            ...                 "iter_num":(5, 50)}
+            >>>
+            >>> eval_params = {"id_column": "id",
+            ...                "accumulate":"species",
+            ...                "model_type":'Classification',
+            ...                "object_order_column":['task_index', 'tree_num', 'iter','class_num', 'tree_order']
+                            }
+            >>>
+            >>> # Import model trainer function and optimizer.
+            >>> from teradataml import XGBoost, GridSearch
+            >>>
+            >>> # Initialize the GridSearch optimizer with model trainer
+            >>> # function and parameter space required for model training.
+            >>> gs_obj = GridSearch(func=XGBoost, params=model_params)
+            >>>
+            >>> # fit() method with max_time argument(in seconds) for model trainer function.
+            >>> gs_obj.fit(data=data, max_time=30, verbose=2, **eval_params)
+                Model_id:XGBOOST_2 - Run time:33.277s - Status:PASS - ACCURACY:0.933               
+                Model_id:XGBOOST_3 - Run time:33.276s - Status:PASS - ACCURACY:0.933               
+                Model_id:XGBOOST_0 - Run time:33.279s - Status:PASS - ACCURACY:0.967                
+                Model_id:XGBOOST_1 - Run time:33.278s - Status:PASS - ACCURACY:0.933                
+                Computing: ｜⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾｜ 33% - 4/12
+            >>>
+            >>> # status 'SKIP' for the models which are not completed within the max_time.
+            >>> gs_obj.models
+                    MODEL_ID	DATA_ID	                                       PARAMETERS	STATUS	ACCURACY
+                0	XGBOOST_2	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	PASS	0.933333
+                1	XGBOOST_4	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	SKIP	NaN
+                2	XGBOOST_5	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	SKIP	NaN
+                3	XGBOOST_6	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	SKIP	NaN
+                4	XGBOOST_7	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	SKIP	NaN
+                5	XGBOOST_8	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	SKIP	NaN
+                6	XGBOOST_9	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	SKIP	NaN
+                7	XGBOOST_10	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	SKIP	NaN
+                8	XGBOOST_11	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	SKIP	NaN
+                9	XGBOOST_3	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	PASS	0.933333
+                10	XGBOOST_0	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	PASS	0.966667
+                11	XGBOOST_1	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	PASS	0.933333
+        """
+        
+        # Set the flag to discard invalid column parameters.
+        self.discard_invalid_column_params =kwargs.get("discard_invalid_column_params", False)
+
+        if self.discard_invalid_column_params:
+            # Setting model trainer input data.
+            super()._setting_model_trainer_data(data)
+            # Data mapping for model trainer function.
+            super()._data_mapping()
+            # Setting the lambda function to None.
+            self._setting_model_trainer_data = lambda data: None
+            self._BaseSearch__update_model_parameters = lambda: None
+
+        # Calling baseSearch class fit method.
+        super().fit(data, evaluation_metric, 
+                    early_stop, frac, run_parallel,
+                    wait, verbose, stratify_column, 
+                    sample_id_column, sample_seed,
+                    max_time, **kwargs)
+
+
+class RandomSearch(_BaseSearch):
+    def __init__(self, func, params, n_iter=10, **kwargs):
+        """
+        DESCRIPTION:
+            RandomSearch algorithm performs random sampling on hyperparameter 
+            space to identify optimal hyperparameters. It works for
+            teradataml analytic functions from SQLE, BYOM, VAL and UAF features.
+            teradataml RandomSearch allows user to perform hyperparameter tuning for 
+            all model trainer and non-model trainer functions.
+            When used for model trainer functions:
+                * Based on evaluation metrics search determines best model.
+                * All methods and properties can be used.
+            When used for non-model trainer functions:
+                * Only fit() method is supported.
+                * User can choose the best output as they see fit to use this.
+
+            teradataml RandomSearch also allows user to use input data as the 
+            hyperparameter. This option can be suitable when the user wants to
+            identify the best models for a set of input data. When user passes
+            set of data as hyperparameter for model trainer function, the search
+            determines the best data along with the best model based on the 
+            evaluation metrics.
+
+        PARAMETERS:
+            func:
+                Required Argument.
+                Specifies a teradataml analytic function from SQLE, VAL, and UAF.
+                Types:
+                    teradataml Analytic Functions
+                        * Advanced analytic functions
+                        * UAF
+                        * VAL
+                    Refer to display_analytic_functions() function for list of functions.
+
+            params:
+                Required Argument.
+                Specifies the parameter(s) of a teradataml analytic function. 
+                The parameter(s) must be in dictionary. keys refers to the 
+                argument names and values refers to argument values for corresponding
+                arguments. 
+                Notes:
+                    * One can specify the argument value in a tuple to run HPT 
+                      with different arguments.
+                    * Model trainer function arguments "id_column", "input_columns",
+                      and "target_columns" must be passed in fit() method.
+                    * All required arguments of non-model trainer function must be
+                      passed while RandomSearch object creation.
+                Types: dict
+            
+            n_iter:
+                Optional Argument.
+                Specifies the number of iterations random search need to be performed.
+                Note:
+                    * n_iter must be less than the size of parameter populations.
+                Default Value: 10
+                Types: int
+
+        RETURNS:
+            None
+
+        RAISES:
+            TeradataMlException, TypeError, ValueError
+        
+        EXAMPLES:
+            >>> # Example 1: Model trainer function. Performing hyperparameter-tuning
+            >>> #            on SVM model trainer function using random search algorithm.
+  
+            >>> # Load the example data.
+            >>> load_example_data("teradataml", ["cal_housing_ex_raw"])
+            
+            >>> # Create teradataml DataFrame objects.
+            >>> data_input = DataFrame.from_table("cal_housing_ex_raw")
+            
+            >>> # Scale "target_columns" with respect to 'STD' value of the column.
+            >>> fit_obj = ScaleFit(data=data_input,
+                                   target_columns=['MedInc', 'HouseAge', 'AveRooms',
+                                                   'AveBedrms', 'Population', 'AveOccup',
+                                                   'Latitude', 'Longitude'],
+                                   scale_method="STD")
             
             >>> # Transform the data.
             >>> transform_obj = ScaleTransform(data=data_input,
@@ -2953,7 +3437,7 @@ class RandomSearch(_BaseSearch):
 
         """
 
-        self.__params = params
+        self.__params = params.copy()
         super().__init__(func=func, params=self.__params)
         # Validate argument 'n_iter'
         awu_matrix = []
@@ -2964,10 +3448,9 @@ class RandomSearch(_BaseSearch):
         # Validates the range of n_iter should be greater than or equal to 1 and
         # less than or equal to parameter space.
         _Validators._validate_argument_range(n_iter, "n_iter", 1, len(parameter_space), True, True)
+        self._n_iter = n_iter
 
-        self.__populate_params_grid(n_iter, parameter_space)
-
-    def __populate_params_grid(self, n_iter, parameter_space):
+    def __populate_params_grid(self):
         """
         DESCRIPTION:
             Populate parameter grid based on the search algorithm. In random search,
@@ -2988,6 +3471,313 @@ class RandomSearch(_BaseSearch):
         EXAMPLES:
             >>> self.__populate_params_grid()
         """
-
         # Populate the parameter space with random and non-repetitive value
-        self._parameter_grid = random.sample(parameter_space, n_iter)
+        if self.discard_invalid_column_params:
+            # Defining the empty data_grouped_dict to group the parameters based on data_id.
+            data_grouped_dict = defaultdict(list)
+            for parameter in self._parameter_grid:
+                # Extracting the data_id from the parameter.
+                data_id = parameter['data_id']
+                # Grouping the parameters based on data_id.
+                data_grouped_dict[data_id].append(parameter)
+            # Converting the grouped dictionary to list.
+            data_grouped_dict = list(data_grouped_dict.values())
+            parameter_grid = []
+            for group in data_grouped_dict:
+                # Randomly selecting the n_iter parameters from the grouped data.
+                tmp = random.sample(group, self._n_iter)
+                parameter_grid.extend(tmp)
+
+            # Setting the parameter grid.
+            self._parameter_grid = parameter_grid
+        else:
+            self._parameter_grid = random.sample(self.get_parameter_grid(), self._n_iter)
+    
+    def fit(self, 
+            data=None,
+            evaluation_metric=None, 
+            early_stop=None,
+            frac=0.8,
+            run_parallel=True,
+            wait=True,
+            verbose=0,
+            stratify_column=None, 
+            sample_id_column=None, 
+            sample_seed=None,
+            max_time=None,
+            **kwargs):   
+        """
+        DESCRIPTION:
+            Function to perform hyperparameter tuning using RandomSearch algorithm.
+            Notes:
+                * In the Model trainer function, the best parameters are 
+                  selected based on training results.
+                * In the Non model trainer function, First execution parameter
+                  set is selected as the best parameters.
+
+        PARAMETERS:
+            data:
+                Optional Argument.
+                Specifies the input teradataml DataFrame for model trainer function.
+                Notes:
+                    * DataFrame need not to be passed in fit() methods, when "data" is 
+                      passed as a model hyperparameters ("params"). 
+                    * "data" is a required argument for model trainer functions.
+                    * "data" is ignored for non-model trainer functions.
+                    * "data" can be contain single DataFrame or multiple DataFrame.
+                    * One can pass multiple dataframes to "data". Hyperparameter 
+                      tuning is performed on all the dataframes for every model 
+                      parameter.
+                    * "data" can be either a dictionary OR a tuple OR a dataframe.
+                        * If it is a dictionary then Key represents the label for 
+                          dataframe and Value represents the dataframe.
+                        * If it is a tuple then teradataml converts it to dictionary
+                          by generating the labels internally.
+                        * If it is a dataframe then teradataml label it as "DF_0".
+                Types: teradataml DataFrame, dictionary, tuples
+
+            evaluation_metric:
+                Optional Argument.
+                Specifies the evaluation metrics to considered for model 
+                evaluation.
+                Notes:
+                    * evaluation_metric applicable for model trainer functions.
+                    * Best model is not selected when evaluation returns 
+                      non-finite values.
+                Permitted Values:
+                    * Classification: Accuracy, Micro-Precision, Micro-Recall,
+                                      Micro-F1, Macro-Precision, Macro-Recall,
+                                      Macro-F1, Weighted-Precision, 
+                                      Weighted-Recall,
+                                      Weighted-F1.
+                    * Regression: MAE, MSE, MSLE, MAPE, MPE, RMSE, RMSLE, ME, 
+                                  R2, EV, MPD, MGD
+                    
+                Default Value:
+                    * Classification: Accuracy
+                    * Regression: MAE
+                Types: str
+
+            early_stop:
+                Optional Argument.
+                Specifies the early stop mechanism value for model trainer 
+                functions. Hyperparameter tuning ends model training when 
+                the training model evaluation metric attains "early_stop" value.
+                Note:
+                    * Early stopping supports only when evaluation returns 
+                      finite value.
+                Types: int or float
+
+            frac:
+                Optional Argument.
+                Specifies the split percentage of rows to be sampled for training 
+                and testing dataset. "frac" argument value must range between (0, 1).
+                Notes: 
+                    * This "frac" argument is not supported for non-model trainer 
+                      function.
+                    * The "frac" value is considered as train split percentage and 
+                      The remaining percentage is taken into account for test splitting.
+                Default Value: 0.8
+                Types: float
+            
+            run_parallel:
+                Optional Argument.
+                Specifies the parallel execution functionality of hyperparameter 
+                tuning. When "run_parallel" set to true, model functions are 
+                executed concurrently. Otherwise, model functions are executed 
+                sequentially.
+                Default Value: True
+                Types: bool
+            
+            wait:
+                Optional Argument.
+                Specifies whether to wait for the completion of execution 
+                of hyperparameter tuning or not. When set to False, hyperparameter 
+                tuning is executed in the background and user can use "is_running()" 
+                method to check the status. Otherwise it waits until the execution 
+                is complete to return the control back to user.
+                Default Value: True
+                Type: bool
+
+            verbose:
+                Optional Argument.
+                Specifies whether to log the model training information and display 
+                the logs. When it is set to 1, progress bar alone logged in the 
+                console. When it is set to 2, along with progress bar, execution 
+                steps and execution time is logged in the console. When it is set 
+                to 0, nothing is logged in the console. 
+                Note:
+                    * verbose is not significant when "wait" is 'False'.
+                Default Value: 0
+                Type: bool
+            
+            sample_seed:
+                Optional Argument.
+                Specifies the seed value that controls the shuffling applied
+                to the data before applying the Train-Test split. Pass an int for 
+                reproducible output across multiple function calls.
+                Notes:
+                    * When the argument is not specified, different
+                      runs of the query generate different outputs.
+                    * It must be in the range [0, 2147483647]
+                    * Seed is supported for stratify column.
+                Types: int
+
+            stratify_column:
+                Optional Argument.
+                Specifies column name that contains the labels indicating
+                which data needs to be stratified for TrainTest split. 
+                Notes:
+                    * seed is supported for stratify column.
+                Types: str
+            
+            sample_id_column:
+                Optional Argument.
+                Specifies the input data column name that has the
+                unique identifier for each row in the input.
+                Note:
+                    * Mandatory when "sample_seed" argument is present.
+                Types: str
+
+            max_time:
+                Optional Argument.
+                Specifies the maximum time for the completion of Hyperparameter tuning execution.
+                Default Value: None
+                Types: int or float
+
+            kwargs:
+                Optional Argument.
+                Specifies the keyword arguments. Accepts additional arguments 
+                required for the teradataml analytic function.
+
+        RETURNS:
+            None
+
+        RAISES:
+            TeradataMlException, TypeError, ValueError
+
+        EXAMPLES:
+            >>> # Create an instance of the RandomSearch algorithm called "optimizer_obj" 
+            >>> optimizer_obj = RandomSearch(func=SVM, params=params, n_iter=3)
+
+            >>> eval_params = {"id_column": "id",
+                               "accumulate": "MedHouseVal"}
+            >>> # Example 1: Passing single DataFrame for model trainer function.
+            >>> optimizer_obj.fit(data=train_df,
+                                  evaluation_metric="MAE",
+                                  early_stop=70.9,
+                                  **eval_params)
+            
+            >>> # Example 2: Passing multiple datasets as tuple of DataFrames for 
+            >>> #            model trainer function.
+            >>> optimizer_obj.fit(data=(train_df_1, train_df_2),
+                                  evaluation_metric="MAE",
+                                  early_stop=70.9,
+                                  **eval_params)  
+            
+            >>> # Example 3: Passing multiple datasets as dictionary of DataFrames 
+            >>> #            for model trainer function.
+            >>> optimizer_obj.fit(data={"Data-1":train_df_1, "Data-2":train_df_2},
+                                  evaluation_metric="MAE",
+                                  early_stop=70.9,
+                                  **eval_params)  
+
+            >>> # Example 4: No data argument passed in fit() method for model trainer function.
+            >>> #            Note: data argument must be passed while creating HPT object as 
+            >>> #                  model hyperparameters.
+            
+            >>> # Define parameter space for model training with "data" argument.
+            >>> params = {"data":(df1, df2),
+                          "input_columns":['MedInc', 'HouseAge', 'AveRooms',
+                                           'AveBedrms', 'Population', 'AveOccup',
+                                           'Latitude', 'Longitude'],
+                          "response_column":"MedHouseVal",
+                          "model_type":"regression",
+                          "batch_size":(11, 50, 75),
+                          "iter_max":(100, 301),
+                          "intercept":False,
+                          "learning_rate":"INVTIME",
+                          "nesterov_optimization":True,
+                          "local_sgd_iterations":1}
+            
+            >>> # Create "optimizer_obj" using RandomSearch algorithm and perform 
+            >>> # fit() method without any "data" argument for model trainer function.
+            >>> optimizer_obj.fit(evaluation_metric="MAE",
+                                  early_stop=70.9,
+                                  **eval_params) 
+
+            >>> # Example 5: Do not pass data argument in fit() method for 
+            >>> #            non-model trainer function.
+            >>> #            Note: data argument must be passed while creating HPT  
+            >>> #                  object as model hyperparameters.
+            >>> optimizer_obj.fit() 
+
+            >>> # Example 6: Passing "verbose" argument value '1' in fit() method to 
+            >>> #            display model log.
+            >>> optimizer_obj.fit(data=train_df, evaluation_metric="R2",
+                                  verbose=1, **eval_params)
+                completed: |████████████████████████████████████████████████████████████| 100% - 6/6
+
+            >>> # Example 7: max_time argument is passed in fit() method.
+            >>> # Model training parameters
+            >>> model_params = {"input_columns":['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],
+            ...                 "response_column" : 'species',
+            ...                 "max_depth":(5,10,15),
+            ...                 "lambda1" : (1000.0,0.001),
+            ...                 "model_type" :"Classification",
+            ...                 "seed":32,
+            ...                 "shrinkage_factor":0.1,
+            ...                 "iter_num":(5, 50)}
+            >>>
+            >>> eval_params = {"id_column": "id",
+            ...                "accumulate": "species",
+            ...                "model_type":'Classification',
+            ...                "object_order_column":['task_index', 'tree_num', 'iter','class_num', 'tree_order']
+            ...               }
+            >>>
+            >>> # Import model trainer and optimizer
+            >>> from teradataml import XGBoost, RandomSearch
+            >>>
+            >>> # Initialize the RandomSearch optimizer with model trainer
+            >>> # function and parameter space required for model training.
+            >>> rs_obj = RandomSearch(func=XGBoost, params=model_params, n_iter=5)
+            >>>
+            >>> # fit() method with max_time argument(in seconds) for model trainer function.
+            >>> rs_obj.fit(data=data, max_time=30, verbose=2, **eval_params)
+                Model_id:XGBOOST_3 - Run time:28.292s - Status:PASS - ACCURACY:0.8                 
+                Model_id:XGBOOST_0 - Run time:28.291s - Status:PASS - ACCURACY:0.867               
+                Model_id:XGBOOST_2 - Run time:28.289s - Status:PASS - ACCURACY:0.867               
+                Model_id:XGBOOST_1 - Run time:28.291s - Status:PASS - ACCURACY:0.867               
+                Computing: ｜⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫿⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾⫾｜ 80% - 4/5
+            >>>
+            >>> # status 'SKIP' for the models which are not completed within the max_time.
+            >>> rs_obj.models
+                    MODEL_ID	DATA_ID	                                       PARAMETERS	STATUS	ACCURACY
+                0	XGBOOST_3	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	PASS	0.800000
+                1	XGBOOST_4	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	SKIP	NaN
+                2	XGBOOST_0	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	PASS	0.866667
+                3	XGBOOST_2	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	PASS	0.866667
+                4	XGBOOST_1	DF_0	{'input_columns': ['sepal_length', 'sepal_widt...	PASS	0.866667
+        """
+
+        # Set discard_invalid_column_params flag.
+        self.discard_invalid_column_params =kwargs.get("discard_invalid_column_params", False)
+
+        if self.discard_invalid_column_params:
+            # Setting model trainer input data
+            super()._setting_model_trainer_data(data)
+            # Mapping the data with input columns
+            super()._data_mapping()
+            # Setting the lambda function to None.
+            self._setting_model_trainer_data = lambda data: None
+            self._BaseSearch__update_model_parameters = lambda: None
+        
+        # Populate parameter grid.
+        self.__populate_params_grid()
+
+        # Calling baseSearch class fit method.
+        super().fit(data, evaluation_metric, early_stop, 
+                    frac, run_parallel, wait, verbose, 
+                    stratify_column, sample_id_column, 
+                    sample_seed, max_time, **kwargs)
+