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

teradataml/automl/feature_engineering.py

@@ -40,6 +40,7 @@ from teradataml.common.garbagecollector import GarbageCollector
 from teradataml.dataframe.sql_functions import case
 from teradataml.hyperparameter_tuner.utils import _ProgressBar
 from teradataml.utils.validators import _Validators
+from teradataml.common.utils import UtilFuncs
 
 
 class _FeatureEngineering:
@@ -50,7 +51,8 @@ class _FeatureEngineering:
                  model_list,
                  verbose = 0,
                  task_type = "Regression",
-                 custom_data = None):
+                 custom_data = None,
+                 **kwargs):
         """
         DESCRIPTION:
             Function initializes the data, target column and columns datatypes
@@ -94,6 +96,28 @@ class _FeatureEngineering:
                 Optional Argument.
                 Specifies json object containing user customized input.
                 Types: json object
+
+            **kwargs:
+                Specifies the additional arguments for feature engineering. 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
         """
         # Instance variables
         self.data = data
@@ -108,6 +132,8 @@ class _FeatureEngineering:
         self.data_transform_dict = {}
         self.one_hot_obj_count = 0
         self.is_classification_type = lambda: self.task_type.upper() == 'CLASSIFICATION'
+        self.volatile = kwargs.get('volatile', False)
+        self.persist = kwargs.get('persist', False)
     
     # Method for doing feature engineering on data -> adding id, removing futile col, imputation, encoding(one hot)
     def feature_engineering(self, 
@@ -133,7 +159,7 @@ class _FeatureEngineering:
              second element represents list of columns which are not participating in outlier tranformation.
         """
         # Assigning number of base jobs for progress bar.
-        base_jobs = 14 if auto else 18
+        base_jobs = 13 if auto else 17
         
         # Updating model list based on distinct value of target column for classification type
         if self.is_classification_type():
@@ -183,9 +209,12 @@ class _FeatureEngineering:
             self._remove_duplicate_rows()
             self.progress_bar.update()
             
+            self._anti_select_columns()
+            self.progress_bar.update()
+
             self._remove_futile_columns()
             self.progress_bar.update()
-            
+
             self._handle_date_columns()
             self.progress_bar.update()
             
@@ -206,10 +235,7 @@ class _FeatureEngineering:
             
             self._non_linear_transformation()
             self.progress_bar.update()
-            
-            self._anti_select_columns()
-            self.progress_bar.update()
-            
+               
         return self.data, self.excluded_cols, self.target_label, self.data_transform_dict
     
     def _extract_list(self,
@@ -248,7 +274,7 @@ class _FeatureEngineering:
                           show_data=True)
         start_time = time.time()
         rows = self.data.shape[0]
-        self.data=self.data.drop_duplicate()
+        self.data=self.data.drop_duplicate(self.data.columns)
         if rows != self.data.shape[0]:
             self._display_msg(msg=f'Updated dataset sample after removing {rows-self.data.shape[0]} duplicate records:',
                               data=self.data,
@@ -324,12 +350,16 @@ class _FeatureEngineering:
         if len(categorical_columns) != 0:
             
             obj = CategoricalSummary(data=self.data, 
-                                     target_columns=categorical_columns)
+                                     target_columns=categorical_columns,
+                                     volatile=self.volatile,
+                                     persist=self.persist)
             
             gfc_out = GetFutileColumns(data=self.data, 
                                        object=obj, 
                                        category_summary_column="ColumnName",
-                                       threshold_value =0.7)
+                                       threshold_value =0.7,
+                                       volatile=self.volatile,
+                                       persist=self.persist)
             
             # Extracting Futile columns
             f_cols = [row[0] for row in gfc_out.result.itertuples()]
@@ -402,10 +432,22 @@ class _FeatureEngineering:
                             "accumulate" : accumulate_columns,
                             "persist" : True
                             }
+        # Disabling display table name if persist is True by default
+        if not self.volatile and not self.persist:
+            convertto_params["display_table_name"] = False
+            
+        # Setting persist to False if volatile is True
+        if self.volatile:
+            convertto_params["persist"] = False
+            convertto_params["volatile"] = True
+
         # returning dataset after performing string manipulation                 
         self.data = ConvertTo(**convertto_params).result
-        # Adding transformed data containing table to garbage collector
-        GarbageCollector._add_to_garbagecollector(self.data._table_name)
+
+        # IF volatile is False and persist is False
+        if not self.volatile and not self.persist:
+            # Adding transformed data containing table to garbage collector
+            GarbageCollector._add_to_garbagecollector(self.data._table_name)
         return new_date_components
   
     def _handle_date_columns_helper(self):
@@ -524,9 +566,18 @@ class _FeatureEngineering:
         
         # Removing rows with missing target column value
         self.data = self.data.dropna(subset=[self.target_column])
+
+        params = {
+            "data": self.data,
+            "target_columns": self.data.columns,
+            "persist": True,
+            "display_table_name": False
+        }
         
-        obj = ColumnSummary(data=self.data, 
-                            target_columns=self.data.columns)
+        obj = ColumnSummary(**params)
+
+        # Adding transformed data containing table to garbage collector
+        GarbageCollector._add_to_garbagecollector(obj.result._table_name)
         
         cols_miss_val={}
         # Iterating over each row in the column summary result
@@ -661,7 +712,7 @@ class _FeatureEngineering:
         for key, val in self.imputation_cols.items():
             
             col_stat.append(key)
-            if self.data_types[key] in ['float', 'int']:
+            if self.data_types[key] in ['float', 'int', 'decimal.Decimal']:
                 val = skew_data[f'skew_{key}']
                 # Median imputation method, if abs(skewness value) > 1
                 if abs(val) > 1:
@@ -670,7 +721,7 @@ class _FeatureEngineering:
                 else:
                     stat.append('mean')     
             # Mode imputation method, if categorical column
-            else:
+            elif self.data_types[key] in ['str']:
                 stat.append('mode')
         
         self._display_msg(msg="Columns with their imputation method:",
@@ -697,12 +748,16 @@ class _FeatureEngineering:
             
             fit_obj = SimpleImputeFit(data=self.data, 
                                       stats_columns=col_stat, 
-                                      stats=stat)
+                                      stats=stat,
+                                      volatile=self.volatile,
+                                      persist=self.persist)
             
             # Storing fit object for imputation in data transform dictionary
             self.data_transform_dict['imputation_fit_object'] = fit_obj.output
             sm = SimpleImputeTransform(data=self.data, 
-                                        object=fit_obj)
+                                       object=fit_obj,
+                                       volatile=self.volatile,
+                                       persist=self.persist)
             
             self.data = sm.result
             self._display_msg(msg="Sample of dataset after Imputation:",
@@ -735,6 +790,8 @@ class _FeatureEngineering:
                 drop_col_ind = missing_handling_param.get("DroppingColumnIndicator", False)
                 drop_row_ind = missing_handling_param.get("DroppingRowIndicator", False)
                 impute_ind = missing_handling_param.get("ImputeMissingIndicator", False)
+                volatile = missing_handling_param.pop("volatile", False)
+                persist = missing_handling_param.pop("persist", False)
                 # Checking for user input if all methods indicator are false or not
                 if not any([drop_col_ind, drop_row_ind, impute_ind]):  
                     self._display_msg(inline_msg="No method information provided for performing customized missing value handling. \
@@ -791,7 +848,9 @@ class _FeatureEngineering:
                             "stats_columns" : stat_list,
                             "stats" : stat_method,
                             "literals_columns" : literal_list,
-                            "literals" : literal_value
+                            "literals" : literal_value,
+                            "volatile" : volatile,
+                            "persist" : persist
                         }
                         # Fitting on dataset
                         fit_obj = SimpleImputeFit(**fit_param)
@@ -804,10 +863,18 @@ class _FeatureEngineering:
                             "object" : fit_obj.output,
                             "persist" : True
                         }
+                        # Disabling display table name if persist is True by default
+                        if not volatile and not persist:
+                            transform_param["display_table_name"] = False
+
+                        if volatile:
+                            transform_param["volatile"] = True
+                            transform_param["persist"] = False
                         # Updating dataset with transform result
                         self.data = SimpleImputeTransform(**transform_param).result
-                        # Adding transformed data containing table to garbage collector
-                        GarbageCollector._add_to_garbagecollector(self.data._table_name)                 
+                        if not volatile and not persist:
+                            # Adding transformed data containing table to garbage collector
+                            GarbageCollector._add_to_garbagecollector(self.data._table_name)                 
                         self._display_msg(msg="Updated dataset sample after performing customized missing value imputation:",
                                           data=self.data,
                                           progress_bar=self.progress_bar)
@@ -848,6 +915,8 @@ class _FeatureEngineering:
                 equal_width_bin_columns  = []
                 var_width_bin_list = []
                 var_width_bin_columns  = []
+                volatile = extracted_col.pop("volatile", False)
+                persist = extracted_col.pop("persist", False)
 
                 # Checking for column present in dataset or not
                 _Validators._validate_dataframe_has_argument_columns(list(extracted_col.keys()), "BincodeParam", self.data, "df")
@@ -881,7 +950,9 @@ class _FeatureEngineering:
                         "data" : self.data,
                         "target_columns": equal_width_bin_columns,
                         "method_type" : "Equal-Width",
-                        "nbins" : bins  
+                        "nbins" : bins,
+                        "volatile" : volatile,
+                        "persist" : persist
                     }
                     eql_bin_code_fit = BincodeFit(**fit_params)
                     # Storing fit object and column list for Equal-Width binning in data transform dictionary
@@ -894,11 +965,19 @@ class _FeatureEngineering:
                         "data" : self.data,
                         "object" : eql_bin_code_fit.output,
                         "accumulate" : accumulate_columns,
-                        "persist" : True,   
+                        "persist" : True
                     }
+                    # Disabling display table name if persist is True by default
+                    if not volatile and not persist:
+                        eql_transform_params["display_table_name"] = False
+                        
+                    if volatile:
+                        eql_transform_params["volatile"] = True
+                        eql_transform_params["persist"] = False
                     self.data = BincodeTransform(**eql_transform_params).result
-                    # Adding transformed data containing table to garbage collector
-                    GarbageCollector._add_to_garbagecollector(self.data._table_name)
+                    if not volatile and not persist:
+                        # Adding transformed data containing table to garbage collector
+                        GarbageCollector._add_to_garbagecollector(self.data._table_name)
                     self._display_msg(msg="\nUpdated dataset sample after performing Equal-Width binning :-",
                                       data=self.data,
                                       progress_bar=self.progress_bar)
@@ -923,7 +1002,9 @@ class _FeatureEngineering:
                         "maxvalue_column" : "MaxValue",
                         "label_column" : "Label",
                         "method_type" : "Variable-Width",
-                        "label_prefix" : "label_prefix"
+                        "label_prefix" : "label_prefix",
+                        "volatile" : volatile,
+                        "persist" : persist
                     }
                     var_bin_code_fit = BincodeFit(**fit_params)
                     # Storing fit object and column list for Variable-Width binning in data transform dictionary
@@ -935,11 +1016,19 @@ class _FeatureEngineering:
                         "object" : var_bin_code_fit.output,
                         "object_order_column" : "TD_MinValue_BINFIT",
                         "accumulate" : accumulate_columns,
-                        "persist" : True   
+                        "persist" : True
                     }
+                    # Disabling display table name if persist is True by default
+                    if not volatile and not persist:
+                        var_transform_params["display_table_name"] = False
+                    
+                    if volatile:
+                        var_transform_params["volatile"] = True
+                        var_transform_params["persist"] = False
                     self.data = BincodeTransform(**var_transform_params).result
-                    # Adding transformed data containing table to garbage collector
-                    GarbageCollector._add_to_garbagecollector(self.data._table_name)
+                    if not volatile and not persist:
+                        # Adding transformed data containing table to garbage collector
+                        GarbageCollector._add_to_garbagecollector(self.data._table_name)
                     self._display_msg(msg="Updated dataset sample after performing Variable-Width binning:",
                                       data=self.data,
                                       progress_bar=self.progress_bar)
@@ -963,11 +1052,13 @@ class _FeatureEngineering:
             # Storing custom string manipulation indicator in data transform dictionary
             self.data_transform_dict['custom_string_manipulation_ind'] = True
             # Fetching list required for performing operation.
-            extracted_col = self.custom_data.get("StringManipulationParam", None)
+            extracted_col = self.custom_data.get("StringManipulationParam", None).copy()
             if not extracted_col:
                 self._display_msg(inline_msg="No information provided for performing string manipulation.",
                                   progress_bar=self.progress_bar)
             else:
+                volatile = extracted_col.pop("volatile", False)
+                persist = extracted_col.pop("persist", False)
                 # Checking for column present in dataset or not
                 _Validators._validate_dataframe_has_argument_columns(list(extracted_col.keys()), "StringManipulationParam", self.data, "df")
 
@@ -980,8 +1071,9 @@ class _FeatureEngineering:
                                   data=self.data,
                                   progress_bar=self.progress_bar)
         else:
-            self._display_msg(inline_msg="Skipping customized string manipulation.")
-                     
+            self._display_msg(inline_msg="Skipping customized string manipulation.",
+                              progress_bar=self.progress_bar)
+ 
     def _str_method_mapping(self,
                             target_col,
                             transform_val):
@@ -1010,7 +1102,11 @@ class _FeatureEngineering:
         
         # Fetching required parameters from json object
         string_operation = transform_val["StringOperation"]
-        
+
+        # Setting volatile and persist parameters for performing string manipulation
+        volatile, persist = self._set_generic_parameters(func_indicator="StringManipulationIndicator",
+                                                         param_name="StringManipulationParam")
+
         # Storing general parameters for performing string transformation
         fit_params = {
             "data" : self.data,
@@ -1020,6 +1116,14 @@ class _FeatureEngineering:
             "inplace" : True,
             "persist" : True
         }
+        # Disabling display table name if persist is True by default
+        if not volatile and not persist:
+            fit_params["display_table_name"] = False
+
+        if volatile:
+            fit_params["volatile"] = True
+            fit_params["persist"] = False
+
         # Adding additional parameters based on string operation type           
         if string_operation in ["StringCon", "StringTrim"]:
             string_argument = transform_val["String"] 
@@ -1040,13 +1144,14 @@ class _FeatureEngineering:
         
         # returning dataset after performing string manipulation                 
         transform_output = StrApply(**fit_params).result
-        # Adding transformed data containing table to garbage collector
-        GarbageCollector._add_to_garbagecollector(transform_output._table_name)
+        if not volatile and not persist:
+            # Adding transformed data containing table to garbage collector
+            GarbageCollector._add_to_garbagecollector(transform_output._table_name)
         return transform_output
               
     def _one_hot_encoding(self, 
-                         one_hot_columns, 
-                         unique_counts):
+                          one_hot_columns, 
+                          unique_counts):
         """
         DESCRIPTION:
             Function performs the one hot encoding to categorcial columns/features in the dataset.
@@ -1060,12 +1165,16 @@ class _FeatureEngineering:
             unique_counts:
                   Required Argument.
                   Specifies the unique counts in the categorical columns.
-                  Types: int or list of integer (int)
-                  
+                  Types: int or list of integer (int)     
         """
         # TD function will add extra column_other in onehotEncoding, so 
         # initailizing this list to remove those extra columns 
         drop_lst = [ele + "_other" for ele in one_hot_columns]
+
+        # Setting volatile and persist parameters for performing encoding
+        volatile, persist = self._set_generic_parameters(func_indicator="CategoricalEncodingIndicator",
+                                                         param_name="CategoricalEncodingParam")
+
         # Adding fit parameters for performing encoding
         fit_params = {
             "data" : self.data,
@@ -1073,7 +1182,9 @@ class _FeatureEngineering:
             "is_input_dense" : True,
             "target_column" : one_hot_columns,
             "category_counts" : unique_counts,
-            "other_column" : "other"
+            "other_column" : "other",
+            "volatile" : volatile,
+            "persist" : persist
         }
         # Performing one hot encoding fit on target columns
         fit_obj = OneHotEncodingFit(**fit_params)
@@ -1089,10 +1200,21 @@ class _FeatureEngineering:
             "is_input_dense" : True,
             "persist" : True
         }
+        # Disabling display table name if persist is True by default
+        if not volatile and not persist:
+            transform_params["display_table_name"] = False
+        
+        # Setting persist to False if volatile is True
+        if volatile:
+            transform_params["volatile"] = True
+            transform_params["persist"] = False
+        
         # Performing one hot encoding transformation
         transform_output = OneHotEncodingTransform(**transform_params).result
-        # Adding transformed data containing table to garbage collector
-        GarbageCollector._add_to_garbagecollector(transform_output._table_name)
+
+        if not volatile and not persist:
+            # Adding transformed data containing table to garbage collector
+            GarbageCollector._add_to_garbagecollector(transform_output._table_name)
         self.data = transform_output.drop(drop_lst, axis=1)
 
     def _ordinal_encoding(self,
@@ -1107,10 +1229,16 @@ class _FeatureEngineering:
                 Specifies the categorical columns for which ordinal encoding will be performed.
                 Types: str or list of strings (str)
         """
+        # Setting volatile and persist parameters for performing encoding
+        volatile, persist = self._set_generic_parameters(func_indicator="CategoricalEncodingIndicator",
+                                                         param_name="CategoricalEncodingParam")
+
         # Adding fit parameters for performing encoding
         fit_params = {
             "data" : self.data,
-            "target_column" : ordinal_columns
+            "target_column" : ordinal_columns,
+            "volatile" : volatile,
+            "persist" : persist
         }
         # Performing ordinal encoding fit on target columns
         ord_fit_obj = OrdinalEncodingFit(**fit_params)
@@ -1130,17 +1258,27 @@ class _FeatureEngineering:
             "accumulate" : accumulate_columns,
             "persist" : True
         }
