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

teradataml/automl/data_preparation.py

@@ -0,0 +1,1011 @@
+# ################################################################## 
+# 
+# Copyright 2024 Teradata. All rights reserved.
+# TERADATA CONFIDENTIAL AND TRADE SECRET
+# 
+# Primary Owner: Sweta Shaw
+# Email Id: Sweta.Shaw@Teradata.com
+# 
+# Secondary Owner: Akhil Bisht
+# Email Id: AKHIL.BISHT@Teradata.com
+# 
+# Version: 1.1
+# Function Version: 1.0
+# ##################################################################
+
+# Python libraries
+import numpy as np
+import pandas as pd
+import random
+import time
+import warnings
+warnings.filterwarnings("ignore")
+
+# Teradata libraries
+from teradataml.dataframe.dataframe import DataFrame
+from teradataml.dataframe.copy_to import copy_to_sql
+from teradataml import OutlierFilterFit, OutlierFilterTransform
+from teradataml import RoundColumns, TeradataMlException
+from teradataml import ScaleFit, ScaleTransform
+from teradataml import TrainTestSplit, UtilFuncs, TeradataConstants
+from teradataml.common.garbagecollector import GarbageCollector
+from teradataml.common.messages import Messages, MessageCodes
+from teradataml.utils.validators import _Validators
+from teradataml import INTEGER
+
+# Control Randomnes
+random.seed(42)
+np.random.seed(42)
+
+class _DataPreparation:
+    
+    def __init__(self, 
+                 data=None, 
+                 target_column=None, 
+                 verbose=0,
+                 excluded_columns=None,
+                 custom_data=None,
+                 data_transform_dict=None,
+                 task_type="Regression"):
+        """
+        DESCRIPTION:
+            Function initializes the data, target column and columns datatypes
+            for data preparation.
+         
+        PARAMETERS:  
+            data:
+                Required Argument.
+                Specifies the input teradataml Dataframe for data preparation phase.
+                Types: teradataml Dataframe
+            
+            target_column:
+                Required Argument.
+                Specifies the name of the target column in "data".
+                Types: str
+            
+            verbose:
+                Optional Argument.
+                Specifies the detailed execution steps based on verbose level.
+                Default Value: 0
+                Permitted Values: 
+                    * 0: prints the progress bar and leaderboard
+                    * 1: prints the execution steps of AutoML.
+                    * 2: prints the intermediate data between the execution of each step of AutoML.
+                Types: int
+            
+            excluded_columns:
+                Required Argument.
+                Specifies the columns should be excluded from any processing.
+                Types: str or list of strings (str)
+
+            custom_data:
+                Optional Argument.
+                Specifies json object containing user customized input.
+                Types: json object
+            
+            data_transform_dict:
+                Optional Argument.
+                Specifies the parameters for data transformation.
+                Types: dict
+            
+            task_type:
+                Required Argument.
+                Specifies the task type for AutoML, whether to apply regresion OR classification
+                on the provived dataset.
+                Default Value: "Regression"
+                Permitted Values: "Regression", "Classification"
+                Types: str
+        """
+        self.data = data
+        self.target_column = target_column
+        self.verbose = verbose
+        self.excluded_columns = excluded_columns
+        self.data_transform_dict = data_transform_dict
+        self.custom_data = custom_data
+        self.task_type = task_type
+        
+        # Setting default value for auto run mode
+        self._train_size = 0.80
+        self._data_sampling_method = "SMOTE"
+        self._scale_method_reg = "STD"
+        self._scale_method_cls = "RANGE"
+        self.table_name_mapping = {}
+        
+        self.data_types = {key: value for key, value in self.data._column_names_and_types}
+        
+        
+    def data_preparation(self, 
+                         auto = True):
+        """
+        DESCRIPTION:
+            Function to perform following tasks:-
+                1. Splits the given data into training and testing datasets.
+                2. Performs outlier processing on the training dataset and transformation on the testing dataset.
+                3. Performs feature selection using RFE, PCA, and Lasso.
+                4. Performs feature scaling.
+         
+        PARAMETERS:  
+            auto:
+                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.
+                Default Value: True
+                Types: bool    
+        
+        RETURNS:
+             list of lists containing, feature selected by rfe, pca and lasso.  
+        """
+        self._display_heading(phase=2,
+                              progress_bar=self.progress_bar)
+        self._display_msg(msg='Data preparation started ...',
+                          progress_bar=self.progress_bar)
+        # Setting user value in case of custom running mode
+        if not auto:
+            self._set_custom_train_test_split()
+            self._set_custom_scaling_method()
+            self._set_custom_sampling()
+        
+        # Performing train test split   
+        self._train_test_split()
+        self.progress_bar.update()
+        
+        # Handling ouliers in dataset
+        self._handle_outliers(auto)
+        self.progress_bar.update()
+        
+        # Handling float type features before processing with feature selection and scaling
+        train = self._handle_generated_features('train')
+        test = self._handle_generated_features('test')
+        self.progress_bar.update()
+        
+        # Temporary Pulling data for feature selection 
+        # Will change after sto
+        
+        # Checking for data imbalance    
+        if self._check_data_imbalance(train):
+            train = self._data_sampling(train)
+        self.progress_bar.update()
+        
+        # Sorting the data based on id to 
+        # remove any shuffling done by sampling
+        train = train.sort_values(by='id')
+
+        # Performing feature selection using lasso followed by scaling  
+        self._feature_selection_Lasso(train, test)
+        self._scaling_features(feature_selection_mtd="lasso")
+        self.progress_bar.update()
+        
+        # Performing feature selection using rfe followed by scaling      
+        self._feature_selection_RFE(train, test)
+        self._scaling_features(feature_selection_mtd="rfe")
+        self.progress_bar.update()
+        
+        # Performing scaling followed by feature selection using pca      
+        self._scaling_features(feature_selection_mtd="pca")
+        self._feature_selection_PCA()
+        self.progress_bar.update()
+        
+        return [self.rfe_feature, self.lasso_feature, self.pca_feature], self.data_transform_dict
+
+    # Splits data into train and test
+    def _train_test_split(self):
+        
+        """
+        DESCRIPTION:
+            Function splits the data into training and testing datasets.
+
+        PARAMETERS:  
+            train_size:
+                Optional Argument.
+                Specifies the training size required for splitting dataset.
+                By Default, it takes 0.8 as training size.
+                Types: float
+        """
+        self._display_msg(msg="\nSpliting of dataset into training and testing ...",
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+        self._display_msg(inline_msg="Training size : {}".format(self._train_size),
+                          progress_bar=self.progress_bar)
+        self._display_msg(inline_msg="Testing size  : {}".format(round((1-self._train_size),2)),
+                          progress_bar=self.progress_bar)
+        start_time = time.time()
+        # Applying TrainTestSplit function on data
+        # Regression
+        train_test_func_params = {
+            "data" : self.data, 
+            "id_column" : "id", 
+            "train_size" : self._train_size, 
+            "seed" : 42
+        }
+        if self.is_classification_type():
+            train_test_func_params["stratify_column"]=self.target_column
+        train_test_split_out = TrainTestSplit(**train_test_func_params)
+        train_test_split_out = train_test_split_out.result
+        
+        # Splitting the data into training and testing data
+        self.train_df = train_test_split_out[train_test_split_out['TD_IsTrainRow'] == 1].drop('TD_IsTrainRow', axis=1)
+        self.test_df = train_test_split_out[train_test_split_out['TD_IsTrainRow'] == 0].drop('TD_IsTrainRow', axis=1)
+
+        self._display_msg(msg="Training data sample",
+                          data=self.train_df,
+                          progress_bar=self.progress_bar)
+        
+        self._display_msg(msg="Testing data sample",
+                          data=self.test_df,
+                          progress_bar=self.progress_bar)
+        
+        end_time = time.time()
+        self._display_msg(msg="Time taken for spliting of data: {:.2f} sec  ".format(end_time - start_time),
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+
+    def _set_custom_train_test_split(self):
+        """
+        DESCRIPTION:
+            Function to split dataset into training and testing based on user input.
+             
+        """ 
+        # Fetching user input for train test split
+        train_test_split_input = self.custom_data.get("TrainTestSplitIndicator", False) 
+        if train_test_split_input:
+            # Extracting training size
+            custom_train_size = self.custom_data.get("TrainingSize", None)
+            if custom_train_size is None:
+                self._display_msg(inline_msg="No information provided for training size. Proceeding with default option.",
+                                  progress_bar=self.progress_bar)
+            else:
+                if not isinstance(custom_train_size, float):
+                    err = Messages.get_message(MessageCodes.INVALID_COLUMN_TYPE,
+                                       'custom_train', type(custom_train_size).__name__, 
+                                       'float')
+                    raise TeradataMlException(err, MessageCodes.INVALID_COLUMN_TYPE)
+                self._train_size = custom_train_size
+        else:
+            self._display_msg(inline_msg="No information provided for performing customized train test split. Proceeding with default option.",
+                              progress_bar=self.progress_bar)
+    
+    def _handle_outliers(self,
+                        auto):
+        """
+        DESCRIPTION:
+            Function to handle existing outliers in dataset based on running mode.
+        """
+        if auto:
+            self._outlier_processing()
+        else:
+            self._custom_outlier_processing()
+
+    def _check_data_imbalance(self, 
+                              data):
+        """
+        DESCRIPTION:
+            Internal function calculate and checks the imbalance in dataset 
+            in case of classification.
+        
+        PARAMETERS:
+            data:
+                Required Argument.
+                Specifies the input teradataml DataFrame.
+                Types: teradataml Dataframe
+        """
+        pass
+    
+    def _data_sampling(self,
+                       data):
+        """
+        DESCRIPTION:
+            Function to handle data imbalance in dataset using sampling techniques 
+            in case of classification.
+        """
+        pass
+    
+    def _set_custom_sampling(self):
+        """
+        DESCRIPTION:
+             Internal Function to handle customized data sampling for imbalance dataset.
+        """
+        pass
+    
+    def _outlier_handling_techniques(self):
+        """
+        DESCRIPTION:
+           Function determines the handling techniques[drop rows/impute values] for outlier columns in the dataset.
+        """
+        columns_to_drop_rows = []
+        columns_to_impute = []
+        # Keeping default method for outlier detection "Tukey"
+        outlier_method = "Tukey"
+        
+        # List of columns for outlier processing.
+        outlier_columns = [col for col in self.train_df.columns if col not in self.excluded_columns]
+        
+        # Detecting outlier percentage in each columns
+        outlier_percentage_df = self._outlier_detection(outlier_method, outlier_columns)
+        
+        # Outlier Handling techniques
+        for i in outlier_percentage_df.itertuples():
+            # Column Name
+            col = i[0]
+            # Outlier value
+            value = i[1]
+
+            if col == self.target_column:
+                if value < 5.0 and value > 0.0:
+                    columns_to_drop_rows.append(col)
+            elif value > 0.0  and value <= 8.0 :
+                columns_to_drop_rows.append(col)
+            elif value> 8.0 and value <= 25.0:
+                columns_to_impute.append(col)
+        
+        return columns_to_drop_rows, columns_to_impute
+
+    def _outlier_handling(self,
+                          target_columns,
+                          outlier_method,
+                          replacement_value):
+        """
+        DESCRIPTION:
+            Function to handle outlier for target column based outlier method and replacement value.
+
+        PARAMETERS:
+            target_columns:
+                Required Argument.
+                Specifies the target columns required for outlier handling.
+                Types: str or list of strings (str)
+        
+            outlier_method:
+                Required Argument.
+                Specifies the outlier method required for outlier handling.
+                Types: str
+                   
+            replacement_value:
+                Optional Argument.
+                Specifies the value required in case of outlier replacement.
+                Types: str, float
+        
+        RETURNS:
+            Pandas DataFrame containing, column name with outlier percentage.
+
+        """
+        # Performing fit on train dataset for outlier handling
+        fit_params = {
+            "data" : self.train_df,
+            "target_columns" : target_columns,
+            "outlier_method" : outlier_method,
+            "replacement_value" : replacement_value
+        }
+        outlier_fit_out = OutlierFilterFit(**fit_params)
+        # Performing transform on train dataset for outlier handling
+        transform_params = {
+            "data" : self.train_df,
+            "object" : outlier_fit_out.result,
+            "persist" : True
+        }
+        self.train_df = OutlierFilterTransform(**transform_params).result
+        # Adding transformed data containing table to garbage collector
+        GarbageCollector._add_to_garbagecollector(self.train_df._table_name)
+
+    def _outlier_processing(self):
+        """
+        DESCRIPTION:
+            Function performs outlier processing on the training dataset. It identifies and handle outliers in the dataset.
+                
+        """
+        self._display_msg(msg="\nOutlier preprocessing ...",
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+        start_time = time.time()
+        
+        # List of columns for dropping rows or imputing 
+        columns_to_drop_rows, columns_to_impute = self._outlier_handling_techniques()
+        # Keeping default method for outlier handling "Tukey"
+        outlier_handling_method = "Tukey"
+
+        # Dropping rows 
+        if len(columns_to_drop_rows) !=0:
+            self._display_msg(msg="Deleting rows of these columns:",
+                              col_lst=columns_to_drop_rows,
+                              progress_bar=self.progress_bar)
+            target_columns=columns_to_drop_rows
+            replacement_strategy = "DELETE"
+            self._outlier_handling(target_columns, outlier_handling_method, replacement_strategy)
+            self._display_msg(msg="Sample of training dataset after removing outlier rows:",
+                              data=self.train_df,
+                              progress_bar=self.progress_bar)
+        
+        # Imputing Median value in place of outliers
+        if len(columns_to_impute) != 0:
+            self._display_msg(msg="median inplace of outliers:",
+                              col_lst=columns_to_impute,
+                              progress_bar=self.progress_bar)
+            target_columns=columns_to_impute
+            replacement_strategy = "MEDIAN"
+            self._outlier_handling(target_columns, outlier_handling_method, replacement_strategy)
+            self._display_msg(msg="Sample of training dataset after performing MEDIAN inplace:",
+                              data=self.train_df,
+                              progress_bar=self.progress_bar)
+
+        if len(columns_to_drop_rows) == 0 and len(columns_to_impute) == 0:
+            self._display_msg(msg='Analysis indicates not outlier in the dataset. No Action Taken.',
+                              progress_bar=self.progress_bar)
+            
+        end_time = time.time()
+        self._display_msg("Time Taken by Outlier processing: {:.2f} sec ".format(end_time - start_time),
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+
+    def _custom_outlier_processing(self):
+        """
+        DESCRIPTION:
+            Function to perform outlier processing on the training dataset based on user input.
+                
+        """
+        self._display_msg(msg="\nStarting customized outlier processing ...",
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+        outlier_filter_input = self.custom_data.get("OutlierFilterIndicator", False) 
+        # Checking user input for outlier filtering   
+        if outlier_filter_input:
+            # List of columns for outlier processing.
+            target_columns = [col for col in self.train_df.columns if col not in self.excluded_columns]
+            # Checking user input for outlier detection method
+            outlier_method = self.custom_data.get("OutlierDetectionMethod", None)
+            if outlier_method == 'PERCENTILE':
+                lower_percentile = self.custom_data.get("OutlierLowerPercentile", None)
+                upper_percentile = self.custom_data.get("OutlierUpperPercentile", None)
+                if lower_percentile and upper_percentile:
+                    # Detecting outlier percentage for each columns
+                    outlier_df = self._outlier_detection(outlier_method, target_columns, \
+                        lower_percentile, upper_percentile)
+            else:
+                # Detecting outlier percentage for each column in case of other than percentile method
+                outlier_df = self._outlier_detection(outlier_method, target_columns)
+                                              
+            # Checking for rows if outlier containing columns exist
+            if outlier_df.shape[0]:
+                # Checking user input list for outlier handling
+                outlier_transform_list = self.custom_data.get("OutlierFilterParam", None)
+                if outlier_transform_list:
+                    # Checking user input for outlier handling
+                    _Validators._validate_dataframe_has_argument_columns(list(outlier_transform_list.keys()), "OutlierFilterParam",
+                                                                         self.train_df, "train")
+
+                    for target_col, transform_val in outlier_transform_list.items():
+                        # Fetching replacement value
+                        replacement_value = transform_val["replacement_value"]
+                        # Performing outlier handling
+                        self._outlier_handling(target_col, outlier_method, replacement_value)
+                else:
+                    self._display_msg(inline_msg="No information provided for feature transformation in outlier handling.",
+                                      progress_bar=self.progress_bar)
+            else:
+                self._display_msg(inline_msg="No oultiers found in dataset after applying the selected method.",
+                                  progress_bar=self.progress_bar)
+        else:
+            self._display_msg(inline_msg="No information provided for customized outlier processing. AutoML will proceed with default settings.",
+                              progress_bar=self.progress_bar)
+            # Performing default handling for outliers
+            self._outlier_processing()
+
+    # function for getting value of "K" in k folds cross validation
+    def _num_of_folds(self, rows=None):
+        """
+        DESCRIPTION:
+            Function to determine the number of folds for cross-validation 
+            based on the number of rows in the dataset.
+        PARAMETERS:
+            rows:
+                Required Argument.
+                Specifies the number of rows in the dataset.
+                Types: int
+        RETURNS:
+            int, number of folds to be used for cross-validation.
+        """
+        num_of_folds = lambda rows: 1 if rows > 20000 else (3 if 1000 < rows <= 20000 else 10)
+        return num_of_folds(rows)
+    
+    def _feature_selection_PCA(self):
+        """
+        DESCRIPTION:
+             Function performs Principal Component Analysis (PCA) for feature selection. 
+             It reduces the dimensionality of the dataset by identifying and retaining the most informative features.
+        """
+        self._display_msg(msg="\nDimension Reduction using pca ...",
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+        # Required imports for PCA
+        from sklearn.decomposition import PCA
+        
+        start_time = time.time()
+        # Training and testing data using pandas dataframe
+        # Temporary Pulling data for feature selection
+        train = DataFrame.from_table(self.table_name_mapping['pca_train']).to_pandas()
+        test = DataFrame.from_table(self.table_name_mapping['pca_test']).to_pandas()
+ 
+        # Drop unnecessary columns and store the result
+        train_data = train.drop(columns=['id', self.target_column], axis=1)
+        test_data = test.drop(columns=['id', self.target_column], axis=1)
+
+        # Initialize and fit PCA
+        pca = PCA()
+        pca.fit(train_data)
+
+        # Find the number of components for PCA
+        variance = pca.explained_variance_ratio_
+        n = np.argmax(np.cumsum(variance) >= 0.95) + 1
+
+        # Create a new instance of PCA with the optimal number of components
+        pca = PCA(n_components=n, random_state=42)
+
+        # Apply PCA on training and testing dataset
+        X_train_pca = pca.fit_transform(train_data)
+        X_test_pca = pca.transform(test_data)
+        
+        # storing instance of PCA in data transformation dictionary
+        self.data_transform_dict["pca_fit_instance"] = pca
+        
+        #converting the numarray into dataframes
+        train_df = pd.DataFrame(X_train_pca)
+        test_df  = pd.DataFrame(X_test_pca)
+        
+        #creating names for combined columns 
+        column_name = {col: 'col_'+str(i) for i,col in enumerate(train_df.columns)}
+        
+        # storing the new column names in data transformation dictionary
+        self.data_transform_dict['pca_new_column'] = column_name
+        
+        #renaming them 
+        train_df = train_df.rename(columns=column_name)
+        test_df = test_df.rename(columns=column_name)
+        
+        # adding the id column [PCA does not shuffle the dataset]
+        train_df = pd.concat([train.reset_index(drop=True)['id'], train_df.reset_index(drop=True)], axis=1)
+        test_df = pd.concat([test.reset_index(drop=True)['id'], test_df.reset_index(drop=True)], axis=1)
+        
+        # merging target column with new training and testing data
+        train_df[self.target_column] = train[self.target_column].reset_index(drop=True)
+        test_df[self.target_column] = test[self.target_column].reset_index(drop=True)
+
+        self.pca_feature = train_df.drop(columns=['id',self.target_column],axis=1).columns.tolist()
+        
+        self._display_msg(msg="PCA columns:",
+                          col_lst=self.pca_feature,
+                          progress_bar=self.progress_bar)
+        end_time = time.time()
+        self._display_msg(msg="Total time taken by PCA: {:.2f} sec  ".format( end_time - start_time),
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+        
+        # Pushing the data in database
+        self.copy_dataframe_to_sql(train_df, test_df, 'pca')
+ 
+    def _feature_selection_RFE(self, 
+                              train=None,
+                              test=None):
+        """
+        DESCRIPTION:
+             Function performs Recursive Feature Elimination (RFE) for feature selection. 
+             It identifies a subset of the most relevant features in the dataset.
+             
+        PARAMETERS:
+            train:
+                Required Argument.
+                Specifies the input train pandas DataFrame.
+                Types: pandas Dataframe
+                
+            test:
+                Required Argument.
+                Specifies the input test pandas DataFrame.
+                Types: pandas Dataframe      
+        """
+        self._display_msg(msg="\nFeature selection using rfe ...",
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+        
+        # Required imports for RFE   
+        from sklearn.feature_selection import RFECV
+        from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
+        from sklearn.model_selection import StratifiedKFold
+
+        start_time = time.time()
+        # Regression
+        is_classification = self.is_classification_type()
+        # Getting the value of k in k-fold cross-validation
+        folds = self._num_of_folds(train.shape[0])
+
+        # Random forest for RFE model
+        RFModel = RandomForestRegressor if not is_classification else RandomForestClassifier
+        rf = RFModel(n_estimators=100, random_state=42)
+
+        # Determine the scoring metric based on the number of unique classes
+        score = 'r2' if not self.is_classification_type() \
+                else 'roc_auc' if self.data.drop_duplicate(self.target_column).size == 2 else 'f1_macro'
+
+        # # Instantiate StratifiedKFold with shuffling for classification
+        cv = folds if not self.is_classification_type() \
+                   else StratifiedKFold(n_splits=folds, shuffle=False)
+
+        # Define the RFE with cross-validation
+        rfecv = RFECV(rf, cv=cv, scoring=score)
+
+        # Prepare the training data
+        train_data = train.drop(columns=['id',self.target_column], axis=1)
+        train_target = train[self.target_column]
+
+        # Fit the RFE using cv
+        rfecv.fit(train_data, train_target)
+
+        # Extract the features
+        features = train_data.columns[rfecv.support_].tolist()
+
+        self._display_msg(msg="feature selected by RFE:",
+                          col_lst=features,
+                          progress_bar=self.progress_bar)
+        features.append(self.target_column)
+        features.insert(0,'id')
+        
+        train_df = train[features]
+        test_df = test[features]
+        
+        # storing the rfe selected features in data transformation dictionary
+        self.data_transform_dict['rfe_features'] = features
+        
+        columns_to_rename = [col for col in train_df.columns if col not in ['id', self.target_column]]
+        new_column = {col: f'r_{col}' for col in columns_to_rename}
+        self.excluded_columns.extend([new_column[key] for key in self.excluded_columns if key in new_column])
+        
+        train_df.rename(columns=new_column, inplace=True)
+        test_df.rename(columns=new_column, inplace=True)
+        
+        # storing the rename column list in data transformation dictionary
+        self.data_transform_dict['rfe_rename_column'] = columns_to_rename
+        
+        end_time = time.time()
+        self._display_msg(msg="Total time taken by feature selection: {:.2f} sec  ".format( end_time - start_time),
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+        self.rfe_feature = train_df.drop(columns=['id',self.target_column], axis=1).columns.tolist()
+
+        # Pushing data into database
+        self.copy_dataframe_to_sql(train_df, test_df, 'rfe')
+        
+    def _feature_selection_Lasso(self,
+                                train=None,
+                                test=None):
+        """
+        DESCRIPTION:
+            Function performs Lasso Regression for feature selection.
+            It helps in identifing and retaining the most important features while setting less important ones to zero.
+        
+        PARAMETERS:
+            train:
+                Required Argument.
+                Specifies the input train pandas DataFrame.
+                Types: pandas Dataframe
+
+            test:
+                Required Argument.
+                Specifies the input test pandas DataFrame.
+                Types: pandas Dataframe 
+        """
+        start_time = time.time()
+        self._display_msg(msg="\nFeature selection using lasso ...",
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+        
+        # Required imports for Lasso
+        from sklearn.model_selection import GridSearchCV
+        from sklearn.linear_model import Lasso
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.model_selection import StratifiedKFold
+
+        # Getting the value k in k-fold cross-validation
+        num_folds = self._num_of_folds(train.shape[0])
+
+        # Prepare the training data
+        train_features = train.drop(columns=['id',self.target_column], axis=1)
+        train_target = train[self.target_column]
+
+        # Determine the estimator and parameters based on the type of problem
+        if self.is_classification_type():
+            if self.data.drop_duplicate(self.target_column).size == 2:
+                scoring_metric = 'roc_auc'
+            else:
+                scoring_metric = 'f1_macro'
+            estimator = LogisticRegression(solver='saga', penalty='l2', multi_class='auto', random_state=42)
+            parameters = {'C':[0.00001,0.0001,0.001,0.01,0.05,0.1,10,100,1000], 'max_iter': [100, 500]}
+        else:
+            estimator = Lasso(random_state=42)
+            parameters = {'alpha':[0.00001,0.0001,0.001,0.01,0.05,0.1,10,100,1000], 'max_iter': [100, 500]}
+            scoring_metric = "r2"
+
+        if self.is_classification_type():
+            cv = StratifiedKFold(n_splits=5, shuffle=False)
+        else:
+            cv = num_folds
+
+        # Applying hyperparameter tuning and optimizing score
+        hyperparameter_search = GridSearchCV(estimator, parameters, cv=cv, refit=True, 
+                                             scoring=scoring_metric, verbose=0)
+
+        # Fitting the best result from hyperparameter
+        hyperparameter_search.fit(train_features, train_target)
+
+        # Extracting the important estimators
+        feature_importance = np.abs(hyperparameter_search.best_estimator_.coef_)
+
+        # Extracting feature using estimators whose importance > 0 
+        if self.is_classification_type():
+            selected_feature_indices = np.where(np.any(feature_importance > 0, axis=0))[0]
+            selected_features = np.array(train_features.columns)[selected_feature_indices]
+            important_features = list(set(selected_features))
+        else:
+            important_features = np.array(train_features.columns)[feature_importance>0].tolist()
+
+        self._display_msg(msg="feature selected by lasso:",
+                        col_lst=important_features,
+                        progress_bar=self.progress_bar)
+
+        important_features = ['id'] + important_features + [self.target_column]
+        train_df = train[important_features]
+        test_df = test[important_features]
+
+        # Storing the lasso selected features in data transformation dictionary
+        self.data_transform_dict['lasso_features'] = important_features
+
+        # Calculate the elapsed time
+        end_time = time.time()
+        self._display_msg(msg="Total time taken by feature selection: {:.2f} sec  ".format( end_time - start_time),
+                        progress_bar=self.progress_bar,
+                        show_data=True)
+        self.lasso_feature = train_df.drop(columns=['id',self.target_column], axis=1).columns.tolist()
+
+        self.copy_dataframe_to_sql(train_df, test_df, 'lasso')
+
+    def copy_dataframe_to_sql(self, 
+                              train, 
+                              test, 
+                              prefix):
+        """
+        DESCRIPTION:
+            Function to copy dataframe to SQL with generated table name.
+
+        PARAMETERS:
+            train:
+                Required Argument.
+                Specifies the input train pandas DataFrame.
+                Types: pandas Dataframe
+
+            test:
+                Required Argument.
+                Specifies the input test pandas DataFrame.
+                Types: pandas Dataframe
+
+            prefix:
+                Required Argument.
+                Specifies the prefix for the table name.
+                Types: str
+        """
+        # Generating table names
+        train_table_name = UtilFuncs._generate_temp_table_name(prefix='{}_train'.format(prefix), 
+                                                               table_type = TeradataConstants.TERADATA_TABLE)
+        test_table_name = UtilFuncs._generate_temp_table_name(prefix='{}_test'.format(prefix), 
+                                                              table_type = TeradataConstants.TERADATA_TABLE)
+        
+        # Storing the table names in the table name mapping dictionary
+        self.table_name_mapping['{}_train'.format(prefix)] = train_table_name
+        self.table_name_mapping['{}_test'.format(prefix)] = test_table_name
+
+        # Pushing data into database
+        if self.is_classification_type():
+            copy_to_sql(df=train, table_name=train_table_name, if_exists="replace", types={f'{self.target_column}': INTEGER})
+            copy_to_sql(df=test, table_name=test_table_name, if_exists="replace", types={f'{self.target_column}': INTEGER})
+        else:
+            copy_to_sql(df=train, table_name=train_table_name, if_exists="replace")
+            copy_to_sql(df=test, table_name=test_table_name, if_exists="replace")
+
+
+        
+    def _scaling_features_helper(self, 
+                                train=None,  
+                                feature_selection_mtd=None):
+        """
+        DESCRIPTION:
+            This function selects the features on which feature scaling should be applied.
+            
+        PARAMETERS:
+            train:
+                Required Argument.
+                Specifies the training data.
+                Types: teradataml Dataframe
+            
+            feature_selection_mtd:
+                Required Argument.
+                Specifies the feature selection algorithm used.
+                Types: str
+                
+        RETURNS:
+            scl_col:
+                list containing, the scaled columns.   
+        """
+        columns_to_scale = []
+        
+        # Iterating over the columns
+        for col in train.columns:
+            # Selecting columns that will be scaled 
+            # Exculding target_col and columns with single value
+            if col not in ['id', self.target_column] and train.drop_duplicate(col).size > 1:
+                columns_to_scale.append(col)
+        
+        if feature_selection_mtd == "lasso":
+            self.lasso_feature = columns_to_scale
+        elif feature_selection_mtd == "rfe":
+            self.rfe_feature = columns_to_scale
+        else:
+            self.pca_feature = columns_to_scale
+        
+        columns_to_scale = [col for col in columns_to_scale if col not in self.excluded_columns]
+        return columns_to_scale
+
+    def _scaling_features(self,
+                        feature_selection_mtd=None):
+        """
+        DESCRIPTION:
+            Function performs feature scaling on columns present inside the dataset 
+            using scaling methods [RANGE/ABS/STD/USTD/MEAN/MIDRANGE/RESCALE].
+            
+        PARAMETERS:
+            feature_selection_mtd:
+                Required Argument.
+                Specifies the feature selection algorithm used.
+                Types: str     
+        """
+
+        self._display_msg(msg="\nscaling Features of {} data ...".format(feature_selection_mtd),
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+        
+        start_time = time.time()
+        train = None
+        test = None
+        
+        if self.is_classification_type():
+            scale_method = self._scale_method_cls
+        else:
+            scale_method = self._scale_method_reg
+        
+        # Loading data for feature scaling based of feature selection method
+        if feature_selection_mtd == 'rfe':
+            train = DataFrame(self.table_name_mapping['rfe_train'])
+            test = DataFrame(self.table_name_mapping['rfe_test'])
+        elif feature_selection_mtd == 'lasso':
+            train = DataFrame(self.table_name_mapping['lasso_train'])
+            test = DataFrame(self.table_name_mapping['lasso_test'])
+        else:
+            train = self.train_df
+            test = self.test_df
+
+        # List of columns that will be scaled
+        scale_col= self._scaling_features_helper(train, feature_selection_mtd)
+        
+        if len(scale_col) != 0:
+            self._display_msg(msg="columns that will be scaled: ",
+                              col_lst=scale_col,
+                              progress_bar=self.progress_bar)
+
+            # Scale Fit
+            fit_obj = ScaleFit(data=train,
+                               target_columns=scale_col,
+                               scale_method=scale_method)
+            
+            # storing the scale fit object and columns in data transformation dictionary
+            self.data_transform_dict['{}_scale_fit_obj'.format(feature_selection_mtd)] = fit_obj
+            self.data_transform_dict['{}_scale_col'.format(feature_selection_mtd)] = scale_col
+            
+            # List of columns to copy to the output generated by scale transform
+            accumulate_cols = list(set(train.columns) - set(scale_col))
+            
+            # Scaling on training dataset
+            tr_obj = ScaleTransform(data=train,
+                      object=fit_obj,
+                      accumulate=accumulate_cols)
+            
+            # Scaling on testing dataset
+            ts_obj = ScaleTransform(data=test,
+                      object=fit_obj,
+                      accumulate=accumulate_cols)
+            
+            train = tr_obj.result
+            test = ts_obj.result
+            
+            self._display_msg(msg="Training dataset sample after scaling:",
+                              data=train,
+                              progress_bar=self.progress_bar)
+            self._display_msg(msg="Testing dataset sample after scaling:",
+                              data=test,
+                              progress_bar=self.progress_bar)
+        else:
+            self._display_msg(msg="No columns to scale.",
+                              progress_bar=self.progress_bar)
+
+        self.copy_dataframe_to_sql(train, test, feature_selection_mtd)
+
+        end_time = time.time()
+        self._display_msg(msg="Total time taken by feature scaling: {:.2f} sec".format( end_time - start_time),
+                          progress_bar=self.progress_bar,
+                          show_data=True)
+
+    def _set_custom_scaling_method(self):
+        """
+        DESCRIPTION:
+            Function to perform feature scaling based on user input.
+             
+        """ 
+        # Fetching user input for performing customized scaling 
+        feature_scaling_input = self.custom_data.get("FeatureScalingIndicator", False) 
+        # Checking user input for feature scaling    
+        if feature_scaling_input:
+            # Extracting scaling method
+            custom_scaling_method = self.custom_data.get("FeatureScalingMethod", None)
+            if custom_scaling_method is None:
+                self._display_msg(inline_msg="No information provided for customized scaling method. AutoML will continue with default option.",
+                                  progress_bar=self.progress_bar)
+            else:
+                if self.is_classification_type():
+                    self._scale_method_cls = custom_scaling_method
+                else:
+                    self._scale_method_reg = custom_scaling_method
+        else:
+            self._display_msg(inline_msg="No information provided for performing customized feature scaling. Proceeding with default option.",
+                              progress_bar=self.progress_bar)
+
+    
+    def _handle_generated_features(self, 
+                                   label = None):
+        """
+        DESCRIPTION:
+            Function to handle newly generated float features. It will round them upto 4 digit after decimal point.
+            
+        PARAMETERS:
+            label:
+                Optional Argument.
+                Specifies label for dataset on which rounding up is getting done i.e., 'train' for training 
+                and 'test' for testing dataset.
+                By Default, it takes None and transformation is getting applied to whole dataset.
+                Types: str
+                
+        """
+        # Checking for label and accordingly deciding target dataset.
+        if label == 'train':
+            target_df = self.train_df
+        elif label == 'test':
+            target_df = self.test_df
+        else:
+            target_df=self.data
+            
+        # Detecting list of float columns on target dataset
+        float_columns =[col for col, d_type in target_df._column_names_and_types if d_type in ["float"]]
+        
+        if len(float_columns) == 0:
+            return target_df.to_pandas()
+        
+        # storing the column details for round up in data transformation dictionary
+        self.data_transform_dict["round_columns"] = float_columns
+        
+        # Extracting accumulate columns
+        accumulate_columns = self._extract_list(target_df.columns,float_columns)
+        # Performing rounding up on target column upto 4 precision digit
+        fit_params = {
+            "data" : target_df,
+            "target_columns" : float_columns,
+            "precision_digit" : 4,
+            "accumulate" : accumulate_columns,
+            "persist" : True}
+
+        transform_output = RoundColumns(**fit_params).result
+        # Adding transformed data containing table to garbage collector
+        GarbageCollector._add_to_garbagecollector(transform_output._table_name)
+        cols = transform_output.columns
+        df = transform_output.to_pandas().reset_index()
+        df = df[cols]
+        return df