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

teradataml/automl/__init__.py

@@ -15,21 +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 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
@@ -51,7 +59,9 @@ class AutoML:
                  max_runtime_secs = None,
                  stopping_metric = None, 
                  stopping_tolerance = None,
-                 custom_config_file = None):
+                 max_models = None,
+                 custom_config_file = None,
+                 **kwargs):
         """
         DESCRIPTION:
             AutoML (Automated Machine Learning) is an approach that automates the process 
@@ -82,12 +92,12 @@ class AutoML:
             AutoML also provides an option to customize the processes within feature
             engineering, data preparation and model training phases. User can customize
             the processes by passing the JSON file path in case of custom run. It also 
-            supports early stopping of model training based on stopping metrics and
-            maximum running time.
+            supports early stopping of model training based on stopping metrics,
+            maximum running time and maximum models to be trained.
          
         PARAMETERS:  
             task_type:
-                Optional Arugment.
+                Optional Argument.
                 Specifies the task type for AutoML, whether to apply regression OR classification
                 on the provided dataset. If user wants AutoML to decide the task type automatically, 
                 then it should be set to "Default".
@@ -122,7 +132,7 @@ class AutoML:
                 Types: int
                 
             max_runtime_secs:
-                Optional Arugment.
+                Optional Argument.
                 Specifies the time limit in seconds for model training.
                 Types: int
                 
@@ -130,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',
@@ -143,11 +155,38 @@ class AutoML:
                 Required, when "stopping_metric" is set, otherwise optional.
                 Specifies the stopping tolerance for stopping metrics in model training.
                 Types: float
+            
+            max_models:
+                Optional Argument.
+                Specifies the maximum number of models to be trained.
+                Types: int
                 
             custom_config_file:
                 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.
@@ -185,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.
@@ -221,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
@@ -246,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()
 
@@ -253,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. 
@@ -285,41 +338,61 @@ class AutoML:
             >>>                     exclude="xgboost",
             >>>                     stopping_metric="R2",
             >>>                     stopping_tolerance=0.7,
+            >>>                     max_models=10,
             >>>                     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_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 = []
@@ -330,25 +403,36 @@ 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',
                                                                                         'WEIGHTED-PRECISION','WEIGHTED-RECALL',
                                                                                         'WEIGHTED-F1', 'ACCURACY']])
         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
+        _Validators._validate_argument_range(max_models, "max_models", lbound=1, lbound_inclusive=True)
         
         custom_data = None
         self.auto = True
@@ -375,10 +459,15 @@ class AutoML:
         self.max_runtime_secs = max_runtime_secs
         self.stopping_metric = stopping_metric
         self.stopping_tolerance = stopping_tolerance
+        self.max_models = max_models
         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,
             data,
             target_column):
@@ -394,7 +483,7 @@ class AutoML:
                 Types: teradataml Dataframe
             
             target_column:
-                Required Arugment.
+                Required Argument.
                 Specifies target column of dataset.
                 Types: str or ColumnExpression
 
@@ -475,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():
@@ -484,7 +575,7 @@ class AutoML:
         
         # Displaying received custom input
         if self.custom_data:
-            print("\n Received below input for customization : ")
+            print("\nReceived below input for customization : ")
             print(json.dumps(self.custom_data, indent=4))
         
         # Classification probelm
@@ -500,38 +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
-                                                                    )
+            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")
     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:
@@ -539,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.
@@ -552,88 +650,84 @@ 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(),
+                                             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 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)
+        # 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:
-            # 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
-        
-            # 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)
-            else:
-                pred = self.m_evaluator.model_evaluation(rank = rank,
-                                                         test_data_ind = \
-                                                         self.test_data_ind,
-                                                         table_name_mapping=self.table_name_mapping)
+            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('Target Column Mapping:')
+            print('\nTarget Column Mapping:')
             # Iterating rows
             for row in self.target_label.result.itertuples():
                 # Retrieving the category names of encoded target column
@@ -644,76 +738,1011 @@ class AutoML:
                     
             for key, value in tar_dct.items():
                 print(f"{key}: {value}")
-            
-        print("\n Prediction : ")
+
+        # 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)
         
-        # 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("\n Performance Metrics : ")
-            print(metrics.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" : prediction_column,
+                        "probability_column" : probability_column,
                         "observation_column" : self.target_column,
                         "positive_class" : "1",
                         "data" : pred.result
                     }
                     # Fitting ROC
                     roc_out = ROC(**fit_params)
-                    print("\n ROC-AUC : ")
+                    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("\n Confusion Matrix : ")
+                print("\nConfusion Matrix : ")
                 print_data(confusion_matrix(prediction_df[target_col], prediction_df[prediction_column]))
                 
         # Returning prediction
-        return pred.result    
+        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.
+            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.
+        
+        PARAMETERS:
+            None
 
         RETURNS:
-            Pandas DataFrame with Leaderboard information.
+            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".
-            >>> 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
+        # 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
         
-    def leader(self):
+        # 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:
+                # 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
+        
+        # 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
+        
+    def _run_loaded_model(self,
+                          test_data,
+                          rank=1,
+                          output_type='prediction'):
         """
         DESCRIPTION:
