teradataml 20.0.0.1__py3-none-any.whl → 20.0.0.3__py3-none-any.whl

teradataml/automl/__init__.py

@@ -15,22 +15,29 @@
 
 # Python libraries
 import json
+import pandas as pd
 import numpy as np
 from sklearn.metrics import confusion_matrix
 import time
+import ast
+import warnings
+import joblib
+from io import BytesIO
 
 # Teradata libraries
 from teradataml.dataframe.copy_to import copy_to_sql
 from teradataml import ColumnExpression
 from teradataml.dataframe.dataframe import DataFrame
+from teradataml.utils.utils import execute_sql
 from teradataml.utils.validators import _Validators
-from teradataml import ROC
-from teradataml.common.utils import UtilFuncs
+from teradataml import ROC, BLOB
 from teradataml.utils.dtypes import _Dtypes
 from teradataml.common.utils import UtilFuncs
 from teradataml import TeradataMlException
 from teradataml.common.messages import Messages, MessageCodes
-from teradatasqlalchemy.telemetry.queryband import collect_queryband
+from teradataml.telemetry_utils.queryband import collect_queryband
+from teradataml import TeradataConstants
+from teradataml import XGBoost, DecisionForest, KNN, SVM, GLM, db_drop_table
 
 # AutoML Internal libraries
 from teradataml.automl.data_preparation import _DataPreparation
@@ -53,7 +60,8 @@ class AutoML:
                  stopping_metric = None, 
                  stopping_tolerance = None,
                  max_models = None,
-                 custom_config_file = None):
+                 custom_config_file = None,
+                 **kwargs):
         """
         DESCRIPTION:
             AutoML (Automated Machine Learning) is an approach that automates the process 
@@ -132,8 +140,10 @@ class AutoML:
                 Required, when "stopping_tolerance" is set, otherwise optional.
                 Specifies the stopping metrics for stopping tolerance in model training.
                 Permitted Values: 
-                    * For task_type "Regression": "R2", "MAE", "MSE", "MSLE", 
-                                                  "RMSE", "RMSLE"
+                    * For task_type "Regression": "R2", "MAE", "MSE", "MSLE",
+                                                  "MAPE", "MPE", "RMSE", "RMSLE",
+                                                  "ME", "EV", "MPD", "MGD"
+
                     * For task_type "Classification": 'MICRO-F1','MACRO-F1',
                                                       'MICRO-RECALL','MACRO-RECALL',
                                                       'MICRO-PRECISION', 'MACRO-PRECISION',
@@ -155,6 +165,28 @@ class AutoML:
                 Optional Argument.
                 Specifies the path of JSON file in case of custom run.
                 Types: str
+
+            **kwargs:
+                Specifies the additional arguments for AutoML. Below
+                are the additional arguments:
+                    volatile:
+                        Optional Argument.
+                        Specifies whether to put the interim results of the
+                        functions in a volatile table or not. When set to
+                        True, results are stored in a volatile table,
+                        otherwise not.
+                        Default Value: False
+                        Types: bool
+
+                    persist:
+                        Optional Argument.
+                        Specifies whether to persist the interim results of the
+                        functions in a table or not. When set to True,
+                        results are persisted in a table; otherwise,
+                        results are garbage collected at the end of the
+                        session.
+                        Default Value: False
+                        Types: bool
                 
         RETURNS:
             Instance of AutoML.
@@ -192,24 +224,28 @@ class AutoML:
 
             # Fit the data.
             >>> automl_obj.fit(admissions_train, "admitted")
-
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-            
-            # Run predict for new test data with best performing model.
-            >>> prediction = automl_obj.predict(admissions_test)
-            >>> prediction
             
-            # Run predict for new test data with second best performing model.
-            >>> prediction = automl_obj.predict(admissions_test, rank=2)
-            >>> prediction 
-
             # Display leaderboard.
             >>> automl_obj.leaderboard()
 
             # Display best performing model.
             >>> automl_obj.leader()
+            
+            # Run predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(admissions_test)
+            >>> prediction
+            
+            # Run predict on test data using second best performing model.
+            >>> prediction = automl_obj.predict(admissions_test, rank=2)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(admissions_test)
+            >>> performance_metrics
+            
+            # Run evaluate to get performance metrics using model rank 3.
+            >>> performance_metrics = automl_obj.evaluate(admissions_test, rank=3)
+            >>> performance_metrics
 
             # Example 2 : Run AutoML for regression problem.
             # Scenario : Predict the price of house based on different factors.
@@ -228,24 +264,28 @@ class AutoML:
             >>>                     custom_config_file="custom_housing.json")
             # Fit the data.
             >>> automl_obj.fit(housing_train, "price")
-
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-            
-            # Run predict for new test data with best performing model.
-            >>> prediction = automl_obj.predict(housing_test)
-            >>> prediction
             
-            # Run predict for new test data with second best performing model.
-            >>> prediction = automl_obj.predict(housing_test, rank=2)
-            >>> prediction 
-
             # Display leaderboard.
             >>> automl_obj.leaderboard()
   
             # Display best performing model.
             >>> automl_obj.leader()
+            
+            # Run predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(housing_test)
+            >>> prediction
+            
+            # Run predict on test data using second best performing model.
+            >>> prediction = automl_obj.predict(housing_test, rank=2)
+            >>> prediction
+
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(housing_test)
+            >>> performance_metrics
+            
+            # Run evaluate to get performance metrics using second best performing model.
+            >>> performance_metrics = automl_obj.evaluate(housing_test, rank=2)
+            >>> performance_metrics
 
             # Example 3 : Run AutoML for multiclass classification problem.
             # Scenario : Predict the species of iris flower based on different
@@ -253,6 +293,11 @@ class AutoML:
             #            different processes of AutoML Run to get the best
             #            performing model out of available models.
             
+            # Split the data into train and test.
+            >>> iris_sample = iris_input.sample(frac = [0.8, 0.2])
+            >>> iris_train= iris_sample[iris_sample['sampleid'] == 1].drop('sampleid', axis=1)
+            >>> iris_test = iris_sample[iris_sample['sampleid'] == 2].drop('sampleid', axis=1)
+            
             # Generate custom JSON file
             >>> AutoML.generate_custom_config()
 
@@ -260,22 +305,23 @@ class AutoML:
             >>> automl_obj = AutoML(verbose=2, 
             >>>                     exclude="xgboost",
             >>>                     custom_config_file="custom.json")
+            
             # Fit the data.
-            >>> automl_obj.fit(iris_input, iris_input.species)
- 
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-
-            # Run predict with second best performing model.
-            >>> prediction = automl_obj.predict(rank=2)
-            >>> prediction
+            >>> automl_obj.fit(iris_train, iris_train.species)
 
             # Display leaderboard.
             >>> automl_obj.leaderboard()
  
             # Display best performing model.
             >>> automl_obj.leader()
+
+            # Run predict on test data using second best performing model.
+            >>> prediction = automl_obj.predict(iris_test, rank=2)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(iris_test)
+            >>> performance_metrics
  
             # Example 4 : Run AutoML for regression problem with early stopping metric and tolerance.
             # Scenario : Predict the price of house based on different factors. 
@@ -296,39 +342,57 @@ class AutoML:
             >>>                     custom_config_file="custom_housing.json")
             # Fit the data.
             >>> automl_obj.fit(housing_train, "price")
- 
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-
+            
             # Display leaderboard.
             >>> automl_obj.leaderboard()
+ 
+            # Run predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(housing_test)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(housing_test)
+            >>> performance_metrics
 
             # Example 5 : Run AutoML for regression problem with maximum runtime.
             # Scenario : Predict the species of iris flower based on different factors.
             #            Run AutoML to get the best performing model in specified time.
 
+            # Split the data into train and test.
+            >>> iris_sample = iris_input.sample(frac = [0.8, 0.2])
+            >>> iris_train= iris_sample[iris_sample['sampleid'] == 1].drop('sampleid', axis=1)
+            >>> iris_test = iris_sample[iris_sample['sampleid'] == 2].drop('sampleid', axis=1)
+            
             # Create instance of AutoML.
             >>> automl_obj = AutoML(verbose=2, 
             >>>                     exclude="xgboost",
             >>>                     max_runtime_secs=500,
             >>>                     max_models=3)
+            
             # Fit the data.
-            >>> automl_obj.fit(iris_input, iris_input.species)
- 
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-
-            # Run predict with second best performing model.
-            >>> prediction = automl_obj.predict(rank=2)
-            >>> prediction
-
+            >>> automl_obj.fit(iris_train, iris_train.species)
+            
             # Display leaderboard.
             >>> automl_obj.leaderboard()
  
             # Display best performing model.
-            >>> automl_obj.leader()     
+            >>> automl_obj.leader()
+ 
+            # Run predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(iris_test)
+            >>> prediction
+
+            # Run predict on test data using second best performing model.
+            >>> prediction = automl_obj.predict(iris_test, rank=2)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(iris_test)
+            >>> performance_metrics
+            
+            # Run evaluate to get performance metrics using model rank 4.
+            >>> performance_metrics = automl_obj.evaluate(iris_test, 4)
+            >>> performance_metrics  
         """
         # Appending arguments to list for validation
         arg_info_matrix = []
@@ -339,9 +403,9 @@ class AutoML:
                                                                               "decision_forest", "xgboost"]])
         arg_info_matrix.append(["verbose", verbose, True, (int), True, [0,1,2]])
         arg_info_matrix.append(["max_runtime_secs", max_runtime_secs, True, (int, float)])