+        # Disabling display table name if persist is True by default
+        if not volatile and not persist:
+            transform_params["display_table_name"] = False
+
+        # Setting persist to False if volatile is True
+        if volatile:
+            transform_params["volatile"] = True
+            transform_params["persist"] = False
         # Performing ordinal encoding transformation
         self.data = OrdinalEncodingTransform(**transform_params).result
-        # Adding transformed data containing table to garbage collector
-        GarbageCollector._add_to_garbagecollector(self.data._table_name)
+
+        if not volatile and not persist:
+            # Adding transformed data containing table to garbage collector
+            GarbageCollector._add_to_garbagecollector(self.data._table_name)
         
         if len(ordinal_columns) == 1 and ordinal_columns[0] == self.target_column:
             self.target_label = ord_fit_obj
         
 
     def _target_encoding(self,
-                          target_encoding_list):
+                         target_encoding_list):
         """
         DESCRIPTION:
             Function performs the target encoding to categorcial columns/features in the dataset.
@@ -1165,6 +1303,11 @@ class _FeatureEngineering:
         # Storing indicator and fit object for target encoding in data transform dictionary
         self.data_transform_dict["custom_target_encoding_ind"] = True
         self.data_transform_dict["custom_target_encoding_fit_obj"] = {}
+
+        # Setting volatile and persist parameters for performing encoding
+        volatile, persist = self._set_generic_parameters(func_indicator="CategoricalEncodingIndicator",
+                                                         param_name="CategoricalEncodingParam")
+        
         # Fetching required argument for performing target encoding
         for col,transform_val in target_encoding_list.items():
             encoder_method = transform_val["encoder_method"]
@@ -1175,7 +1318,9 @@ class _FeatureEngineering:
                 "category_data" : category_data,
                 "encoder_method" : encoder_method,
                 "target_columns" : col,
-                "response_column" : response_column
+                "response_column" : response_column,
+                "volatile" : volatile,
+                "persist" : persist
                 }
             if encoder_method == "CBM_DIRICHLET":
                 num_distinct_responses=transform_val["num_distinct_responses"]
@@ -1184,7 +1329,7 @@ class _FeatureEngineering:
             # Performing target encoding fit on target columns
             tar_fit_obj = TargetEncodingFit(**fit_params)
             # Storing each column fit object for target encoding in data transform dictionary
-            self.data_transform_dict["custom_target_encoding_fit_obj"].update({col : tar_fit_obj})
+            self.data_transform_dict["custom_target_encoding_fit_obj"].update({col : tar_fit_obj.result})
             # Extracting accumulate columns
             accumulate_columns = self._extract_list(self.data.columns, [col])
             # Adding transform parameters for performing encoding
@@ -1192,12 +1337,21 @@ class _FeatureEngineering:
                 "data" : self.data,
                 "object" : tar_fit_obj,
                 "accumulate" : accumulate_columns,
-                "persist" : True                
+                "persist" : True              
             }
+            
+            # Disabling display table name if persist is True by default
+            if not volatile and not persist:
+                transform_params["display_table_name"] = False
+            
+            if volatile:
+                transform_params["volatile"] = True
+                transform_params["persist"] = False
             # Performing ordinal encoding transformation
             self.data = TargetEncodingTransform(**transform_params).result
-            # Adding transformed data containing table to garbage collector
-            GarbageCollector._add_to_garbagecollector(self.data._table_name)
+            if not volatile and not persist:
+                # Adding transformed data containing table to garbage collector
+                GarbageCollector._add_to_garbagecollector(self.data._table_name)
     
     def _encoding_categorical_columns(self):
         """