-            Function displays best performing model.
+            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:
+            Tuple containing prediction and performance metrics.
+
+        RAISES:
+            TeradataMlException.
+
+        """
+        # 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']
+        
+        # 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 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
 
@@ -721,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"):
@@ -810,12 +1862,12 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                 Types: teradataml Dataframe
             
             target_column:
-                Required Arugment.
+                Required Argument.
                 Specifies the name of the target column in "data".
                 Types: str
             
             custom_data:
-                Optional Arugment.
+                Optional Argument.
                 Specifies json object containing user customized input.
                 Types: json object
         """
@@ -830,14 +1882,16 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                     verbose = 0,
                     max_runtime_secs = None,
                     stopping_metric = None, 
-                    stopping_tolerance = None):
+                    stopping_tolerance = None,
+                    max_models = None,
+                    **kwargs):
         """
         DESCRIPTION:
             Interal Function runs Regression.
          
         PARAMETERS:  
             auto:
-                Optional Arugment.
+                Optional Argument.
                 Specifies whether to run AutoML in custom mode or auto mode.
                 When set to False, runs in custom mode. Otherwise, by default runs in auto mode.
                 Types: bool
@@ -853,20 +1907,44 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                 Types: int
                 
             max_runtime_secs:
-                Optional Arugment.
+                Optional Argument.
                 Specifies the time limit in seconds for model training.
                 Types: int
                 
             stopping_metric:
                 Required, when "stopping_tolerance" is set, otherwise optional.
-	        Specifies the stopping mertics for stopping tolerance in model training.
+                Specifies the stopping mertics for stopping tolerance in model training.
                 Types: str
 
             stopping_tolerance:
                 Required, when "stopping_metric" is set, otherwise optional.
-	        Specifies the stopping tolerance for stopping metrics in model training.
+                Specifies the stopping tolerance for stopping metrics in model training.
                 Types: float
+            
+            max_models:
+                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.   
         """
@@ -883,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)
@@ -895,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,
@@ -915,11 +1995,13 @@ 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, 
-                                                        stopping_tolerance = stopping_tolerance)
+                                                        stopping_tolerance = stopping_tolerance,
+                                                        max_models = max_models)
 
         return (models_info, leaderboard, target_count, target_label, data_transformation_params, self.table_name_mapping)
             
@@ -940,12 +2022,12 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                 Types: teradataml Dataframe
             
             target_column:
-                Required Arugment.
+                Required Argument.
                 Specifies the name of the target column in "data".
                 Types: str
             
             custom_data:
-                Optional Arugment.
+                Optional Argument.
                 Specifies json object containing user customized input.
                 Types: json object
         """
@@ -959,14 +2041,16 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                         verbose = 0,
                         max_runtime_secs = None,
                         stopping_metric = None, 
-                        stopping_tolerance = None):
+                        stopping_tolerance = None,
+                        max_models = None,
+                        **kwargs):
         """
         DESCRIPTION:
             Interal Function runs Classification.
          
         PARAMETERS:  
             auto:
-                Optional Arugment.
+                Optional Argument.
                 Specifies whether to run AutoML in custom mode or auto mode.
                 When set to False, runs in custom mode. Otherwise, by default runs in auto mode.
                 Types: bool
@@ -982,7 +2066,7 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                 Types: int
                 
             max_runtime_secs:
-                Optional Arugment.
+                Optional Argument.
                 Specifies the time limit in seconds for model training.
                 Types: int
                 
@@ -995,12 +2079,35 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                 Required, when "stopping_metric" is set, otherwise optional.
 	            Specifies the stopping tolerance for stopping metrics in model training.
                 Types: float
-        
+            
+            max_models:
+                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, 
@@ -1015,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)
@@ -1027,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,
@@ -1047,11 +2156,13 @@ 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, 
-                                                        stopping_tolerance = stopping_tolerance)
+                                                        stopping_tolerance = stopping_tolerance,
+                                                        max_models = max_models)
 
         return (models_info, leaderboard, target_count, target_label, data_transformation_params, self.table_name_mapping)
   
@@ -1166,7 +2277,7 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
             min_label_count = min(data[self.target_column].value_counts())
             if self._data_sampling_method == 'SMOTE':
                 n_neighbors = min(5, min_label_count - 1)
-                sampling_method = SMOTE(k_neighbors=n_neighbors, random_state=5)
+                sampling_method = SMOTE(k_neighbors=n_neighbors, random_state=42)
             else:
                 n_neighbors = min(3, min_label_count)
                 sampling_method = NearMiss(version=1, n_neighbors=n_neighbors)
@@ -1206,7 +2317,9 @@ class AutoRegressor(AutoML):
                  max_runtime_secs=None,
                  stopping_metric=None, 
                  stopping_tolerance=None,