-        arg_info_matrix.append(["stopping_metric", stopping_metric, True, (str), True, ["R2", 'MAE', 
-                                                                                        'MSE', 'MSLE',
-                                                                                        'RMSE', 'RMSLE',
+        arg_info_matrix.append(["stopping_metric", stopping_metric, True, (str), True, ["R2", "MAE", "MSE", "MSLE",
+                                                                                        "MAPE", "MPE", "RMSE", "RMSLE",
+                                                                                        "ME", "EV", "MPD", "MGD",
                                                                                         'MICRO-F1','MACRO-F1',
                                                                                         'MICRO-RECALL','MACRO-RECALL',
                                                                                         'MICRO-PRECISION', 'MACRO-PRECISION',
@@ -350,13 +414,21 @@ class AutoML:
         arg_info_matrix.append(["stopping_tolerance", stopping_tolerance, True, (float, int)])
         arg_info_matrix.append(["max_models", max_models, True, (int)])
         arg_info_matrix.append(["custom_config_file", custom_config_file, True, (str), True])
-        
+
+        volatile = kwargs.get('volatile', False)
+        persist = kwargs.get('persist', False)
+
+        arg_info_matrix.append(["volatile", volatile, True, (bool)])
+        arg_info_matrix.append(["persist", persist, True, (bool)])
 
         # Validate argument types
         _Validators._validate_function_arguments(arg_info_matrix)
         # Either include or exclude can be used.
         if include is not None or exclude is not None:
             _Validators._validate_mutually_exclusive_arguments(include, "include", exclude, "exclude")
+        # Either volatile or persist can be used.
+        if volatile and persist:
+            _Validators._validate_mutually_exclusive_arguments(volatile, "volatlie", persist, "persist")
         # Validate mutually inclusive arguments
         _Validators._validate_mutually_inclusive_arguments(stopping_metric, "stopping_metric", stopping_tolerance, "stopping_tolerance")
         # Validate lower range for max_models
@@ -391,6 +463,9 @@ class AutoML:
         self.model_list = ['decision_forest', 'xgboost', 'knn', 'svm', 'glm']
         self.is_classification_type = lambda: self.task_type.upper() == 'CLASSIFICATION'
         self._is_fit_called = False 
+        self._is_load_model_called = False
+        self.kwargs = kwargs
+        self.table_name_mapping={}
         
     @collect_queryband(queryband="AutoML_fit")    
     def fit(self,
@@ -489,7 +564,9 @@ class AutoML:
                 _Validators._validate_permitted_values(self.stopping_metric, permitted_values, "stopping_metric")
         else:
             if self.stopping_metric is not None:
-                permitted_values = ["R2", 'MAE', 'MSE', 'MSLE','RMSE', 'RMSLE']
+                permitted_values = ["R2", "MAE", "MSE", "MSLE",
+                                    "MAPE", "MPE", "RMSE", "RMSLE",
+                                    "ME", "EV", "MPD", "MGD"]
                 _Validators._validate_permitted_values(self.stopping_metric, permitted_values, "stopping_metric")
 
         if not self.is_classification_type():
@@ -514,40 +591,39 @@ class AutoML:
         clf = task_cls(self.data, self.target_column, self.custom_data)
         
         self.model_info, self.leader_board, self.target_count, self.target_label, \
-            self.data_transformation_params, self.table_name_mapping = getattr(clf, cls_method)(    
-                                                                    model_list = self.model_list,
-                                                                    auto = self.auto,
-                                                                    verbose = self.verbose,
-                                                                    max_runtime_secs = self.max_runtime_secs, 
-                                                                    stopping_metric = self.stopping_metric, 
-                                                                    stopping_tolerance = self.stopping_tolerance,
-                                                                    max_models = self.max_models)
+            self.data_transformation_params, self.table_name_mapping = getattr(clf, cls_method)(
+                                                                       model_list = self.model_list,
+                                                                       auto = self.auto,
+                                                                       verbose = self.verbose,
+                                                                       max_runtime_secs = self.max_runtime_secs, 
+                                                                       stopping_metric = self.stopping_metric, 
+                                                                       stopping_tolerance = self.stopping_tolerance,
+                                                                       max_models = self.max_models,
+                                                                       **self.kwargs)
 
         # Model Evaluation Phase
         self.m_evaluator = _ModelEvaluator(self.model_info, 
                                            self.target_column,
                                            self.task_type)
       
-    @collect_queryband(queryband="AutoML_predict")  
+    @collect_queryband(queryband="AutoML_predict")
     def predict(self,
-                data = None,
-                rank = 1):
+                data,
+                rank = 1,
+                use_loaded_models = False):
         """
         DESCRIPTION:
-            Function generates prediction on either default test data or any other data 
-            using model rank in leaderboard and displays performance metrics 
-            of the specified model.
-            
-            If test data contains target column, then it displays both prediction 
-            and performance metrics, otherwise displays only prediction.
+            Function generates prediction on data using model rank in 
+            leaderboard.
+            Note:
+                * If both fit and load method are called before predict, then fit method model will be used
+                  for prediction by default unless 'use_loaded_models' is set to True in predict.
 
         PARAMETERS:
             data:
-                Optional Argument.
-                Specifies the dataset on which prediction and performance
-                metrices needs to be generated using model rank in leaderboard.
-                When "data" is not specified default test data is used. Default 
-                test data is the dataset generated at the time of training.
+                Required Argument.
+                Specifies the dataset on which prediction needs to be generated 
+                using model rank in leaderboard.
                 Types: teradataml DataFrame
 
             rank:
@@ -555,6 +631,12 @@ class AutoML:
                 Specifies the rank of the model in the leaderboard to be used for prediction.
                 Default Value: 1
                 Types: int
+            
+            use_loaded_models:
+                Optional Argument.
+                Specifies whether to use loaded models from database for prediction or not.
+                Default Value: False
+                Types: bool
                 
         RETURNS:
             Pandas DataFrame with predictions.
@@ -568,174 +650,1099 @@ class AutoML:
             # Perform fit() operation on the "automl_obj".
             # Perform predict() operation on the "automl_obj".
             
-            # Example 1: Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-            
-            # Example 2: Run predict with second best performing model.
-            >>> prediction = automl_obj.predict(rank=2)
-            >>> prediction
-            
-            # Example 3: Run predict for new test data with best performing model.
+            # Example 1: Run predict on test data using best performing model.
             >>> prediction = automl_obj.predict(admissions_test)
             >>> prediction
             
-            # Example 4: Run predict for new test data with second best performing model.
+            # Example 2: Run predict on test data using second best performing model.
             >>> prediction = automl_obj.predict(admissions_test, rank=2)
             >>> prediction
+
+            # Example 3: Run predict on test data using loaded model.
+            >>> automl_obj.load("model_table")
+            >>> prediction = automl_obj.predict(admissions_test, rank=3)
+            >>> prediction
+
+            # Example 4: Run predict on test data using loaded model when fit is also called.
+            >>> automl_obj.fit(admissions_train, "admitted")
+            >>> automl_obj.load("model_table")
+            >>> prediction = automl_obj.predict(admissions_test, rank=3, use_loaded_models=True)
+            >>> prediction
         """
-        if not self._is_fit_called:
-            # raise ValueError("fit() method must be called before generating prediction.")
+        # Checking if fit or load model is called before predict, If not raise error
+        if not self._is_fit_called and not self._is_load_model_called:
             err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
                                        "'predict' method", \
-                                       "'fit' method must be called before" \
+                                       "'fit' or 'load' method must be called before" \
                                        " running predict.")
             raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+
         # Appending predict arguments to list for validation.
         arg_info_pred_matrix = []
-        arg_info_pred_matrix.append(["data", data, True, (DataFrame), True])
+        arg_info_pred_matrix.append(["data", data, False, (DataFrame), True])
         arg_info_pred_matrix.append(["rank", rank, True, (int), True])
+        arg_info_pred_matrix.append(["use_loaded_models", use_loaded_models, True, (bool)])
 
         # Validate argument types
         _Validators._validate_function_arguments(arg_info_pred_matrix)
+
+        # Run predict using loaded model
+        if self._is_load_model_called and (not self._is_fit_called or use_loaded_models):
+            # Validate range for model rank
+            _Validators._validate_argument_range(rank, "rank", lbound=1, 
+                                                 ubound=self.loaded_models_info.RANK.max(),
+                                                 lbound_inclusive=True, ubound_inclusive=True)
+            return self._run_loaded_model(data, rank)
+        
         # Validate range for model rank
         _Validators._validate_argument_range(rank, "rank", lbound=1, 
-                                             ubound=self.leader_board.Rank.max(),
+                                             ubound=self.leader_board.RANK.max(),
                                              lbound_inclusive=True, ubound_inclusive=True)
         
-        # Setting test data indicator to default value, i.e., False.
-        self.test_data_ind = False
-        # Setting target column indicator to default value, i.e., False.
-        self.target_column_ind = False
+        # Setting target column indicator to default value, i.e., True.
+        self.target_column_ind = True
+        # Model Evaluation using rank-1 [rank starts from 0 in leaderboard]
+        rank = rank-1
+
+        # Setting indicator to False if target column doesn't exist
+        if self.target_column not in data.columns:
+            self.target_column_ind = False
+        
+        # Checking if data is already transformed before or not
+        data_node_id = data._nodeid
+        if not self.table_name_mapping.get(data_node_id):
+            # At first data transformation will be performed on raw test data
+            # then evaluation will happen.
+            self.transform_data(data)
+        else:
+            print("\nSkipping data transformation as data is already transformed.")
+    
+        # Generating prediction
+        pred = self.m_evaluator.model_evaluation(rank = rank, 
+                                                 table_name_mapping = self.table_name_mapping,
+                                                 data_node_id = data_node_id,
+                                                 target_column_ind = self.target_column_ind)
+            
+        # Checking if problem type is classification and target label is present.
+        if self.is_classification_type() and self.target_label is not None:
+            # Displaying target column labels
+            tar_dct = {}
+            print('\nTarget Column Mapping:')
+            # Iterating rows
+            for row in self.target_label.result.itertuples():
+                # Retrieving the category names of encoded target column
+                # row[1] contains the orginal name of cateogry
+                # row[2] contains the encoded value
+                if row[1] != 'TD_CATEGORY_COUNT':
+                    tar_dct[row[1]] = row[2]
+                    
+            for key, value in tar_dct.items():
+                print(f"{key}: {value}")
+
+        # Renaming probability column if any
+        prob_lst = [item for item in pred.result.columns if item.startswith('Prob_')]
+        if len(prob_lst) > 0:
+            rename_dict ={}
+            for col in pred.result.columns:
+                if col not in prob_lst:
+                    rename_dict[col] = getattr(pred.result, col)
+                else:
+                    indx = int(col.split('_')[1])
+                    rename_dict[f'prob_{indx}'] = getattr(pred.result, f'Prob_{indx}')
+            rename_dict['drop_columns'] = True
+            pred.result = pred.result.assign(**rename_dict)              
+
+        print("\nPrediction : ")
+        print(pred.result)
+        
+        if self.target_column_ind:
+            prediction_column = 'prediction' if 'prediction' in pred.result.columns else 'Prediction'
+            probability_column = 'prob_1'
+            # Displaying confusion matrix and ROC-AUC for classification problem
+            if self.is_classification_type():
+                print_data = lambda data: print(data) if _is_terminal() else display(data)
+                # Displaying ROC-AUC for binary classification
+                if self.target_count == 2:
+                    fit_params = {
+                        "probability_column" : probability_column,
+                        "observation_column" : self.target_column,
+                        "positive_class" : "1",
+                        "data" : pred.result
+                    }
+                    # Fitting ROC
+                    roc_out = ROC(**fit_params)
+                    print("\nROC-AUC : ")
+                    print_data(roc_out.result)
+                    print_data(roc_out.output_data)
+                
+                # Displaying confusion matrix for binary and multiclass classification
+                prediction_df=pred.result.to_pandas()
+                target_col = self.target_column
+                print("\nConfusion Matrix : ")
+                print_data(confusion_matrix(prediction_df[target_col], prediction_df[prediction_column]))
+                
+        # Returning prediction
+        return pred.result
+    
+    @collect_queryband(queryband="AutoML_evaluate")  
+    def evaluate(self,
+                 data,
+                 rank = 1,
+                 use_loaded_models = False
+                 ):
+        """
+        DESCRIPTION:
+            Function evaluates on data using model rank in leaderboard
+            and generates performance metrics.
+            Note:
+                * If both fit and load method are called before predict, then fit method model will be used
+                  for prediction by default unless 'use_loaded_models' is set to True in predict.
+            
+        PARAMETERS:
+            data:
+                Required Argument.
+                Specifies the dataset on which performance metrics needs to be generated.
+                Types: teradataml DataFrame
+                
+                Note:
+                    * Target column used for generating model is mandatory in "data" for evaluation.
+
+            rank:
+                Optional Argument.
+                Specifies the rank of the model available in the leaderboard to be used for evaluation.
+                Default Value: 1
+                Types: int
+
+            use_loaded_models:
+                Optional Argument.
+                Specifies whether to use loaded models from database for prediction or not.
+                Default Value: False
+                Types: bool
+
+        RETURNS:
+            Pandas DataFrame with performance metrics.
+        
+        RAISES:
+            TeradataMlException.
+        
+        EXAMPLES:
+            # Create an instance of the AutoML called "automl_obj" 
+            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
+            # Perform fit() operation on the "automl_obj".
+            # Perform evaluate() operation on the "automl_obj".
+            
+            # Example 1: Run evaluate on test data using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(admissions_test)
+            >>> performance_metrics
+            
+            # Example 2: Run evaluate on test data using second best performing model.
+            >>> performance_metrics = automl_obj.evaluate(admissions_test, rank=2)
+            >>> performance_metrics
+
+            # Example 3: Run evaluate on test data using loaded model.
+            >>> automl_obj.load("model_table")
+            >>> evaluation = automl_obj.evaluate(admissions_test, rank=3)
+            >>> evaluation
+
+            # Example 4: Run predict on test data using loaded model when fit is also called.
+            >>> automl_obj.fit(admissions_train, "admitted")
+            >>> automl_obj.load("model_table")
+            >>> evaluation = automl_obj.evaluate(admissions_test, rank=3, use_loaded_models=True)
+            >>> evaluation
+        """
+        if not self._is_fit_called and not self._is_load_model_called:
+            # raise ValueError("fit() method must be called before evaluating.")
+            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                       "'evaluate' method", \
+                                       "'fit' or 'load' method must be called before" \
+                                       " running evaluate.")
+            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        # Appending evaluate arguments to list for validation.
+        arg_info_pred_matrix = []
+        arg_info_pred_matrix.append(["data", data, False, (DataFrame), True])
+        arg_info_pred_matrix.append(["rank", rank, True, (int), True])
+        arg_info_pred_matrix.append(["use_loaded_models", use_loaded_models, True, (bool)])
+
+        # Validate argument types
+        _Validators._validate_function_arguments(arg_info_pred_matrix)
+
+        # Run evaluate using loaded model
+        if self._is_load_model_called and (not self._is_fit_called or use_loaded_models):
+            # Validate range for model rank
+            _Validators._validate_argument_range(rank, "rank", lbound=1, 
+                                                 ubound=self.loaded_models_info.RANK.max(),
+                                                 lbound_inclusive=True, ubound_inclusive=True)
+            return self._run_loaded_model(data, rank, output_type="evaluate")
+
+        # Validate range for model rank
+        _Validators._validate_argument_range(rank, "rank", lbound=1, 
+                                             ubound=self.leader_board.RANK.max(),
+                                             lbound_inclusive=True, ubound_inclusive=True)
+
         # Model Evaluation using rank-1 [rank starts from 0 in leaderboard]
         rank = rank-1
+
+        # Raising exception if target column is not present in data
+        # as it is required for evaluation.
+        if self.target_column not in data.columns:
+             raise TeradataMlException(
+                            Messages.get_message(MessageCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE).format(self.target_column),
+                            MessageCodes.TARGET_COL_NOT_FOUND_FOR_EVALUATE)
+        
+        # Checking if data is already transformed before or not
+        data_node_id = data._nodeid
+        if not self.table_name_mapping.get(data_node_id):
+            # At first data transformation will be performed on raw test data
+            # then evaluation will happen.
+            self.transform_data(data)
+        else:
+            print("\nSkipping data transformation as data is already transformed.")
+
+        metrics = self.m_evaluator.model_evaluation(rank = rank,  
+                                                    table_name_mapping=self.table_name_mapping,
+                                                    data_node_id = data_node_id,
+                                                    get_metrics = True)
+
+        # Checking if problem type is classification and target label is present.
+        if self.is_classification_type() and self.target_label is not None:
+            # Displaying target column labels
+            tar_dct = {}
+            print('\nTarget Column Mapping:')
+            # Iterating rows
+            for row in self.target_label.result.itertuples():
+                # Retrieving the category names of encoded target column
+                # row[1] contains the orginal name of cateogry
+                # row[2] contains the encoded value
+                if row[1] != 'TD_CATEGORY_COUNT':
+                    tar_dct[row[1]] = row[2]
+                    
+            for key, value in tar_dct.items():
+                print(f"{key}: {value}")
+        
+        # Showing performance metrics
+        print("\nPerformance Metrics : ")
+        print(metrics.result)
+        if self.is_classification_type():
+            print("-"*80)
+            print(metrics.output_data)
+        
+        # Returning performance metrics
+        return metrics.result
+    
+    def transform_data(self,
+                       data,
+                       data_params = None,
+                       auto = None,
+                       verbose = None,
+                       target_column_ind = None):
+        """
+        DESCRIPTION:
+            Function transforms the data based on the data transformation parameters
+            generated during the fit phase.
+        
+        PARAMETERS:
+            data:
+                Required Argument.
+                Specifies the dataset to be transformed.
+                Types: teradataml DataFrame
+            
+            data_params:
+                Optional Argument.
+                Specifies the data transformation parameters.
+                Default Value: None
+                Types: dict
+            
+            auto:
+                Optional Argument.
+                Specifies whether to AutoML ran in auto or custom mode.
+                Default Value: None
+                Types: bool
+
+            verbose:
+                Optional Argument.
+                Specifies the verbosity level.
+                Default Value: None
+                Types: int
+        
+            target_column_ind:
+                Optional Argument.
+                Specifies whether target column is present in data or not.
+                Default Value: None
+                Types: bool
+
+        RETURNS:
+            None
+        """
+        # Creating instance of DataTransformation
+        data_transform_instance = _DataTransformation(data = data,
+                                                      data_transformation_params=data_params if data_params is not None else \
+                                                                                 self.data_transformation_params,
+                                                      auto=auto if data_params is not None else self.auto,
+                                                      verbose=verbose if verbose is not None else self.verbose,
+                                                      target_column_ind=target_column_ind if target_column_ind is not None else \
+                                                                        self.target_column_ind,
+                                                      table_name_mapping=self.table_name_mapping)
+        
+        # Storing mapping of table names for transformed data
+        self.table_name_mapping = data_transform_instance.data_transformation()
+    
+    @collect_queryband(queryband="AutoML_leaderboard")
+    def leaderboard(self):
+        """
+        DESCRIPTION:
+            Function displays leaderboard.
+
+        RETURNS:
+            Pandas DataFrame with Leaderboard information.
+
+        RAISES:
+            TeradataMlException.
+
+        EXAMPLES:
+            # Create an instance of the AutoML called "automl_obj" 
+            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
+            # Perform fit() operation on the "automl_obj".
+            # Generate leaderboard using leaderboard() method on "automl_obj".
+            >>> automl_obj.leaderboard()
+        """
+        if not self._is_fit_called:
+            # raise ValueError("fit() method must be called before generating leaderboard.")
+            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                       "'leaderboard' method", \
+                                       "'fit' method must be called before" \
+                                       " generating leaderboard.")
+            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        return self.leader_board
+        
+    @collect_queryband(queryband="AutoML_leader")    
+    def leader(self):
+        """
+        DESCRIPTION:
+            Function displays best performing model.
+            
+        RETURNS:
+            None
+
+        RAISES:
+            TeradataMlException.
+
+        EXAMPLES:
+            # Create an instance of the AutoML called "automl_obj" 
+            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
+            # Perform fit() operation on the "automl_obj".
+            # Generate leaderboard using leaderboard() method on "automl_obj".
+            # Display best performing model using leader() method on "automl_obj".
+            >>> automl_obj.leader()   
+        """
+        if not self._is_fit_called:
+            # raise ValueError("fit() method must be called before generating leader.")
+            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                       "'leader' method", \
+                                       "'fit' method must be called before" \
+                                       " generating leader.")
+            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        record = self.leader_board
+        if not _is_terminal():
+            display(record[record['RANK'] == 1])
+        else:
+            print(record[record['RANK'] == 1])
+
+    @collect_queryband(queryband="AutoML_hyperparameter")
+    def model_hyperparameters(self,
+                              rank=1, 
+                              use_loaded_models=False):
+        """
+        DESCRIPTION:
+            Get hyperparameters of the model based on rank in leaderboard.
+            Note:
+                * If both the fit() and load() methods are invoked before calling model_hyperparameters(), 
+                  by default hyperparameters are retrieved from the fit leaderboard. 
+                  To retrieve hyperparameters from the loaded models, set "use_loaded_models" to True in the model_hyperparameters call.
+
+        PARAMETERS:
+            rank:
+                Required Argument.
+                Specifies the rank of the model in the leaderboard.
+                Default Value: 1
+                Types: int
+
+            use_loaded_models:
+                Optional Argument.
+                Specifies whether to use loaded models from database to get hyperparameters or not.
+                Default Value: False
+                Types: bool
+
+        RETURNS:
+            Dictionary, containing hyperparameters.
+
+        RAISES:
+            TeradataMlException.
+
+        EXAMPLES:
+            # Example 1: Get hyperparameters of the model using fit models.
+            # Create an instance of the AutoML called "automl_obj" 
+            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
+            # Perform fit() operation on the "automl_obj".
+            # Get hyperparameters of the model using model_hyperparameters() method on "automl_obj".
+            >>> automl_obj = AutoML(task_type="Classification")
+            >>> automl_obj.fit(admissions_train, "admitted")
+            >>> automl_obj.model_hyperparameters(rank=1)
+
+            # Example 2: Get hyperparameters of the model using loaded models.
+            # Create an instance of the AutoML called "automl_obj"
+            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
+            # Load models from the specified table.
+            # Get hyperparameters of the model using model_hyperparameters() method on "automl_obj".
+            >>> automl_obj = AutoML()
+            >>> automl_obj.load("model_table")
+            >>> automl_obj.model_hyperparameters(rank=1)
+
+            # Example 3: Get hyperparameters of the model when both fit and load method are called.
+            # Create an instance of the AutoML called "automl_obj"
+            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
+            # Fit the data.
+            # Load models from the specified table.
+            # Get hyperparameters of the model using model_hyperparameters() method on "automl_obj".
+            >>> automl_obj = AutoML(task_type="Classification")
+            >>> automl_obj.fit(admissions_train, "admitted")
+            >>> automl_obj.load("model_table")
+
+            # Get hyperparameters of the model using loaded models.
+            >>> automl_obj.model_hyperparameters(rank=1, use_loaded_models=True)
+            # Get hyperparameters of the model using fit models.
+            >>> automl_obj.model_hyperparameters(rank=1)
+        """
+
+        if not self._is_fit_called and not self._is_load_model_called:
+            # raise ValueError("fit() or load() method must be called before getting hyperparameters.")
+            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                       "'model_hyperparameters' method",
+                                       "No models available to get hyperparameters. " \
+                                       "Run 'fit()' or 'load()' methods to get models.")
+            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        
+        arg_info_matrix = []
+        arg_info_matrix.append(["rank", rank, True, (int), True])
+        arg_info_matrix.append(["use_loaded_models", use_loaded_models, True, (bool)])
+
+        # Validate argument types
+        _Validators._validate_function_arguments(arg_info_matrix)
+
+        leaderboard = None
+        if self._is_load_model_called and (not self._is_fit_called or use_loaded_models):
+            leaderboard = self.loaded_models_info
+        else:
+            leaderboard = self.model_info
+
+        # Validate range for model rank from loaded models
+        _Validators._validate_argument_range(rank, "rank", lbound=1, 
+                                             ubound=leaderboard.RANK.max(),
+                                             lbound_inclusive=True, ubound_inclusive=True)
+        hyperparams = leaderboard.loc[leaderboard['RANK'] == rank, 'PARAMETERS'].values[0]
+
+        # Deserializing hyperparameters
+        hyperparams = ast.literal_eval(hyperparams)
+
+        # Removing 'data' from hyperparameters
+        keys_to_remove = ['input_columns', 'data', 'train_data', 'test_data']
+        for key in keys_to_remove:
+            hyperparams.pop(key, None)
+
+        return hyperparams
+    
+    @collect_queryband(queryband="AutoML_load")
+    def load(self,
+             table_name):
+        """
+        DESCRIPTION:
+            Function loads models information from the specified table.
+
+        PARAMETERS:
+            table_name:
+                Required Argument.
+                Specifies the table name from which models are to be loaded.
+                Types: str
+
+        RETURNS:
+            Pandas DataFrame with loaded models information.
+
+        RAISES:
+            TeradataMlException.
+
+        EXAMPLES:
+            # Create an instance of the AutoML called "obj" 
+            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
+            >>> obj = AutoML()
+            # Load models from the specified table.
+            >>> tab = obj.load("model_table")
+        """
+        # Appending arguments to list for validation
+        arg_info_matrix = []
+        arg_info_matrix.append(["table_name", table_name, True, (str), True])
+
+        # Validate argument types
+        _Validators._validate_function_arguments(arg_info_matrix)
+
+        # Loading models
+        self.loaded_models_info = DataFrame(table_name).to_pandas()
+
+        self._load_data_transform_params()
+
+        self._is_load_model_called = True
+
+        return self.loaded_models_info.drop(['RESULT_TABLE', 'PARAMETERS'], axis=1)
+    
+    def _load_data_transform_params(self):
+        """
+        DESCRIPTION:
+            Internal Function loads data transformation parameters from the specified table.
+        """
+        from sklearn.decomposition import PCA
+
+        # Getting data transformation row
+        data_transform_row = self.loaded_models_info[self.loaded_models_info['RANK'] == -1].iloc[0]
+
+        # Removing data transformation row and dropping 'DATA_PARAMS' column
+        # from loaded models info
+        self.loaded_models_info = self.loaded_models_info[self.loaded_models_info['RANK'] != -1]
+        self.loaded_models_info.drop('DATA_PARAMS', axis=1, inplace=True)
+
+        # Loading data transformation parameters by deserializing
+        buffer = BytesIO(data_transform_row['DATA_PARAMS'])
+        data_params = joblib.load(buffer)
+
+        fit_obj_lst = json.loads(data_transform_row['PARAMETERS'])
+
+        # Generating Dataframe from table_names in data params
+        # fit_obj_lst contain : ['one_hot_encoding_fit_obj', 'lasso_scale_fit_obj', 'pca_scale_fit_obj', imputation_fit_object]
+        # Iterating over fit_obj_lst and converting table names to DataFrame
+        for fit_obj_name in fit_obj_lst:
+            if isinstance(data_params[fit_obj_name], dict):
+                for key, val in data_params[fit_obj_name].items():
+                    # Key: automl transformation step name, val: table name
+                    data_params[fit_obj_name][key] = DataFrame(f'{val}')
+            else:
+                data_params[fit_obj_name] = DataFrame(f'{data_params[fit_obj_name]}')
+        
+        # Manually deserializing and reconstructing PCA object
+        load_pca_info = data_params['pca_fit_instance']
+        pca = PCA(n_components=load_pca_info['n_components'], random_state=42)
+        pca.components_ = np.array(load_pca_info['components'])
+        pca.explained_variance_ = np.array(load_pca_info['explained_variance'])
+        pca.explained_variance_ratio_ = np.array(load_pca_info['explained_variance_ratio'])
+        pca.mean_ = np.array(load_pca_info['mean'])
+        pca.n_components_ = load_pca_info['n_components']
+        pca.noise_variance_ = load_pca_info['noise_variance']
+        pca.singular_values_ = np.array(load_pca_info['singular_values'])
+
+        data_params['pca_fit_instance'] = pca
+
+        self.loaded_data_transformation_params = data_params
+    
+    def _validate_ranks(self, ranks):
+        """
+        DESCRIPTION:
+            Function validates the ranks argument.
+
+        PARAMETERS:
+            ranks:
+                Required Argument.
+                Specifies the ranks for the models to be saved.
+                Types: int or list of int
+
+        RAISES:
+            TeradataMlException.
+        """
+        start_rank, end_rank = ranks.start, ranks.stop
+
+        # Check if both parts are non-negative integers
+        if not (start_rank > 0 and end_rank > 0):
+            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                       "'deploy' method", \
+                                       "Provided start and end rank in 'ranks' "\
+                                       "must be positive non-zero integers.")
+            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+
+        # Check if start_rank is less than or equal to end_rank
+        if start_rank > end_rank:
+            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                       "'deploy' method", \
+                                       "Provided start rank in 'ranks' must be less than"\
+                                       " or equal to end rank in 'ranks'.")
+            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        
+        # check end rank is less than or equal to total models
+        if end_rank > self.leader_board.RANK.max():
+            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                       "'deploy' method", \
+                                       "Provided end rank in 'ranks' must be less than"\
+                                       " or equal to total models available.")
+            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        
+        return start_rank, end_rank
+    
+    @collect_queryband(queryband="AutoML_deploy")
+    def deploy(self,
+               table_name,
+               top_n = 3,
+               ranks = None
+               ):
+        """
+        DESCRIPTION:
+            Function saves models to the specified table name.
+            Note:
+                * If 'ranks' is provided, specified models in 'ranks' will be saved
+                  and ranks will be reassigned to specified models based
+                  on the order of the leaderboard, non-specified models will be ignored.
+            
+        PARAMETERS:
+            table_name:
+                Required Argument.
+                Specifies the table name to which models information is to be saved.
+                Types: str
+
+            top_n:
+                Optional Argument.
+                Specifies the top n models to be saved.
+                Note:
+                    * If 'ranks' is not provided, the function saves the top 'top_n' models.
+
+                Default Value: 3
+                Types: int
+            
+            ranks:
+                Optional Argument.
+                Specifies the ranks for the models to be saved.
+                Note:
+                    * If 'ranks' is provided, then 'top_n' is ignored.
+                Types: int or list of int or range object
+        
+        RETURNS:
+            None
+
+        RAISES:
+            TeradataMlException.
+        
+        EXAMPLES:
+            # Create an instance of the AutoML called "obj" 
+            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
+            >>> obj = AutoML(task_type="Classification")
+            >>> obj.fit(data = data, target_column = target_column)
+
+            # Save top 3 models to the specified table.
+            >>> obj.deploy("model_table")
+
+            # Save top n models to the specified table.
+            >>> obj.deploy("model_table", top_n=5)
+
+            # Save models based on specified ranks to the specified table.
+            >>> obj.deploy("model_table", ranks=[1, 3, 5])
+
+            # Save models based on specified rank range to the specified table.
+            >>> obj.deploy("model_table", ranks=range(2,6))
+        """ 
+        # raise Error if fit is not called
+        if not self._is_fit_called:
+            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                    "'deploy' method", \
+                                    "'fit' method must be called before" \
+                                    " 'deploy'.")
+            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+
+        # Appending arguments to list for validation
+        arg_info_matrix = []
+        arg_info_matrix.append(["table_name", table_name, True, (str), True])
+        arg_info_matrix.append(["top_n", top_n, True, (int)])
+        if not isinstance(ranks, range):
+            arg_info_matrix.append(["ranks", ranks, True, (int, list)])
+
+        # Validate argument types
+        _Validators._validate_function_arguments(arg_info_matrix)
+
+        if isinstance(ranks, int):
+            ranks = [ranks]
+        elif isinstance(ranks, range):
+            start_rank, end_rank = self._validate_ranks(ranks)
+
+        if ranks is None or len(ranks) == 0:
+            # If total models are greater than available models or less than 1
+            try:
+                _Validators._validate_argument_range(top_n, "top_n", lbound=1, 
+                                                     ubound=self.leader_board.RANK.max(),
+                                                     lbound_inclusive=True, ubound_inclusive=True)
+            except ValueError as e:
+                msg = "\n'top_n' should be equal or less than the available models or greater than 0. " \
+                      "Deploying all available models to the table."
+                warnings.warn(message=msg, stacklevel=2)
+                top_n = self.leader_board.shape[0]
+        elif isinstance(ranks, list):
+            # If ranks is provided, then validating the ranks elements
+            for ele in ranks:
+                _Validators._validate_argument_range(ele, "element in ranks", lbound=1, 
+                                                     ubound=self.leader_board.RANK.max(),
+                                                     lbound_inclusive=True, ubound_inclusive=True)
+
+        feature_selections = self.model_info['FEATURE_SELECTION'].unique().tolist()
+
+        # Mapping feature selection to training data, 
+        # we are creating a dictionary with key as feature selection and
+        # value as temporary training data table name, so that we can copy
+        # temporary training data to permanent table.
+        # Here's an example of mapping:
+        # Example: {'lasso': 'ml__survived_lasso_1717475362789542',
+        #           'rfe': 'ml__survived_rfe_1717474570567062',
+        #           'pca': 'ml__survived_pca_1717475375119752'}
+        fs_to_data_dict ={fs:self.model_info.loc[self.model_info['FEATURE_SELECTION'] == fs, \
+                                                'DATA_TABLE'].iloc[0] for fs in feature_selections}
+
+        # Saving temporary training data to permanent table
+        # We are replacing DATA_TABLE with permanent table name in model_info
+        for key, val in fs_to_data_dict.items():
+            per_name = self._create_per_result_table(prefix='{}_{}'.format(self.target_column, key),
+                                                     persist_result_table=val)
+            fs_to_data_dict[key] = per_name
+
+        # Persist flag
+        persist = self.kwargs.get('persist', False)
+        # If ranks is provided, then saving models based on specified rank
+        # in list will be prioritized over 'top_n'.
+        if ranks is None or len(ranks) == 0:
+            # Saving only top 'top_n' models
+            for index, row in self.model_info.iterrows():
+                if index < top_n:
+                    self.model_info.loc[index, 'DATA_TABLE'] = fs_to_data_dict[row['FEATURE_SELECTION']]
+                    if not persist:
+                        per_name = self._create_per_result_table(prefix='{}_{}'.format(self.target_column, row['MODEL_ID']),
+                                                                 persist_result_table=row['RESULT_TABLE'])
+                        self.model_info.loc[index, 'RESULT_TABLE'] = per_name
+                else:
+                    break
+            sv_models = self.model_info.drop('model-obj', axis=1).head(top_n)
+        else:
+            if isinstance(ranks, range):
+                # Saving models based on start and end rank.
+                sv_models = self.model_info[start_rank-1:end_rank].copy()
+            else:
+                # Saving models based on specified rank in list
+                sv_models = self.model_info[self.model_info['RANK'].isin(ranks)].copy()
+            sv_models.drop('model-obj', axis=1, inplace=True)
+            sv_models.reset_index(drop=True, inplace=True)
+
+            for index, row in sv_models.iterrows():
+                sv_models.loc[index, 'RANK'] = index + 1
+                sv_models.loc[index, 'DATA_TABLE'] = fs_to_data_dict[row['FEATURE_SELECTION']]
+                if not persist:
+                    per_name = self._create_per_result_table(prefix='{}_{}'.format(self.target_column, row['MODEL_ID']),
+                                                             persist_result_table=row['RESULT_TABLE'])
+                    sv_models.loc[index, 'RESULT_TABLE'] = per_name  
+        
+        # Data Transformation Parameters
+        df = self._deploy_data_transformation_params()
+
+        # Saving data transformation parameters to the specified table
+        sv_models = pd.concat([sv_models, df], ignore_index=True, sort=False)
+
+        copy_to_sql(df = sv_models, table_name=table_name, if_exists='replace', types={'DATA_PARAMS':BLOB})
+
+        print('Model Deployment Completed Successfully.')
+
+    def _create_per_result_table(self, prefix, persist_result_table):
+        """
+        DESCRIPTION:
+            Internal Function creates permanent table for the specified result table.
+
+        PARAMETERS:
+            prefix:
+                Required Argument.
+                Specifies the prefix for the permanent table name.
+                Types: str
+
+            persist_result_table:
+                Required Argument.
+                Specifies the result table name.
+                Types: str
+
+        RETURNS:
+            Permanent table name.
+            
+        RAISES:
+            TeradataMlException.
+        """
+
+        table_name = UtilFuncs._generate_temp_table_name(prefix=prefix,
+                                                       table_type=TeradataConstants.TERADATA_TABLE,
+                                                       gc_on_quit=False)
+        qry = f"SELECT * FROM {persist_result_table}"
+        UtilFuncs._create_table(table_name=table_name, 
+                                query=qry,
+                                volatile=False)
+        return table_name
+
+
+    def _deploy_data_transformation_params(self):
+        """
+        DESCRIPTION:
+            Internal Function converts data transformation parameters dictonary (information of each step of automl) 
+            to DataFrame with rank as -1 and return the DataFrame that can be concatenated with model_info DataFrame
+            and saved to the user specified table in database.
         
-        # Checking if there is test data provided or not.
-        # If no, then model will generate predicion on default test data.
-        # If yes, then at first data transformation will happen then prediction will be generated.
-        if data is None:
-            metrics, pred = self.m_evaluator.model_evaluation(rank = rank,
-                                                              table_name_mapping=self.table_name_mapping)
-        else:
-            # Setting test data indicator to True
-            self.test_data_ind = True
-            # Setting indicator to True if target column exists
-            if self.target_column in data.columns:
-                self.target_column_ind = True
+        PARAMETERS:
+            None
+
+        RETURNS:
+            None
+
+        RAISES:
+            TeradataMlException.
+        """
+        # Create a new dictionary to store the deep copy
+        data_params = {}
+
+        # Define a recursive function to deep copy dictionaries
+        def deep_copy_dict(d):
+            if not isinstance(d, dict):
+                return d  # Base case: if it's not a dictionary, return the value directly
+            return {k: deep_copy_dict(v) for k, v in d.items()}  # Recursively copy each item
         