@@ -1262,8 +1416,10 @@ class _FeatureEngineering:
             # Storing custom categorical encoding indicator in data transform dictionary
             self.data_transform_dict["custom_categorical_encoding_ind"] = True
             # Fetching user input list for performing 
-            encoding_list = self.custom_data.get("CategoricalEncodingParam", None)
+            encoding_list = self.custom_data.get("CategoricalEncodingParam", None).copy()
             if encoding_list:
+                volatile = encoding_list.pop("volatile", False)
+                persist = encoding_list.pop("persist", False)
                 onehot_encode_ind = encoding_list.get("OneHotEncodingIndicator", False)
                 ordinal_encode_ind = encoding_list.get("OrdinalEncodingIndicator", False)
                 target_encode_ind = encoding_list.get("TargetEncodingIndicator", False)
@@ -1340,11 +1496,25 @@ class _FeatureEngineering:
         """
         DESCRIPTION:
             Function to perform different numerical transformations using NumApply on numerical features based on user input.
-                    
+
+        PARAMETERS:
+            target_col:
+                Required Argument.
+                Specifies the numerical column for which transformation will be performed.
+                Types: str
+
+            transform_val:
+                Required Argument.
+                Specifies different parameter require for applying numerical transformation.
+                Types: dict     
         """
         # Fetching columns for accumulation
         accumulate_columns = self._extract_list(self.data.columns, [target_col])
         apply_method = transform_val["apply_method"]
