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

teradataml/automl/feature_engineering.py

@@ -24,7 +24,7 @@ from teradataml.dataframe.dataframe import DataFrame
 from teradataml.dataframe.copy_to import copy_to_sql
 from teradataml import Antiselect
 from teradataml import BincodeFit, BincodeTransform
-from teradataml import ColumnSummary, CategoricalSummary, GetFutileColumns, FillRowId
+from teradataml import CategoricalSummary, ColumnSummary, ConvertTo, GetFutileColumns, FillRowId
 from teradataml import Fit, Transform
 from teradataml import NonLinearCombineFit, NonLinearCombineTransform
 from teradataml import NumApply
@@ -36,6 +36,8 @@ from teradataml import TargetEncodingFit, TargetEncodingTransform
 from sqlalchemy import literal_column
 from teradatasqlalchemy import INTEGER
 from teradataml import display
+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
 
@@ -61,12 +63,12 @@ class _FeatureEngineering:
                 Types: teradataml Dataframe
             
             target_column:
-                Required Arugment.
+                Required Argument.
                 Specifies the name of the target column in "data"..
                 Types: str
             
             model_list:
-                Required Arugment.
+                Required Argument.
                 Specifies the list of models to be used for model training.
                 Types: list
             
@@ -81,7 +83,7 @@ class _FeatureEngineering:
                 Types: int
 
             task_type:
-                Required Arugment.
+                Required Argument.
                 Specifies the task type for AutoML, whether to apply regresion OR classification
                 on the provived dataset.
                 Default Value: "Regression"
@@ -89,7 +91,7 @@ class _FeatureEngineering:
                 Types: str
 
             custom_data:
-                Optional Arugment.
+                Optional Argument.
                 Specifies json object containing user customized input.
                 Types: json object
         """
@@ -120,7 +122,7 @@ class _FeatureEngineering:
          
         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.
                 Default Value: True
@@ -255,7 +257,7 @@ class _FeatureEngineering:
                                   f"Remaining Columns in the data: {self.data.shape[1]}",
                               progress_bar=self.progress_bar)
         else:
-            self._display_msg(inline_msg="Analysis complete. No action taken.",
+            self._display_msg(inline_msg="Analysis completed. No action taken.",
                               progress_bar=self.progress_bar)   
 
         end_time = time.time()
@@ -333,7 +335,7 @@ class _FeatureEngineering:
             f_cols = [row[0] for row in gfc_out.result.itertuples()]
             
             if len(f_cols) == 0:
-                self._display_msg(inline_msg="All categorical columns seem to be significant.",
+                self._display_msg(inline_msg="Analysis indicates all categorical columns are significant. No action Needed.",
                                   progress_bar=self.progress_bar)
             else:
 
@@ -350,128 +352,68 @@ class _FeatureEngineering:
         self._display_msg(msg="Total time to handle less significant features: {:.2f} sec  ".format( end_time - start_time),
                           progress_bar=self.progress_bar,
                           show_data=True)
-
-    def _handle_date_component(self,
-                               date_component_columns,
-                               date_component):  
         
+    def _fetch_date_component(self):
         """
         DESCRIPTION:
-            Function to handle newly generated date components, i.e., day , month and year diff.
-            Based on their distinct values, binning is done with predefined prefix. 
-            Binned component is used further as categorical features.
-            
-        PARAMETERS:
-            date_component_columns:
-                Required Argument.
-                Specifies the list of newly generated differnt component of date features.
-                Types: list
-                
-            date_component:
-                Required Argument.
-                Specifies identifier for the differnt component of date features, i.e., D - Days , M - Months and Y - Year diffs.
-                Types: str 
-            
-        """
-        # Check for day
-        if date_component == "D":
-            prefix_value = "Day_"
-        # Check for month
-        elif date_component == "M":
-            prefix_value = "Month_"
-        # Check for year diff
-        elif date_component == "Y":
-            prefix_value = "Year_diff_"
+            Function to fetch day of week, week of month, month of quarter, quarter of year
+            component from date column. Generate weekend and month half details from day of week and
+            week of month columns respectively. Convert quarter of year and month of quarter
+            component columns to VARCHAR.
         
-        # Deciding bins based on distinct value of date component features.
-        for col in date_component_columns:
-            data_size = self.data.drop_duplicate(col).size
-            if data_size < 4:
-                num_bins = data_size
-            else:
-                num_bins = 4
-            # Performing bincode for converting date component to specific labels
-            fit_params = {
-                        "data": self.data,
-                        "target_columns": col,
-                        "method_type":"Equal-Width",
-                        "nbins": num_bins,
-                        "label_prefix" : prefix_value
-                        }
-            bin_code_fit = BincodeFit(**fit_params)
-            
-            fit_params_map = {"D": "day_component_fit_object",
-                              "M": "month_component_fit_object",
-                              "Y": "year_diff_component_fit_object"}
-            
-            # Storing fit object for each date component in data transform dictionary
-            self.data_transform_dict[fit_params_map[date_component]][col] = bin_code_fit.output
-                
-            accumulate_columns = self._extract_list(self.data.columns, [col])
-            transform_params = {
-                        "data": self.data,
-                        "object": bin_code_fit.output,
-                        "accumulate": accumulate_columns,
-                        "persist": True
-                        }
-            self.data = BincodeTransform(**transform_params).result
-          
-    def _fetch_date_component(self, 
-                              process, 
-                              regex_str, 
-                              columns, 
-                              date_component):
-        
-        """
-        DESCRIPTION:
-            Function to fetch newly generated date component features.
-            Passing ahead for performing binning.
-            
-        PARAMETERS:
-            process:
-                Required Argument.
-                Specifies date component of date feature which is going to be fetched and handled.
-                Types: str
-                
-            regex_str:
-                Required Argument.
-                Specifies regular expression for identifying newly generated date component features.
-                Types: str 
-            
-            columns:
-                Required Argument.
-                Specifies list of newly generated date component features.
-                Types: list
-                
-            date_component:
-                Required Argument.
-                Specifies identifier for the differnt component of date features, i.e., D - Days , M - Months and Y - Year diffs.
-                Types: str
-            
+        RETURNS:
+            List of newly generated date component features.
         """
-        date_component_columns = [col for col in columns if re.search(regex_str+"$", col)]
-        if len(date_component_columns) != 0:
-            self._handle_date_component(date_component_columns,date_component)
-            self._display_msg(msg="Useful {} features:".format(process),
-                              col_lst=date_component_columns,
-                              progress_bar=self.progress_bar)
-            self._display_msg(msg="Updated dataset sample:",
-                              data=self.data,
-                              progress_bar=self.progress_bar)
-                
-        else:
-            self._display_msg("\nNo useful feature found for {} component:".format(process),
-                              progress_bar=self.progress_bar)
+        # List for storing newly generated date component features
+        new_date_components=[]
+        # Extracting weekend, month, quarter details information from date columns
+        date_component_param={}
+        for col in self.date_column_list: 
+            # Generating new column names for extracted date components
+            weekend_col = f'{col}_weekend'
+            month_half_col = f'{col}_month_half'
+            month_of_quarter_col=f'{col}_month_of_quarter'
+            quarter_of_year_col=f'{col}_quarter_of_year'
             
-        return date_component_columns
+            date_component_param =  {
+                **date_component_param,
+                weekend_col: case([(self.data[col].day_of_week().isin([1, 7]), 'yes')], else_='no'),
+                month_half_col: case([(self.data[col].week_of_month().isin([1, 2]), 'first_half')], else_='second_half'),
+                month_of_quarter_col: self.data[col].month_of_quarter(),
+                quarter_of_year_col: self.data[col].quarter_of_year()
+            }
+            # Storing newly generated date component month and quarter columns.
+            # Skipping day of week and week of month columns as they will be used 
+            # later for extracting weekend and month part details.
+            new_date_components.extend([weekend_col, month_half_col, month_of_quarter_col, quarter_of_year_col])
+        # Adding new date component columns to dataset
+        self.data=self.data.assign(**date_component_param)
+        # Dropping date columns as different component columns are extracted.     
+        self.data = self.data.drop(self.date_column_list, axis=1)
+        
+        # Converting remaining component columns to VARCHAR 
+        # So that it will be treated as categorical columns
+        remaining_component_columns = [col for col in self.data.columns if re.search('month_of_quarter|quarter_of_year'+"$", col)]
+        accumulate_columns = self._extract_list(self.data.columns, remaining_component_columns)
+        convertto_params = {
+                            "data" : self.data,
+                            "target_columns" : remaining_component_columns,
+                            "target_datatype" : ["VARCHAR(charlen=20,charset=UNICODE,casespecific=NO)"],
+                            "accumulate" : accumulate_columns,
+                            "persist" : 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)
+        return new_date_components
   
     def _handle_date_columns_helper(self):
         
         """
         DESCRIPTION:
-            Function for dropping irrelevent date features.
-            Extracting day, month and year component from revelent date features.
-            Passing extracted component for performing binning.
+            Function for dropping irrelevent date features. Perform Extraction of different
+            component from revelent date features and transform them.
         """
         
         # Dropping missing value for all date columns
@@ -484,7 +426,7 @@ class _FeatureEngineering:
         # Date columns list eligible for dropping from dataset
         drop_date_cols = []     
         
-        # Checking for single valued date columns
+        # Checking for unique valued date columns
         for col in self.date_column_list:
             if self.data.drop_duplicate(col).size == self.data.shape[0]:
                 drop_date_cols.append(col)
@@ -496,46 +438,18 @@ class _FeatureEngineering:
             self._display_msg(msg='Dropping date features with all unique value:',
                               col_lst = drop_date_cols,
                               progress_bar=self.progress_bar)
-             
-        # Updated date columns list
-        self.date_column_list = [item for item in self.date_column_list if item not in drop_date_cols]
+            # Updated date column list after dropping irrelevant date columns
+            self.date_column_list = [item for item in self.date_column_list if item not in drop_date_cols]
         
-        # List for storing newly generated date component features
-        new_columns=[]
-        
-        # Extracting day, month and year difference from date columns
         if len(self.date_column_list) != 0:
             
-            component_param={}
-            for col in self.date_column_list: 
-                
-                day_column=str(col)+"_day_comp"
-                month_column=str(col)+"_month_comp"
-                year_diff_column=str(col)+"_year_diff_comp"
-                new_columns.extend([day_column,month_column,year_diff_column])
-                day_query=("EXTRACT(DAY FROM {0})".format(col))
-                month_query=("EXTRACT(MONTH FROM {0})".format(col))
-                year_query=("EXTRACT(YEAR FROM CURRENT_DATE) - EXTRACT(YEAR FROM {0})".format(col))
-                component_param[day_column]=literal_column(day_query,INTEGER())
-                component_param[month_column]=literal_column(month_query,INTEGER())
-                component_param[year_diff_column]=literal_column(year_query,INTEGER())
-                
-            self.data=self.data.assign(**component_param)
-            # Storing newly generated date component list along with parameters in data transform dictionary
-            self.data_transform_dict['extract_date_comp_col'] = self.date_column_list
-            self.data_transform_dict['extract_date_comp_param'] = component_param
-         
-            # Dropping date columns as we have already extracted day, month and year in new columns        
-            self.data = self.data.drop(self.date_column_list, axis=1)
+            # List for storing newly generated date component features
+            new_columns=self._fetch_date_component()
             self._display_msg(msg='List of newly generated features from existing date features:',
                               col_lst=new_columns,
                               progress_bar=self.progress_bar)
-            self._display_msg(msg='List of newly generated features from existing date features:',
-                              data=self.data,
-                              progress_bar=self.progress_bar)
-            
+            # Dropping columns with all unique values or single value
             drop_cols=[]
-            
             for col in new_columns:
                 distinct_rows = self.data.drop_duplicate(col).size
                 if  distinct_rows == self.data.shape[0]:
@@ -555,21 +469,11 @@ class _FeatureEngineering:
                 self.data = self.data.drop(drop_cols, axis=1)
                 # Storing extract date component list for drop in data transform dictionary
                 self.data_transform_dict['drop_extract_date_columns'] = drop_cols        
-                
-            # Extracting all newly generated columns    
-            new_columns = [item for item in new_columns if item not in drop_cols]
+                # Extracting all newly generated columns    
+                new_columns = [item for item in new_columns if item not in drop_cols]
             
-            # Storing each date component transformation fit object in data transform dictionary
-            self.data_transform_dict = {**self.data_transform_dict, 
-                                        'day_component_fit_object': {}, 
-                                        'month_component_fit_object': {}, 
-                                        'year_diff_component_fit_object': {}}
-            # Grouping date components based on types i.e., day, month, and year_diff for performing binning
-            if len(new_columns) != 0:
-                self.day_columns = self._fetch_date_component("day", "_day_comp", new_columns, "D")
-                self.month_columns = self._fetch_date_component("month", "_month_comp", new_columns, "M")
-                self.year_diff_columns = self._fetch_date_component("year_diff", "_year_diff_comp", new_columns, "Y")
-                self._display_msg(inline_msg="No useful date component found",
+                self._display_msg(msg='Updated list of newly generated features from existing date features :',
+                                  col_lst=new_columns,
                                   progress_bar=self.progress_bar)
             
             self._display_msg(msg='Updated dataset sample after handling date features:',
@@ -595,7 +499,7 @@ class _FeatureEngineering:
                                if d_type in ["datetime.date","datetime.datetime"]]
                  
         if len(self.date_column_list) == 0:
-            self._display_msg(inline_msg="Dataset does not contain any feature related to dates.",
+            self._display_msg(inline_msg="Analysis Completed. Dataset does not contain any feature related to dates. No action needed.",
                               progress_bar=self.progress_bar)
         else:
             # Storing date column list in data transform dictionary
@@ -622,8 +526,7 @@ class _FeatureEngineering:
         self.data = self.data.dropna(subset=[self.target_column])
         
         obj = ColumnSummary(data=self.data, 
-                            target_columns=self.data.columns, 
-                            volatile=True)
+                            target_columns=self.data.columns)
         
         cols_miss_val={}
         # Iterating over each row in the column summary result
@@ -705,11 +608,15 @@ class _FeatureEngineering:
             self.data_transform_dict['imputation_columns'] = self.imputation_cols
 
         if len(delete_rows) != 0:
+            rows = self.data.shape[0]
             self.data = self.data.dropna(subset=delete_rows)
             msg_val_found=1
             self._display_msg(msg='Deleting rows of these columns for handling missing values:',
                               col_lst=delete_rows,
                               progress_bar=self.progress_bar)
+            self._display_msg(msg=f'Sample of dataset after removing {rows-self.data.shape[0]} rows:',
+                              data=self.data,
+                              progress_bar=self.progress_bar)
             
         if len(drop_cols) != 0:
             self.data = self.data.drop(drop_cols, axis=1)
@@ -719,9 +626,12 @@ class _FeatureEngineering:
             self._display_msg(msg='Dropping these columns for handling missing values:',
                               col_lst=drop_cols,
                               progress_bar=self.progress_bar)
+            self._display_msg(msg=f'Sample of dataset after removing {len(drop_cols)} columns:',
+                              data=self.data,
+                              progress_bar=self.progress_bar)
         
         if len(self.imputation_cols) == 0 and msg_val_found ==0:
-            self._display_msg(inline_msg="No Missing Values Detected.",
+            self._display_msg(inline_msg="Analysis Completed. No Missing Values Detected.",
                               progress_bar=self.progress_bar)
             
         end_time = time.time()
@@ -787,21 +697,19 @@ class _FeatureEngineering:
             
             fit_obj = SimpleImputeFit(data=self.data, 
                                       stats_columns=col_stat, 
-                                      stats=stat, 
-                                      volatile=True)
+                                      stats=stat)
             
             # 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, 
-                                        volatile=True)
+                                        object=fit_obj)
             
             self.data = sm.result
-            self._display_msg(msg="Sample of Data after Imputation:",
+            self._display_msg(msg="Sample of dataset after Imputation:",
                               data=self.data,
                               progress_bar=self.progress_bar)
         else:
-            self._display_msg(inline_msg="No imputation is Required.",
+            self._display_msg(inline_msg="Analysis completed. No imputation required.",
                               progress_bar=self.progress_bar)
               
         end_time = time.time()
@@ -898,6 +806,8 @@ class _FeatureEngineering:
                         }
                         # 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)                 
                         self._display_msg(msg="Updated dataset sample after performing customized missing value imputation:",
                                           data=self.data,
                                           progress_bar=self.progress_bar)
@@ -987,6 +897,8 @@ class _FeatureEngineering:
                         "persist" : True,   
                     }
                     self.data = BincodeTransform(**eql_transform_params).result
+                    # 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)
@@ -1026,6 +938,8 @@ class _FeatureEngineering:
                         "persist" : True   
                     }
                     self.data = BincodeTransform(**var_transform_params).result
+                    # 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)
@@ -1125,7 +1039,10 @@ class _FeatureEngineering:
                           "string_length" : string_length}
         
         # returning dataset after performing string manipulation                 
-        return StrApply(**fit_params).result 
+        transform_output = StrApply(**fit_params).result
+        # 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, 
@@ -1173,8 +1090,10 @@ class _FeatureEngineering:
             "persist" : True
         }
         # Performing one hot encoding transformation
-        transform_obj = OneHotEncodingTransform(**transform_params)
-        self.data = transform_obj.result.drop(drop_lst, axis=1)
+        transform_output = OneHotEncodingTransform(**transform_params).result
+        # 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,
                           ordinal_columns):
@@ -1191,8 +1110,7 @@ class _FeatureEngineering:
         # Adding fit parameters for performing encoding
         fit_params = {
             "data" : self.data,
-            "target_column" : ordinal_columns,
-            "volatile" : True
+            "target_column" : ordinal_columns
         }
         # Performing ordinal encoding fit on target columns
         ord_fit_obj = OrdinalEncodingFit(**fit_params)
@@ -1214,6 +1132,8 @@ class _FeatureEngineering:
         }
         # 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 len(ordinal_columns) == 1 and ordinal_columns[0] == self.target_column:
             self.target_label = ord_fit_obj
@@ -1276,6 +1196,8 @@ class _FeatureEngineering:
             }
             # 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)
     
     def _encoding_categorical_columns(self):
         """