-            # Data Transformation Phase
-            data_transform_instance = _DataTransformation(data = data,
-                                                          data_transformation_params = \
-                                                          self.data_transformation_params,
-                                                          auto = self.auto,
-                                                          verbose = self.verbose,
-                                                          target_column_ind = self.target_column_ind,
-                                                          table_name_mapping=self.table_name_mapping)
-            
-            self.table_name_mapping = data_transform_instance.data_transformation()
-            
-            # Checking for target column presence in passed test data.
-            # If present, then both prediction and evaluation metrics will be generated.
-            # If not present, then only prediction will be generated.
-            if self.target_column_ind:
-                metrics, pred = self.m_evaluator.model_evaluation(rank = rank, 
-                                                                  test_data_ind = \
-                                                                  self.test_data_ind, 
-                                                                  target_column_ind = \
-                                                                  self.target_column_ind,
-                                                                  table_name_mapping=self.table_name_mapping)
+        # Deep copy is needed as the original dictionary contains nested dictionaries 
+        # and we want to avoid modifying the original dictionary when changes are made.
+        # The .copy() method creates a shallow copy, which does not suffice for nested dictionaries.
+        # Iterate through the original dictionary to handle deep copying.
+        for key, value in self.data_transformation_params.items():
+            # Check if value is a dictionary
+            if isinstance(value, dict):
+                # If the value is a dictionary, create a deep copy of the dictionary
+                # This ensures that nested dictionaries are also copied, not just referenced.
+                data_params[key] = deep_copy_dict(value)
             else:
-                pred = self.m_evaluator.model_evaluation(rank = rank,
-                                                         test_data_ind = \
-                                                         self.test_data_ind,
-                                                         table_name_mapping=self.table_name_mapping)
-        # Checking if problem type is classification and target label is present.
-        if self.is_classification_type() and self.target_label is not None:
-            # Displaying target column labels
-            tar_dct = {}
-            print('\nTarget Column Mapping:')
-            # Iterating rows
-            for row in self.target_label.result.itertuples():
-                # Retrieving the category names of encoded target column
-                # row[1] contains the orginal name of cateogry
-                # row[2] contains the encoded value
-                if row[1] != 'TD_CATEGORY_COUNT':
-                    tar_dct[row[1]] = row[2]
-                    
-            for key, value in tar_dct.items():
-                print(f"{key}: {value}")
-            
-        print("\nPrediction : ")
-        print(pred.result)
+                # If the value is not a dictionary, perform a shallow copy (direct assignment)
+                data_params[key] = value
+
+        # Names of fit objects that contain the table names
+        # pointing to tables in the database.
+        fit_obj_names = []
+
+        # Persist flag
+        persist = self.kwargs.get('persist', False)
+
+        data_params['auto_mode'] = False if self.custom_data is not None else True
+
+        # Iterating over data transformation parameters
+        # aml_step_name is the name of transformation step taken and val is the value
+        for aml_step_name,val in data_params.items():
+            # Checking if value is of type teradataml DataFrame
+            # If yes, then creating permanent table for the same
+            # and storing the table_name in data_params instead of dataframe.
+            if isinstance(val, DataFrame):
+                fit_obj_names.append(aml_step_name)
+                if persist:
+                    data_params[aml_step_name] = val._table_name
+                else:
+                    per_name = self._create_per_result_table(prefix='{}'.format(aml_step_name),
+                                                             persist_result_table= val._table_name)
+                    data_params[aml_step_name] = per_name
+            elif isinstance(val, dict) and 'fit_obj' in aml_step_name:
+                for key, val in val.items():
+                    if isinstance(val, DataFrame):
+                        fit_obj_names.append(aml_step_name)
+                        if persist:
+                            data_params[aml_step_name][key] = val._table_name
+                        else:
+                            per_name = self._create_per_result_table(prefix='{}'.format(key),
+                                                                     persist_result_table= val._table_name)
+                            data_params[aml_step_name][key] = per_name
+            elif aml_step_name == 'pca_fit_instance':
+                # Serializing PCA object
+                pca = data_params[aml_step_name]
+                # Extract pca parameters
+                pca_params = {
+                    'n_components': pca.n_components_,
+                    'components': pca.components_.tolist(),
+                    'explained_variance': pca.explained_variance_.tolist(),
+                    'explained_variance_ratio': pca.explained_variance_ratio_.tolist(),
+                    'mean': pca.mean_.tolist(),
+                    'singular_values': pca.singular_values_.tolist(),
+                    'noise_variance': pca.noise_variance_
+                }
+                data_params[aml_step_name] = pca_params
         