+
+        # Setting volatile and persist parameters for performing transformation
+        volatile, persist = self._set_generic_parameters(func_indicator="MathameticalTransformationIndicator",
+                                                         param_name="MathameticalTransformationParam")
         # Adding fit parameters for performing transformation
         fit_params={
             "data": self.data,
@@ -1354,17 +1524,25 @@ class _FeatureEngineering:
             "persist" :True,
             "accumulate" : accumulate_columns
         }
+        # Disabling display table name if persist is True by default
+        if not volatile and not persist:
+            fit_params["display_table_name"] = False
+        
+        if volatile:
+            fit_params["volatile"] = True
+            fit_params["persist"] = False
         # Adding addition details for fit parameters in case of SIGMOID transformation
         if apply_method == "sigmoid":
             sigmoid_style=transform_val["sigmoid_style"]
             fit_params = {**fit_params, "sigmoid_style" : sigmoid_style}
         # Performing transformation on target columns
         transform_output = NumApply(**fit_params).result
-        # Adding transformed data containing table to garbage collector
-        GarbageCollector._add_to_garbagecollector(transform_output._table_name)
+        if not volatile and not persist:
+            # Adding transformed data containing table to garbage collector
+            GarbageCollector._add_to_garbagecollector(transform_output._table_name)
         return transform_output
   