-                 custom_config_file=None
+                 max_models=None,
+                 custom_config_file=None,
+                 **kwargs
                 ):
         """
         DESCRIPTION:
@@ -1239,7 +2352,7 @@ class AutoRegressor(AutoML):
                 Types: int
                 
             max_runtime_secs:
-                Optional Arugment.
+                Optional Argument.
                 Specifies the time limit in seconds for model training.
                 Types: int
                 
@@ -1247,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',
@@ -1260,12 +2375,39 @@ class AutoRegressor(AutoML):
                 Required, when "stopping_metric" is set, otherwise optional.
                 Specifies the stopping tolerance for stopping metrics in model training.
                 Types: float
+            
+            max_models:
+                Optional Argument.
+                Specifies the maximum number of models to be trained.
+                Types: int
                 
             custom_config_file:
                 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.
     
@@ -1294,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.
@@ -1325,19 +2471,24 @@ class AutoRegressor(AutoML):
 
             # Create instance of AutoRegressor.
             >>> automl_obj = AutoRegressor(verbose=2,
-            >>>                     exclude="xgboost",
-            >>>                     stopping_metric="R2",
-            >>>                     stopping_tolerance=0.7,
-            >>>                     custom_config_file="custom_housing.json")
+            >>>                            exclude="xgboost",
+            >>>                            stopping_metric="R2",
+            >>>                            stopping_tolerance=0.7,
+            >>>                            max_models=10,
+            >>>                            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.
@@ -1345,29 +2496,34 @@ class AutoRegressor(AutoML):
 
             # Create instance of AutoRegressor.
             >>> automl_obj = AutoRegressor(verbose=2, 
-            >>>                     exclude="xgboost",
-            >>>                     max_runtime_secs=500)
+            >>>                            exclude="xgboost",
+            >>>                            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
         self.stopping_metric = stopping_metric
         self.stopping_tolerance = stopping_tolerance
+        self.max_models = max_models
         self.custom_config_file = custom_config_file
         self.task_type = "Regression"
         self.include = include
@@ -1380,7 +2536,9 @@ class AutoRegressor(AutoML):
                                             max_runtime_secs=self.max_runtime_secs,
                                             stopping_metric=self.stopping_metric, 
                                             stopping_tolerance=self.stopping_tolerance,
-                                            custom_config_file=self.custom_config_file)        
+                                            max_models=self.max_models,
+                                            custom_config_file=self.custom_config_file,
+                                            **kwargs)        
 class AutoClassifier(AutoML):
         
     def __init__(self,
@@ -1390,7 +2548,9 @@ class AutoClassifier(AutoML):
                 max_runtime_secs=None,
                 stopping_metric=None, 
                 stopping_tolerance=None,
-                custom_config_file=None
+                max_models=None,
+                custom_config_file=None,
+                **kwargs
                 ):
         """
         DESCRIPTION:
@@ -1423,32 +2583,61 @@ class AutoClassifier(AutoML):
                 Types: int
                 
             max_runtime_secs:
-                Optional Arugment.
+                Optional Argument.
                 Specifies the time limit in seconds for model training.
                 Types: int
                 
             stopping_metric:
                 Required, when "stopping_tolerance" is set, otherwise optional.
                 Specifies the stopping mertics for stopping tolerance in model training.
-                Types: str
-
-            stopping_tolerance:
-                Required, when "stopping_metric" is set, otherwise optional.
-                Specifies the stopping tolerance for stopping metrics 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',
                                                       'WEIGHTED-PRECISION','WEIGHTED-RECALL',
                                                       'WEIGHTED-F1', 'ACCURACY'
+                Types: str
+
+            stopping_tolerance:
+                Required, when "stopping_metric" is set, otherwise optional.
+                Specifies the stopping tolerance for stopping metrics in model training.
                 Types: float
+            
+            max_models:
+                Optional Argument.
+                Specifies the maximum number of models to be trained.
+                Types: int
                 
             custom_config_file:
                 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.
@@ -1484,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
@@ -1510,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")
             
@@ -1517,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.
@@ -1539,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")
             
@@ -1546,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 
@@ -1565,64 +2776,87 @@ 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")
 
             # Create instance of AutoClassifier.
             >>> automl_obj = AutoClassifier(verbose=2, 
-            >>>                     exclude="xgboost",
-            >>>                     stopping_metric="MICRO-F1",
-            >>>                     stopping_tolerance=0.7,
-            >>>                     custom_config_file="custom_titanic.json")
+            >>>                             exclude="xgboost",
+            >>>                             stopping_metric="MICRO-F1",
+            >>>                             stopping_tolerance=0.7,
+            >>>                             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, 
-            >>>                     exclude="xgboost",
-            >>>                     max_runtime_secs=500)
+            >>>                             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 model rank 3.
+            >>> performance_metrics = automl_obj.evaluate(iris_test, 3)
+            >>> performance_metrics  
         """
         self.verbose = verbose
         self.max_runtime_secs = max_runtime_secs
         self.stopping_metric = stopping_metric
         self.stopping_tolerance = stopping_tolerance
+        self.max_models = max_models
         self.custom_config_file = custom_config_file
         self.task_type = "Classification"
         self.include = include
         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,
-                                            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)