-        # Showing performance metrics if there is no test data
-        # Or if target column is present in test data.
-        if not self.test_data_ind or self.target_column_ind:
-            print("\nPerformance Metrics : ")
-            print(metrics.result)
+        # Serializing data transformation parameters
+        buffer = BytesIO()
+        joblib.dump(data_params, buffer)
+        buffer.seek(0)
+        serialized_data = buffer.getvalue()
+
+        # Creating a string representation of fit object names
+        param = json.dumps(fit_obj_names)
+
+        # Creating a DataFrame of data transformation information
+        row = {
+            'RANK':-1,
+            'PARAMETERS':param,
+            'DATA_PARAMS':serialized_data,
+        }
+        df = pd.DataFrame([row])
+
+        return df
         
-            prediction_column = 'prediction' if 'prediction' in pred.result.columns else 'Prediction'
-
-            # Displaying confusion matrix and ROC-AUC for classification problem
-            if self.is_classification_type():
-                print_data = lambda data: print(data) if _is_terminal() else display(data)
-                # Displaying ROC-AUC for binary classification
-                if self.target_count == 2:
-                    fit_params = {
-                        "probability_column" : prediction_column,
-                        "observation_column" : self.target_column,
-                        "positive_class" : "1",
-                        "data" : pred.result
-                    }
-                    # Fitting ROC
-                    roc_out = ROC(**fit_params)
-                    print("\nROC-AUC : ")
-                    print_data(roc_out.result)
-                    print_data(roc_out.output_data)
-                
-                # Displaying confusion matrix for binary and multiclass classification
-                prediction_df=pred.result.to_pandas()
-                target_col = self.target_column
-                print("\nConfusion Matrix : ")
-                print_data(confusion_matrix(prediction_df[target_col], prediction_df[prediction_column]))
-                
-        # Returning prediction
-        return pred.result    
-    
-    @collect_queryband(queryband="AutoML_leaderboard")
-    def leaderboard(self):
+    def _run_loaded_model(self,
+                          test_data,
+                          rank=1,
+                          output_type='prediction'):
         """
         DESCRIPTION:
-            Function displays leaderboard.
+            Internal Function generates prediction and performance metrics using the specified model rank
+            in the loaded models leaderboard.
+
+        PARAMETERS:
+            test_data:
+                Required Argument.
+                Specifies the test data on which prediction and performance metrics needs to be generated.
+                Types: teradataml DataFrame
+
+            rank:
+                Optional Argument.
+                Specifies the rank of the model in the leaderboard to be used for prediction.
+                Default Value: 1
+                Types: int
+            
+            output_type:
+                Optional Argument.
+                Specifies the type of output to be generated.
+                Default Value: 'prediction'
+                Types: str
+                Permitted Values: 'prediction', 'metrics'
 
         RETURNS:
-            Pandas DataFrame with Leaderboard information.
+            Tuple containing prediction and performance metrics.
 
         RAISES:
             TeradataMlException.
 
-        EXAMPLES:
-            # Create an instance of the AutoML called "automl_obj" 
-            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
-            # Perform fit() operation on the "automl_obj".
-            # Generate leaderboard using leaderboard() method on "automl_obj".
-            >>> automl_obj.leaderboard()
         """