-    def _numerical_transformation(self, target_columns, num_transform_data):
+    def _numerical_transformation(self, target_columns, num_transform_data, volatile, persist):
         """
         DESCRIPTION:
             Function to perform different numerical transformations using Fit and Transform on numerical features based on user input.
@@ -1374,7 +1552,9 @@ class _FeatureEngineering:
         fit_params={
             "data" : self.data,
             "object" : num_transform_data,
-            "object_order_column" : "TargetColumn"
+            "object_order_column" : "TargetColumn",
+            "volatile" : volatile,
+            "persist" : persist
         }
         # Peforming fit with all arguments.
         num_fit_obj = Fit(**fit_params)
@@ -1392,10 +1572,18 @@ class _FeatureEngineering:
             "id_columns" : id_columns,
             "persist" :True
         }
+        # Disabling display table name if persist is True by default
+        if not volatile and not persist:
+            transform_params["display_table_name"] = False
+        
+        if volatile:
+            transform_params["volatile"] = True
+            transform_params["persist"] = False
         # Peforming transformation on target columns
         self.data = Transform(**transform_params).result
-        # Adding transformed data containing table to garbage collector
-        GarbageCollector._add_to_garbagecollector(self.data._table_name)
+        if not volatile and not persist:
+            # Adding transformed data containing table to garbage collector
+            GarbageCollector._add_to_garbagecollector(self.data._table_name)
         self._display_msg(msg="Updated dataset sample after applying numerical transformation:",
                           data=self.data,
                           progress_bar=self.progress_bar)
@@ -1414,8 +1602,11 @@ class _FeatureEngineering:
         # Checking user input for mathematical transformations
         if mat_transform_input:
             # Extracting list required for mathematical transformations
-            mat_transform_list = self.custom_data.get("MathameticalTransformationParam", None)
+            mat_transform_list = self.custom_data.get("MathameticalTransformationParam", None).copy()
+            
             if mat_transform_list:
+                volatile = mat_transform_list.pop("volatile", False)
+                persist = mat_transform_list.pop("persist", False)
                 # Checking for column present in dataset or not
                 _Validators._validate_dataframe_has_argument_columns(list(mat_transform_list.keys()), 
                                                                      "MathameticalTransformationParam", self.data, "df")
@@ -1459,7 +1650,7 @@ class _FeatureEngineering:
                     copy_to_sql(df=transform_data, table_name="automl_num_transform_data", temporary=True)
                     num_transform_data = DataFrame.from_table("automl_num_transform_data") 
                     # Applying transformation using Fit/Transform functions
-                    self._numerical_transformation(target_columns, num_transform_data)
+                    self._numerical_transformation(target_columns, num_transform_data, volatile, persist)
                     # Storing custom numerical transformation parameters and column list in data transform dictionary
                     self.data_transform_dict['custom_numerical_transformation_col'] = target_columns
                     self.data_transform_dict['custom_numerical_transformation_params'] = num_transform_data
@@ -1485,6 +1676,8 @@ class _FeatureEngineering:
             nl_transform_list = self.custom_data.get("NonLinearTransformationParam", None)
             # Extracting list required for non-linear transformation
             if nl_transform_list:
+                volatile = nl_transform_list.pop("volatile", False)
+                persist = nl_transform_list.pop("persist", False)
                 total_combination = len(nl_transform_list)
                 # Generating all possible combination names
                 possible_combination = ["Combination_"+str(counter) for counter in range(1,total_combination+1)]
@@ -1511,12 +1704,14 @@ class _FeatureEngineering:
                             "data" : self.data,
                             "target_columns" : target_columns,
                             "formula" : formula,
-                            "result_column" : result_column
+                            "result_column" : result_column,
+                            "volatile" : volatile,
+                            "persist" : persist
                         }
                         # Performing fit on dataset
                         fit_obj = NonLinearCombineFit(**fit_param)
                         # Updating it for each non-linear combination
-                        self.data_transform_dict['custom_non_linear_transformation_fit_object'].update({comb:fit_obj})
+                        self.data_transform_dict['custom_non_linear_transformation_fit_object'].update({comb:fit_obj.result})
                         # Adding transform params for transformation   
                         transform_params = {
                             "data" : self.data,
@@ -1524,9 +1719,18 @@ class _FeatureEngineering:
                             "accumulate" : self.data.columns,
                             "persist" : True
                         }
+                        # Disabling display table name if persist is True by default
+                        if not volatile and not persist:
+                            transform_params["display_table_name"] = False
+                        
+                        if volatile:
+                            transform_params["volatile"] = True
+                            transform_params["persist"] = False
                         self.data = NonLinearCombineTransform(**transform_params).result
-                        # Adding transformed data containing table to garbage collector
-                        GarbageCollector._add_to_garbagecollector(self.data._table_name)
+
+                        if not volatile and not persist:
+                            # Adding transformed data containing table to garbage collector
+                            GarbageCollector._add_to_garbagecollector(self.data._table_name)
                     else:
                         self._display_msg(inline_msg="Combinations are not as per expectation.",
                                           progress_bar=self.progress_bar)
@@ -1552,29 +1756,64 @@ class _FeatureEngineering:
         anti_select_input = self.custom_data.get("AntiselectIndicator", False) 
         # Checking user input for anti-select columns    
         if anti_select_input:
-            # Extracting list required for anti-select columns
-            anti_select_list = self.custom_data.get("AntiselectParam", None)
-            if(anti_select_list):
-                if all(item in self.data.columns for item in anti_select_list):
-                    # Storing custom anti-select columns indicator and column list in data transform dictionary
-                    self.data_transform_dict['custom_anti_select_columns_ind'] = True
-                    self.data_transform_dict['custom_anti_select_columns'] = anti_select_list
-                    fit_params = {
-                        "data" : self.data,
-                        "exclude" : anti_select_list
-                    }
-                    # Performing transformation for given user input
-                    self.data = Antiselect(**fit_params).result
-                    self._display_msg(msg="Updated dataset sample after performing anti-select columns:",
-                                      data=self.data,
-                                      progress_bar=self.progress_bar)
-                else:
-                    self._display_msg(msg="Columns provided in list are not present in dataset:",
-                                      col_lst=anti_select_list,
-                                      progress_bar=self.progress_bar)         
+            anti_select_params = self.custom_data.get("AntiselectParam", None)
+            if anti_select_params:
+                # Extracting list required for anti-select columns
+                anti_select_list = anti_select_params.get("excluded_columns", None)
+                volatile = anti_select_params.get("volatile", False)
+                persist = anti_select_params.get("persist", False)
+                if(anti_select_list):
+                    if all(item in self.data.columns for item in anti_select_list):
+                        # Storing custom anti-select columns indicator and column list in data transform dictionary
+                        self.data_transform_dict['custom_anti_select_columns_ind'] = True
+                        self.data_transform_dict['custom_anti_select_columns'] = anti_select_list
+                        fit_params = {
+                            "data" : self.data,
+                            "exclude" : anti_select_list,
+                            "volatile" : volatile,
+                            "persist" : persist
+                        }
+                        # Performing transformation for given user input
+                        self.data = Antiselect(**fit_params).result
+                        self._display_msg(msg="Updated dataset sample after performing anti-select columns:",
+                                        data=self.data,
+                                        progress_bar=self.progress_bar)
+                    else:
+                        self._display_msg(msg="Columns provided in list are not present in dataset:",
+                                        col_lst=anti_select_list,
+                                        progress_bar=self.progress_bar)         
             else:
                 self._display_msg(inline_msg="No information provided for performing anti-select columns operation.",
                                   progress_bar=self.progress_bar)
         else:
             self._display_msg(inline_msg="Skipping customized anti-select columns.",
-                              progress_bar=self.progress_bar)
+                              progress_bar=self.progress_bar)
+            
+    def _set_generic_parameters(self,
+                                func_indicator=None,
+                                param_name=None):
+        """
+        DESCRIPTION:
+            Function to set generic parameters.
+        
+        PARAMETERS:     
+            func_indicator:
+                Optional Argument.
+                Specifies the name of function indicator.
+                Types: str
+                
+            param_name:
+                Optional Argument.
+                Specifies the name of the param which contains generic parameters.
+                Types: str
+
+        RETURNS:
+            Tuple containing volatile and persist parameters.
+        """
+        volatile = self.volatile
+        persist = self.persist
+        if self.custom_data is not None and self.custom_data.get(func_indicator, False):
+            volatile = self.custom_data[param_name].get("volatile", False)
+            persist = self.custom_data[param_name].get("persist", False)
+
+        return (volatile, persist)