@@ -1308,8 +1230,11 @@ class _FeatureEngineering:
             self._display_msg(msg="ONE HOT Encoding these Columns:",
                               col_lst=ohe_col,
                               progress_bar=self.progress_bar)
+            self._display_msg(msg="Sample of dataset after performing one hot encoding:",
+                              data=self.data,
+                              progress_bar=self.progress_bar)
         else:
-            self._display_msg(inline_msg="Encoding not required.",
+            self._display_msg(inline_msg="Analysis completed. No categorical columns were found.",
                               progress_bar=self.progress_bar)
         
         # List of columns after one hot
@@ -1434,7 +1359,10 @@ class _FeatureEngineering:
             sigmoid_style=transform_val["sigmoid_style"]
             fit_params = {**fit_params, "sigmoid_style" : sigmoid_style}
         # Performing transformation on target columns
-        return NumApply(**fit_params).result
+        transform_output = NumApply(**fit_params).result
+        # 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):
         """
@@ -1465,7 +1393,9 @@ class _FeatureEngineering:
             "persist" :True
         }
         # Peforming transformation on target columns
-        self.data = Transform(**transform_params).result  
+        self.data = Transform(**transform_params).result
+        # 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)
@@ -1595,6 +1525,8 @@ class _FeatureEngineering:
                             "persist" : True
                         }
                         self.data = NonLinearCombineTransform(**transform_params).result
+                        # 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)

teradataml/automl/feature_exploration.py

@@ -21,6 +21,7 @@ from teradataml import ColumnSummary, CategoricalSummary, GetFutileColumns
 from teradataml import OutlierFilterFit, OutlierFilterTransform
 from teradataml.hyperparameter_tuner.utils import _ProgressBar
 from teradataml.common.messages import Messages, MessageCodes
+from teradataml import display as dp
 
 def _is_terminal():
     """
@@ -158,13 +159,14 @@ class _FeatureExplore:
             Internal function displays the column summary of categorical column such as 
             datatype, null count, non null count, zero count.
         """
+        dp.max_rows = self.data.shape[1]
         # Column Summary of all columns of dataset
         obj = ColumnSummary(data=self.data,
-                            target_columns=self.data.columns,
-                            volatile=True)
+                            target_columns=self.data.columns)
         self._display_msg(msg='\nColumn Summary:',
                           data=obj.result,
                           show_data=True)
+        dp.max_rows = 10
                
     def _categorical_summary(self, 
                              categorical_columns=None):
@@ -503,6 +505,11 @@ class _FeatureExplore:
                     progress_bar.update(msg=msg, data=col_lst if col_lst else data if data is not None else None, 
                                         progress=False, 
                                         ipython=not self.terminal_print)
+                    # Displaying shape of data
+                    if data is not None:
+                        progress_bar.update(msg=f'{data.shape[0]} rows X {data.shape[1]} columns',
+                                            progress=False,
+                                            ipython=not self.terminal_print)
                 # If an inline message is provided instead
                 elif inline_msg:
                     # Update the progress bar with the inline message

teradataml/automl/model_evaluation.py

@@ -18,6 +18,7 @@ import time
 
 # Teradata libraries
 from teradataml.dataframe.dataframe import DataFrame
+from teradataml.automl.model_training import _ModelTraining
 
 
 class _ModelEvaluator:
@@ -38,12 +39,12 @@ class _ModelEvaluator:
                 Types: teradataml Dataframe
             
             target_column:
-                Required Arugment.
+                Required Argument.
                 Specifies the target column present inside the dataset.
                 Types: str
                 
             task_type:
-                Required Arugment.
+                Required Argument.
                 Specifies the task type for AutoML, whether to apply regresion OR classification
                 on the provived dataset.
                 Default Value: "Regression"
@@ -115,37 +116,24 @@ class _ModelEvaluator:
         model = self.model_info.loc[rank]
         
         # Defining eval_params 
-        eval_params = {"id_column": "id",
-                        "accumulate": self.target_column}
-
-        # eval_params for Classification
-        if self.task_type != "Regression":
-            # XGboost
-            if model['Name'] == 'xgboost':
-                eval_params['model_type'] = 'Classification'
-                eval_params['object_order_column'] = ['task_index', 'tree_num', 'iter','class_num', 'tree_order']
-            else:
-            # DF,KNN,SVM,GLM
-                eval_params['output_prob'] = True
-        else:
-        # eval_params for Regression in XGboost
-            if model['Name'] == 'xgboost':
-                eval_params['model_type'] = 'Regression'
-                eval_params['object_order_column'] = ['task_index', 'tree_num', 'iter', 'tree_order']
-                    
+        eval_params = _ModelTraining._eval_params_generation(model['Name'],
+                                                             self.target_column,
+                                                             self.task_type)
         
         # Test Data
-        test = DataFrame(self.table_name_mapping['{}_test'.format(model['Feature selection'])])
+        test = DataFrame(self.table_name_mapping['{}_test'.format(model['Feature-Selection'])])
 
         # Getting test data from table
         if not self.test_data_ind:
             # Test Data
-            test = DataFrame(self.table_name_mapping['{}_test'.format(model['Feature selection'])])
+            test = DataFrame(self.table_name_mapping['{}_test'.format(model['Feature-Selection'])])
         else:
-            test = DataFrame(self.table_name_mapping['{}_new_test'.format(model['Feature selection'])])
+            test = DataFrame(self.table_name_mapping['{}_new_test'.format(model['Feature-Selection'])])
+
+        print("\nFollowing model is being used for generating prediction :")
+        print("Model ID :", model['Model-ID'],
+              "\nFeature Selection Method :",model['Feature-Selection'])
 
-        print(model['Name'], model['Feature selection'])
-        
         # Evaluation and predictions 
         if model['Name'] == 'knn':
             metrics = model['model-obj'].evaluate(test_data=test)