-        if not self._is_fit_called:
-            # raise ValueError("fit() method must be called before generating leaderboard.")
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'leaderboard' method", \
-                                       "'fit' method must be called before" \
-                                       " generating leaderboard.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
-        return self.leader_board
+        # Indexing starts from 0
+        rank = rank - 1
+        # Extracting parameters
+        parameters = ast.literal_eval(self.loaded_models_info.loc[rank, 'PARAMETERS'])
+        # Model name
+        model_name = self.loaded_models_info.loc[rank, 'MODEL_ID'].split('_')[0]
+        # Feature selection
+        fs = self.loaded_models_info.loc[rank, 'FEATURE_SELECTION']
         
-    @collect_queryband(queryband="AutoML_leader")    
-    def leader(self):
+        # Checking task type
+        if 'R2' in self.loaded_models_info.columns:
+            task_type='Regression'
+        else:
+            task_type='Classification'
+
+        # Model names mapping to Analytic Functions
+        func_map = {
+            'XGBOOST': lambda params: XGBoost(**params),
+            'GLM': lambda params: GLM(**params),
+            'SVM': lambda params: SVM(**params),
+            'DECISIONFOREST': lambda params: DecisionForest(**params),
+            'KNN': lambda params: KNN(**params)
+        }
+
+        if output_type == 'prediction':
+            print('Generating prediction using:')
+        else:
+            print('Generating performance metrics using:')
+        print(f"Model Name: {model_name}")
+        print(f"Feature Selection: {fs}")
+
+        # Generating evaluation parameters
+        eval_params = _ModelTraining._eval_params_generation(model_name,
+                                                             parameters['response_column'],
+                                                             task_type)
+        if task_type == 'Classification':
+            eval_params['output_responses'] = parameters['output_responses']
+        
+        # Checking if response column is present in test data
+        if parameters['response_column'] not in test_data.columns:
+            # Checking if output type is evaluation
+            if output_type == 'evaluation':
+                # Response column is rqeuired for evaluation, raise error if not present
+                raise ValueError(f"Response column '{parameters['response_column']}' is not present in test data for evaluation.")
+            eval_params.pop('accumulate', None)
+            reponse_col_present = False
+        else:
+            reponse_col_present = True
+
+        # Checking if data is already transformed before or not
+        data_node_id = test_data._nodeid
+        if not self.table_name_mapping.get(data_node_id):
+            # Data transformation will be performed on raw test data
+            self.transform_data(data=test_data, 
+                                data_params=self.loaded_data_transformation_params,
+                                auto=self.loaded_data_transformation_params['auto_mode'],
+                                verbose=0, 
+                                target_column_ind=reponse_col_present)
+
+        # Extracting test data
+        for feature_selection, table_name in self.table_name_mapping[data_node_id].items():
+            if fs in feature_selection:
+                test_data = DataFrame(table_name)
+                break
+        
+        if model_name == 'KNN':
+            train_data = DataFrame(self.loaded_models_info.loc[rank, 'DATA_TABLE'])
+            
+            parameters['train_data'] = train_data
+            parameters['test_data'] = test_data
+            
+            if parameters['response_column'] in test_data.columns:
+                parameters['accumulate'] = parameters['response_column']
+
+            knn = func_map[model_name](parameters)
+  
+            # Checking if response column is present in test data
+            if reponse_col_present and output_type != 'prediction':
+                metrics = knn.evaluate(test_data=test_data, **eval_params)
+            else:
+                predictions = knn.result
+        else:
+            # Extracting result table name
+            result_table_name = self.loaded_models_info.loc[rank, 'RESULT_TABLE']
+            result_table = DataFrame(result_table_name)
+            params = {
+                "skip_input_arg_processing":True,
+                "skip_output_arg_processing":True,
+                "skip_other_arg_processing":True,
+                "skip_func_output_processing":True,
+                "_result_data":result_table,
+                "response_column": parameters['response_column']
+            }
+            model = func_map[model_name](params)
+            # Checking if response column is present in test data
+            if reponse_col_present and output_type != 'prediction':
+                metrics = model.evaluate(newdata=test_data, **eval_params)
+            else:
+                predictions = model.predict(newdata=test_data, **eval_params)
+        
+        # Return prediction and metrics, when output type is metrics
+        if reponse_col_present and output_type != 'prediction':
+            return metrics
+        
+        # Return prediction, when output type is prediction
+        return predictions if model_name == 'KNN' else predictions.result
+
+    @collect_queryband(queryband="AutoML_remove_saved_models")
+    def remove_saved_models(self,
+                            table_name):
         """
         DESCRIPTION:
-            Function displays best performing model.
-            
+            Function removes the specified table containing saved models.
+            Note:
+                * If any data table result table is not present inside the database, 
+                  then it will be skipped.
+        
+        PARAMETERS:
+            table_name:
+                Required Argument.
+                Specifies the table name containing saved models.
+                Types: str
+
         RETURNS:
             None
 
@@ -743,25 +1750,48 @@ class AutoML:
             TeradataMlException.
 
         EXAMPLES:
-            # Create an instance of the AutoML called "automl_obj" 
+            # Create an instance of the AutoML called "obj" 
             # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
-            # Perform fit() operation on the "automl_obj".
-            # Generate leaderboard using leaderboard() method on "automl_obj".
-            # Display best performing model using leader() method on "automl_obj".
-            >>> automl_obj.leader()   
+            >>> obj = AutoML()
+            # Remove saved models from the specified table.
+            >>> obj.remove_saved_models("model_table")
         """
-        if not self._is_fit_called:
-            # raise ValueError("fit() method must be called before generating leader.")
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'leader' method", \
-                                       "'fit' method must be called before" \
-                                       " generating leader.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
-        record = self.leader_board
-        if not _is_terminal():
-            display(record[record['Rank'] == 1])
-        else:
-            print(record[record['Rank'] == 1])
+        # Appending arguments to list for validation
+        arg_info_matrix = []
+        arg_info_matrix.append(["table_name", table_name, True, (str), True])
+
+        # Validate argument types
+        _Validators._validate_function_arguments(arg_info_matrix)
+
+        df = DataFrame(table_name).to_pandas()
+
+        drop_list = df['DATA_TABLE'].dropna().unique().tolist()
+        drop_list.extend(df['RESULT_TABLE'].dropna().unique().tolist())
+
+        # Removing data transformation parameters tables
+        data=df[df['RANK'] == -1].iloc[0]
+        buffer = BytesIO(data['DATA_PARAMS'])
+        data_params = joblib.load(buffer)
+        fit_obj_lst = json.loads(data['PARAMETERS'])
+        for i in fit_obj_lst:
+            if isinstance(data_params[i], dict):
+                drop_list.extend(data_params[i].values())
+            else:
+                drop_list.append(data_params[i])
+            
+        non_existent_tables = []
+        for table in drop_list:
+            try:
+                execute_sql(f"DROP TABLE {table};")
+            except Exception as e:
+                non_existent_tables.append(table)
+                continue
+        
+        if len(non_existent_tables) > 0:
+            warnings.warn(message=f"\nThe following tables '{non_existent_tables}' do not exist in the database and have been skipped.",
+                          stacklevel=2)
+
+        db_drop_table(table_name)
     
     @staticmethod
     def generate_custom_config(file_name = "custom"):
@@ -853,7 +1883,8 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                     max_runtime_secs = None,
                     stopping_metric = None, 
                     stopping_tolerance = None,
-                    max_models = None):
+                    max_models = None,
+                    **kwargs):
         """
         DESCRIPTION:
             Interal Function runs Regression.
@@ -895,6 +1926,25 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                 Specifies the maximum number of models to be trained.
                 Types: int
         
+            volatile:
+                Optional Argument.
+                Specifies whether to put the results of the
+                function in a volatile table or not. When set to
+                True, results are stored in a volatile table,
+                otherwise not.
+                Default Value: False
+                Types: bool
+
+            persist:
+                Optional Argument.
+                Specifies whether to persist the results of the
+                function in a table or not. When set to True,
+                results are persisted in a table; otherwise,
+                results are garbage collected at the end of the
+                session.
+                Default Value: False
+                Types: bool    
+            
         RETURNS:
             a tuple containing, model information and leaderboard.   
         """
@@ -911,7 +1961,8 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                                      target_column = self.target_column,
                                      model_list = model_list,
                                      verbose = verbose,
-                                     custom_data = self.custom_data)
+                                     custom_data = self.custom_data,
+                                     **kwargs)
         # Start time
         start_time = time.time()
         data, excluded_columns, target_label, data_transformation_params = self.feature_engineering(auto)
@@ -923,7 +1974,8 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                                   verbose = verbose,
                                   excluded_columns = excluded_columns,
                                   custom_data = self.custom_data,
-                                  data_transform_dict = data_transformation_params)
+                                  data_transform_dict = data_transformation_params,
+                                  **kwargs)
         features, data_transformation_params = self.data_preparation(auto)
 
         # Calculating max_runtime_secs for model training by,
@@ -943,7 +1995,8 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                                 verbose = verbose,
                                 features = features,
                                 task_type = "Regression",
-                                custom_data = self.custom_data)
+                                custom_data = self.custom_data,
+                                **kwargs)
         models_info, leaderboard, target_count = self.model_training(auto = auto,
                                                         max_runtime_secs = max_runtime_secs, 
                                                         stopping_metric = stopping_metric, 
@@ -989,7 +2042,8 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                         max_runtime_secs = None,
                         stopping_metric = None, 
                         stopping_tolerance = None,
-                        max_models = None):
+                        max_models = None,
+                        **kwargs):
         """
         DESCRIPTION:
             Interal Function runs Classification.
@@ -1030,12 +2084,30 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                 Optional Argument.
                 Specifies the maximum number of models to be trained.
                 Types: int
-        
+
+            volatile:
+                Optional Argument.
+                Specifies whether to put the results of the
+                function in a volatile table or not. When set to
+                True, results are stored in a volatile table,
+                otherwise not.
+                Default Value: False
+                Types: bool
+
+            persist:
+                Optional Argument.
+                Specifies whether to persist the results of the
+                function in a table or not. When set to True,
+                results are persisted in a table; otherwise,
+                results are garbage collected at the end of the
+                session.
+                Default Value: False
+                Types: bool
+
         RETURNS:
             a tuple containing, model information and leaderboard.
         """
-        
-        
+
         # Feature Exploration Phase
         _FeatureExplore.__init__(self, 
                                      data = self.data, 
@@ -1050,7 +2122,8 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                                      model_list = model_list,
                                      verbose = verbose,
                                      task_type = "Classification",
-                                     custom_data = self.custom_data)
+                                     custom_data = self.custom_data,
+                                     **kwargs)
         # Start time
         start_time = time.time()
         data, excluded_columns, target_label, data_transformation_params = self.feature_engineering(auto)
@@ -1062,7 +2135,8 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                                   excluded_columns = excluded_columns, 
                                   custom_data = self.custom_data,
                                   data_transform_dict = data_transformation_params,
-                                  task_type = "Classification")
+                                  task_type = "Classification",
+                                  **kwargs)
         features, data_transformation_params = self.data_preparation(auto)
 
         # Calculating max_runtime_secs for model training by,
@@ -1082,7 +2156,8 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                                 verbose = verbose,
                                 features = features, 
                                 task_type = "Classification",
-                                custom_data = self.custom_data)
+                                custom_data = self.custom_data,
+                                **kwargs)
         models_info, leaderboard, target_count = self.model_training(auto = auto,
                                                         max_runtime_secs = max_runtime_secs, 
                                                         stopping_metric = stopping_metric, 
@@ -1243,7 +2318,8 @@ class AutoRegressor(AutoML):
                  stopping_metric=None, 
                  stopping_tolerance=None,
                  max_models=None,
-                 custom_config_file=None
+                 custom_config_file=None,
+                 **kwargs
                 ):
         """
         DESCRIPTION:
@@ -1284,8 +2360,10 @@ class AutoRegressor(AutoML):
                 Required, when "stopping_tolerance" is set, otherwise optional.
                 Specifies the stopping mertics for stopping tolerance in model training.
                 Permitted Values: 
-                    * For task_type "Regression": "R2", "MAE", "MSE", "MSLE", 
-                                                  "RMSE", "RMSLE"
+                    * For task_type "Regression": "R2", "MAE", "MSE", "MSLE",
+                                                  "MAPE", "MPE", "RMSE", "RMSLE",
+                                                  "ME", "EV", "MPD", "MGD"
+
                     * For task_type "Classification": 'MICRO-F1','MACRO-F1',
                                                       'MICRO-RECALL','MACRO-RECALL',
                                                       'MICRO-PRECISION', 'MACRO-PRECISION',
@@ -1307,7 +2385,29 @@ class AutoRegressor(AutoML):
                 Optional Argument.
                 Specifies the path of JSON file in case of custom run.
                 Types: str
-                
+
+            **kwargs:
+                Specifies the additional arguments for AutoRegressor. Below
+                are the additional arguments:
+                    volatile:
+                            Optional Argument.
+                            Specifies whether to put the interim results of the
+                            functions in a volatile table or not. When set to
+                            True, results are stored in a volatile table,
+                            otherwise not.
+                            Default Value: False
+                            Types: bool
+
+                    persist:
+                        Optional Argument.
+                        Specifies whether to persist the interim results of the
+                        functions in a table or not. When set to True,
+                        results are persisted in a table; otherwise,
+                        results are garbage collected at the end of the
+                        session.
+                        Default Value: False
+                        Types: bool
+            
         RETURNS:
             Instance of AutoRegressor.
     
@@ -1336,24 +2436,28 @@ class AutoRegressor(AutoML):
 
             # Fit the data.
             >>> automl_obj.fit(housing_train, "price")
+            
+            # Display leaderboard.
+            >>> automl_obj.leaderboard()
 
-            # Predict using best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
+            # Display best performing model.
+            >>> automl_obj.leader()
             
-            # Run predict for new test data with best performing model.
+            # Run predict on test data using best performing model.
             >>> prediction = automl_obj.predict(housing_test)
             >>> prediction
             
-            # Run predict for new test data with second best performing model.
+            # Run predict on test data using second best performing model.
             >>> prediction = automl_obj.predict(housing_test, rank=2)
             >>> prediction
-
-            # Display leaderboard.
-            >>> automl_obj.leaderboard()
-
-            # Display best performing model.
-            >>> automl_obj.leader()
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(housing_test)
+            >>> performance_metrics
+            
+            # Run evaluate to get performance metrics using second best performing model.
+            >>> performance_metrics = automl_obj.evaluate(housing_test, 2)
+            >>> performance_metrics
 
             # Example 2 : Run AutoRegressor for regression problem with early stopping metric and tolerance.
             # Scenario : Predict the price of house based on different factors.
@@ -1374,13 +2478,17 @@ class AutoRegressor(AutoML):
             >>>                            custom_config_file="custom_housing.json")
             # Fit the data.
             >>> automl_obj.fit(housing_train, "price")
- 
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-
+            
             # Display leaderboard.
             >>> automl_obj.leaderboard()
+ 
+            # Run predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(housing_test)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(housing_test)
+            >>> performance_metrics
 
             # Example 3 : Run AutoRegressor for regression problem with maximum runtime.
             # Scenario : Predict the price of house based on different factors.
@@ -1392,20 +2500,24 @@ class AutoRegressor(AutoML):
             >>>                            max_runtime_secs=500)
             # Fit the data.
             >>> automl_obj.fit(housing_train, "price")
- 
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-
-            # Run predict with second best performing model.
-            >>> prediction = automl_obj.predict(rank=2)
-            >>> prediction
-
+            
             # Display leaderboard.
             >>> automl_obj.leaderboard()
  
             # Display best performing model.
             >>> automl_obj.leader()  
+ 
+            # Run predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(housing_test)
+            >>> prediction
+
+            # Run predict on test data using second best performing model.
+            >>> prediction = automl_obj.predict(housing_test, 2)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(housing_test)
+            >>> performance_metrics
         """
         self.verbose = verbose
         self.max_runtime_secs = max_runtime_secs
@@ -1425,7 +2537,8 @@ class AutoRegressor(AutoML):
                                             stopping_metric=self.stopping_metric, 
                                             stopping_tolerance=self.stopping_tolerance,
                                             max_models=self.max_models,
-                                            custom_config_file=self.custom_config_file)        
+                                            custom_config_file=self.custom_config_file,
+                                            **kwargs)        
 class AutoClassifier(AutoML):
         
     def __init__(self,
@@ -1436,7 +2549,8 @@ class AutoClassifier(AutoML):
                 stopping_metric=None, 
                 stopping_tolerance=None,
                 max_models=None,
-                custom_config_file=None
+                custom_config_file=None,
+                **kwargs
                 ):
         """
         DESCRIPTION:
@@ -1477,8 +2591,10 @@ class AutoClassifier(AutoML):
                 Required, when "stopping_tolerance" is set, otherwise optional.
                 Specifies the stopping mertics for stopping tolerance in model training.
                 Permitted Values: 
-                    * For task_type "Regression": "R2", "MAE", "MSE", "MSLE", 
-                                                  "RMSE", "RMSLE"
+                    * For task_type "Regression": "R2", "MAE", "MSE", "MSLE",
+                                                  "MAPE", "MPE", "RMSE", "RMSLE",
+                                                  "ME", "EV", "MPD", "MGD"
+                                                  
                     * For task_type "Classification": 'MICRO-F1','MACRO-F1',
                                                       'MICRO-RECALL','MACRO-RECALL',
                                                       'MICRO-PRECISION', 'MACRO-PRECISION',
@@ -1500,6 +2616,28 @@ class AutoClassifier(AutoML):
                 Optional Argument.
                 Specifies the path of json file in case of custom run.
                 Types: str
+
+            **kwargs:
+                Specifies the additional arguments for AutoClassifier. Below
+                are the additional arguments:
+                    volatile:
+                        Optional Argument.
+                        Specifies whether to put the interim results of the
+                        functions in a volatile table or not. When set to
+                        True, results are stored in a volatile table,
+                        otherwise not.
+                        Default Value: False
+                        Types: bool
+
+                    persist:
+                        Optional Argument.
+                        Specifies whether to persist the interim results of the
+                        functions in a table or not. When set to True,
+                        results are persisted in a table; otherwise,
+                        results are garbage collected at the end of the
+                        session.
+                        Default Value: False
+                        Types: bool
                 
         RETURNS:
             Instance of AutoClassifier.
@@ -1535,24 +2673,28 @@ class AutoClassifier(AutoML):
 
             # Fit the data.
             >>> automl_obj.fit(admissions_train, "admitted")
+            
+            # Display leaderboard.
+            >>> automl_obj.leaderboard()
 
-            # Predict using best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
+            # Display best performing model.
+            >>> automl_obj.leader()
             
-            # Run predict for new test data with best performing model.
+            # Run predict on test data using best performing model.
             >>> prediction = automl_obj.predict(admissions_test)
             >>> prediction
             
-            # Run predict for new test data with second best performing model.
+            # Run predict on test data using second best performing model.
             >>> prediction = automl_obj.predict(admissions_test, rank=2)
             >>> prediction
-
-            # Display leaderboard.
-            >>> automl_obj.leaderboard()
-
-            # Display best performing model.
-            >>> automl_obj.leader()
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(admissions_test)
+            >>> performance_metrics
+            
+            # Run evaluate to get performance metrics using model rank 4.
+            >>> performance_metrics = automl_obj.evaluate(admissions_test, 4)
+            >>> performance_metrics
 
             # Example 2 : Run AutoClassifier for binary classification.
             # Scenario : Predict whether passenger aboard the RMS Titanic survived
@@ -1561,6 +2703,11 @@ class AutoClassifier(AutoML):
             #            configuration file to customize different processes of
             #            AutoML Run. 
             
+            # Split the data into train and test.
+            >>> titanic_sample = titanic.sample(frac = [0.8, 0.2])
+            >>> titanic_train= titanic_sample[titanic_sample['sampleid'] == 1].drop('sampleid', axis=1)
+            >>> titanic_test = titanic_sample[titanic_sample['sampleid'] == 2].drop('sampleid', axis=1)
+            
             # Generate custom configuration file.
             >>> AutoClassifier.generate_custom_config("custom_titanic")
             
@@ -1568,21 +2715,25 @@ class AutoClassifier(AutoML):
             >>> automl_obj = AutoClassifier(verbose=2, 
             >>>                             custom_config_file="custom_titanic.json")
             # Fit the data.
-            >>> automl_obj.fit(titanic, titanic.survived)
- 
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-
-            # Run predict with second best performing model.
-            >>> prediction = automl_obj.predict(rank=2)
-            >>> prediction
+            >>> automl_obj.fit(titanic_train, titanic_train.survived)
 
             # Display leaderboard.
             >>> automl_obj.leaderboard()
  
             # Display best performing model.
             >>> automl_obj.leader()
+ 
+            # Run predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(titanic_test)
+            >>> prediction
+
+            # Run predict on test data using second best performing model.
+            >>> prediction = automl_obj.predict(titanic_test, rank=2)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(titanic_test)
+            >>> performance_metrics
 
             # Example 3 : Run AutoClassifier for multiclass classification problem.
             # Scenario : Predict the species of iris flower based on different factors.
@@ -1590,6 +2741,11 @@ class AutoClassifier(AutoML):
             #            models. Use custom configuration file to customize different 
             #            processes of AutoML Run.
             
+            # Split the data into train and test.
+            >>> iris_sample = iris_input.sample(frac = [0.8, 0.2])
+            >>> iris_train= iris_sample[iris_sample['sampleid'] == 1].drop('sampleid', axis=1)
+            >>> iris_test = iris_sample[iris_sample['sampleid'] == 2].drop('sampleid', axis=1)
+            
             # Generate custom configuration file.
             >>> AutoClassifier.generate_custom_config("custom_iris")
             
@@ -1597,18 +2753,22 @@ class AutoClassifier(AutoML):
             >>> automl_obj = AutoClassifier(verbose=1, 
             >>>                             custom_config_file="custom_iris.json")
             # Fit the data.
-            >>> automl_obj.fit(iris_input, "species")
-
-            # Predict using best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-
+            >>> automl_obj.fit(iris_train, "species")
+            
             # Display leaderboard.
             >>> automl_obj.leaderboard()
   
             # Display best performing model.
             >>> automl_obj.leader()
 
+            # Predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(iris_test)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(iris_test)
+            >>> performance_metrics
+
             # Example 4 : Run AutoClassifier for classification problem with stopping metric and tolerance.
             # Scenario : Predict whether passenger aboard the RMS Titanic survived
             #            or not based on differect factors. Use custom configuration 
@@ -1616,6 +2776,11 @@ class AutoClassifier(AutoML):
             #            performance threshold to acquire for the available models, and 
             #            terminate training upon meeting the stipulated performance criteria.
             
+            # Split the data into train and test.
+            >>> titanic_sample = titanic.sample(frac = [0.8, 0.2])
+            >>> titanic_train= titanic_sample[titanic_sample['sampleid'] == 1].drop('sampleid', axis=1)
+            >>> titanic_test = titanic_sample[titanic_sample['sampleid'] == 2].drop('sampleid', axis=1)
+            
             # Generate custom configuration file.
             >>> AutoClassifier.generate_custom_config("custom_titanic")
 
@@ -1627,18 +2792,27 @@ class AutoClassifier(AutoML):
             >>>                             max_models=8
             >>>                             custom_config_file="custom_titanic.json")
             # Fit the data.
-            >>> automl_obj.fit(titanic, titanic.survived)
- 
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-
+            >>> automl_obj.fit(titanic_train, titanic_train.survived)
+            
             # Display leaderboard.
             >>> automl_obj.leaderboard()
+ 
+            # Run predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(titanic_test)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using best performing model.
+            >>> performance_metrics = automl_obj.evaluate(titanic_test)
+            >>> performance_metrics
 
             # Example 5 : Run AutoClassifier for classification problem with maximum runtime.
             # Scenario : Predict the species of iris flower based on different factors.
             #            Run AutoML to get the best performing model in specified time.
+            
+            # Split the data into train and test.
+            >>> iris_sample = iris_input.sample(frac = [0.8, 0.2])
+            >>> iris_train= iris_sample[iris_sample['sampleid'] == 1].drop('sampleid', axis=1)
+            >>> iris_test = iris_sample[iris_sample['sampleid'] == 2].drop('sampleid', axis=1)
 
             # Create instance of AutoClassifier.
             >>> automl_obj = AutoClassifier(verbose=2, 
@@ -1646,21 +2820,25 @@ class AutoClassifier(AutoML):
             >>>                             max_runtime_secs=500)
             >>>                             max_models=3)
             # Fit the data.
-            >>> automl_obj.fit(iris_input, iris_input.species)
- 
-            # Run predict with best performing model.
-            >>> prediction = automl_obj.predict()
-            >>> prediction
-
-            # Run predict with second best performing model.
-            >>> prediction = automl_obj.predict(rank=2)
-            >>> prediction
-
+            >>> automl_obj.fit(iris_train, iris_train.species)
+            
             # Display leaderboard.
             >>> automl_obj.leaderboard()
  
             # Display best performing model.
-            >>> automl_obj.leader()     
+            >>> automl_obj.leader()
+ 
+            # Run predict on test data using best performing model.
+            >>> prediction = automl_obj.predict(iris_test)
+            >>> prediction
+
+            # Run predict on test data using second best performing model.
+            >>> prediction = automl_obj.predict(iris_test, rank=2)
+            >>> prediction
+            
+            # Run evaluate to get performance metrics using model rank 3.
+            >>> performance_metrics = automl_obj.evaluate(iris_test, 3)
+            >>> performance_metrics  
         """
         self.verbose = verbose
         self.max_runtime_secs = max_runtime_secs
@@ -1673,11 +2851,12 @@ class AutoClassifier(AutoML):
         self.exclude = exclude
         
         super(AutoClassifier, self).__init__(task_type=self.task_type,
-                                            include = self.include,
-                                            exclude = self.exclude,
-                                            verbose=self.verbose,
-                                            max_runtime_secs=self.max_runtime_secs,
-                                            stopping_metric=self.stopping_metric, 
-                                            stopping_tolerance=self.stopping_tolerance,
-                                            max_models=self.max_models,
-                                            custom_config_file=self.custom_config_file)
+                                             include = self.include,
+                                             exclude = self.exclude,
+                                             verbose=self.verbose,
+                                             max_runtime_secs=self.max_runtime_secs,
+                                             stopping_metric=self.stopping_metric, 
+                                             stopping_tolerance=self.stopping_tolerance,
+                                             max_models=self.max_models,
+                                             custom_config_file=self.custom_config_file,
+                                             **kwargs)