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

teradataml/automl/custom_json_utils.py

@@ -64,6 +64,7 @@ class _GenerateCustomJson:
         RAISES:
             ValueError: If input data is empty or not valid.
         """
+        
         while True:
             try:
                 # Checking if input is empty
@@ -76,7 +77,12 @@ class _GenerateCustomJson:
                 elif value_type == 'float':
                     result = [float(value.strip()) for value in input_data.split(',')]
                 elif value_type == 'bool':
-                    result = [True if value.strip().lower() == 'true' else False for value in input_data.split(',')]
+                    result = []
+                    for value in input_data.split(','):
+                        if value.strip().lower() not in ['true', 'false']:
+                            raise ValueError("\nInvalid input. Please provide a valid input from 'True' or 'False'.")
+                        else:
+                            result.append(True if value.strip().lower() == 'true' else False)
                 else:
                     result = [value.strip() for value in input_data.split(',')]
                     
@@ -242,17 +248,19 @@ class _GenerateCustomJson:
                 input("\nEnter the list of indices you want to customize in feature engineering phase: "), 
                 'int', list(fe_customize_options.keys()))
             
+            # Setting back_key and exit_key
+            fe_back_key, fe_exit_key = 8, 9
             # Flag variable to back to main menu
             fe_exit_to_main_flag = False
             # Flag variable to exit from main menu
             # Handling the scenario when input contains both index 8 and 9
-            fe_exit_from_main_flag = 9 in fe_phase_idx
+            fe_exit_from_main_flag = fe_exit_key in fe_phase_idx
 
             # Processing each functionality for customization in sorted order  
             for index in sorted(fe_phase_idx):
-                if index == 8 or index == 9:
+                if index == fe_back_key or index == fe_exit_key:
                     fe_exit_to_main_flag = True
-                    if index == 9:
+                    if index == fe_exit_key:
                         fe_exit_from_main_flag = True 
                     break
                 fe_method_map[index](self.fe_flag[index])
@@ -273,12 +281,11 @@ class _GenerateCustomJson:
         print("\nCustomizing Data Preparation Phase ...")
         # Available options for customization of data preparation phase
         dp_customize_options = {
-            1: 'Customize Train Test Split',
-            2: 'Customize Data Imbalance Handling',
-            3: 'Customize Outlier Handling',
-            4: 'Customize Feature Scaling',
-            5: 'Back to main menu',
-            6: 'Generate custom json and exit'
+            1: 'Customize Data Imbalance Handling',
+            2: 'Customize Outlier Handling',
+            3: 'Customize Feature Scaling',
+            4: 'Back to main menu',
+            5: 'Generate custom json and exit'
             }
         
         while True:
@@ -290,10 +297,9 @@ class _GenerateCustomJson:
             print("-"*80)
             # Mapping each index to corresponding functionality
             de_method_map = {
-                1: self._get_customize_input_train_test_split,
-                2: self._get_customize_input_data_imbalance_handling,
-                3: self._get_customize_input_outlier_handling,
-                4: self._get_customize_input_feature_scaling
+                1: self._get_customize_input_data_imbalance_handling,
+                2: self._get_customize_input_outlier_handling,
+                3: self._get_customize_input_feature_scaling
             }
             
             # Taking required input for customizing data preparation.
@@ -301,17 +307,19 @@ class _GenerateCustomJson:
                 input("\nEnter the list of indices you want to customize in data preparation phase: "),
                 'int', list(dp_customize_options.keys()))
             
+            # Setting back_key and exit_key
+            de_back_key, de_exit_key = 4, 5
             # Flag variable to back to main menu
             de_exit_to_main_flag = False
             # Flag variable to exit from main menu
-            # Handling the scenario when input contains both index 5 and 6
-            de_exit_from_main_flag = 6 in dp_phase_idx
+            # Handling the scenario when input contains both back_key and exit_key
+            de_exit_from_main_flag = de_exit_key in dp_phase_idx
             
             # Processing each functionality for customization in sorted order
             for index in sorted(dp_phase_idx):
-                if index == 5 or index == 6:
+                if index == de_back_key or index == de_exit_key:
                     de_exit_to_main_flag = True
-                    if index == 6:
+                    if index == de_exit_key:
                         de_exit_from_main_flag = True
                     break
                 de_method_map[index](self.de_flag[index])
@@ -373,6 +381,35 @@ class _GenerateCustomJson:
         # Returning flag to exit from main menu
         return mt_exit_from_main_flag
     
+    def _set_generic_arguement(self,
+                               func_name):
+        """
+        DESCRIPTION:
+            Internal Function to set generic arguments for each functionality.
+
+        PARAMETERS:
+            func_name:
+                Required Argument.
+                Specifies the name of functionality for which generic arguments are to be set.
+                Types: str
+        """
+        generic_flag = {
+            0: 'Default',
+            1: 'volatile',
+            2: 'persist'
+        }
+        print("\nAvailable options for generic arguments: ")
+        for index, method in generic_flag.items():
+            print(f"Index {index}: {method}")
+        inp = self._process_list_input(
+                input("\nEnter the indices for generic arguments : "), 'int')[0]
+        if inp == 0:
+            return
+        if inp == 1:
+            self.data[func_name]['volatile'] = True
+        elif inp == 2:
+            self.data[func_name]['persist'] = True
+    
     def _get_customize_input_missing_value_handling(self, 
                                                     first_execution_flag=False):
         """
@@ -471,7 +508,8 @@ class _GenerateCustomJson:
                                 input(f"\nEnter the specific literal value for imputing missing "
                                       f"values for feature {feature}: "))
                             self.data['MissingValueHandlingParam']['LiteralImputeValue'].append(literal_value)
-
+        # Setting generic arguments
+        self._set_generic_arguement(func_name='MissingValueHandlingParam')
         print("\nCustomization of missing value handling has been completed successfully.")
         
     def _get_customize_input_bin_code_encoding(self,
@@ -554,6 +592,7 @@ class _GenerateCustomJson:
                         # Setting label for corresponding bin
                         self.data['BincodeParam'][feature][bin_num]['label'] = self._process_single_input(
                             input(f"\nEnter the label for bin {num} of feature {feature}: "))
+            self._set_generic_arguement(func_name='BincodeParam')
 
         print("\nCustomization of bincode encoding has been completed successfully.")          
             
@@ -621,7 +660,8 @@ class _GenerateCustomJson:
                         input(f"\nEnter the start value required for string manipulation "
                               f"operation for feature {feature}: "), 'int')
                     self.data['StringManipulationParam'][feature]["StartIndex"] = str_mnpl_start
-
+        
+        self._set_generic_arguement(func_name='StringManipulationParam')
         print("\nCustomization of string manipulation has been completed successfully.")
 
     
@@ -713,7 +753,8 @@ class _GenerateCustomJson:
                                   f"for target encoding method for feature {feature}: "), 'int')
                         self.data['CategoricalEncodingParam']['TargetEncodingList'][feature]["num_distinct_responses"] = \
                             num_distinct_responses
-
+        
+        self._set_generic_arguement(func_name='CategoricalEncodingParam')
         print("\nCustomization of categorical encoding has been completed successfully.")
             
     def _get_customize_input_mathematical_transformation(self,
@@ -782,6 +823,7 @@ class _GenerateCustomJson:
                               f"transformation for feature {feature}: "), 'int')
                     self.data['MathameticalTransformationParam'][feature]["exponent"] = exponent
         
+        self._set_generic_arguement(func_name='MathameticalTransformationParam')
         print("\nCustomization of mathematical transformation has been completed successfully.")
 
     def _get_customize_input_nonlinear_transformation(self,
@@ -828,6 +870,7 @@ class _GenerateCustomJson:
                 input(f"\nEnter the resultant feature for non-linear combination {num}: "))
             self.data['NonLinearTransformationParam'][combination]["result_column"] = result_column
 
+        self._set_generic_arguement(func_name='NonLinearTransformationParam')
         print("\nCustomization of nonlinear transformation has been completed successfully.")
 
     def _get_customize_input_antiselect(self,
@@ -850,35 +893,12 @@ class _GenerateCustomJson:
         print("\nCustomizing Antiselect Features ...")
         # Setting indicator and parameter for antiselect
         self.data['AntiselectIndicator'] = True
-        self.data['AntiselectParam'] = self._process_list_input(
+        self.data['AntiselectParam'] = {}
+        self.data['AntiselectParam']['excluded_columns'] = self._process_list_input(
             input("\nEnter the feature or list of features for antiselect: "))
 
+        self._set_generic_arguement(func_name='AntiselectParam')
         print("\nCustomization of antiselect features has been completed successfully.")
-            
-    def _get_customize_input_train_test_split(self,
-                                              first_execution_flag=False):
-        """
-        DESCRIPTION:
-            Function takes user input to generate custom json paramaters for train test split.
-        
-        PARAMETERS:
-            first_execution_flag:
-                Optional Argument.
-                Specifies the flag to check if the function is called for the first time.
-                Default Value: False
-                Types: bool
-        """
-        if first_execution_flag:
-            print("\nWARNING : Reinitiated train test split customization. "
-                  "Overwriting the previous input.")
-
-        print("\nCustomizing Train Test Split ...")
-        # Setting indicator and parameter for customizing train test split
-        self.data['TrainTestSplitIndicator'] = True
-        self.data['TrainingSize']= self._process_single_input(
-            input("\nEnter the train size for train test split: "), 'float')
-
-        print("\nCustomization of train test split has been completed successfully.")
     
     def _get_customize_input_data_imbalance_handling(self,
                                                      first_execution_flag):
@@ -997,6 +1017,7 @@ class _GenerateCustomJson:
                 self.data['OutlierFilterParam'][feature]["replacement_value"] = \
                 self._process_single_input(replacement_value, replacement_value_types[value_type_idx])
 
+        self._set_generic_arguement(func_name='OutlierFilterParam')
         print("\nCustomization of outlier handling has been completed successfully.")
         
     def _get_customize_input_feature_scaling(self,
@@ -1027,6 +1048,7 @@ class _GenerateCustomJson:
                            6: 'std',
                            7: 'sum',
                            8: 'ustd'}
+        self.data['FeatureScalingParam'] = {}
         # Displaying available methods for scaling
         print("\nAvailable feature scaling methods with corresponding indices:")
         for index, value in scaling_methods.items():
@@ -1039,7 +1061,7 @@ class _GenerateCustomJson:
         
         # Handling for 'rescale' method
         if scaling_methods_idx != 5:
-            self.data['FeatureScalingMethod'] = scaling_methods[scaling_methods_idx]
+            self.data['FeatureScalingParam']['FeatureScalingMethod'] = scaling_methods[scaling_methods_idx]
         else:
             rescaling_params = {
                 1: 'lower-bound',
@@ -1085,8 +1107,9 @@ class _GenerateCustomJson:
             elif ub:
                 scale_method = f'rescale(ub={ub})'
             # Setting parameters for feature scaling
-            self.data['FeatureScalingMethod'] = scale_method 
+            self.data['FeatureScalingParam']['FeatureScalingMethod'] = scale_method 
         
+        self._set_generic_arguement(func_name='FeatureScalingParam')
         print("\nCustomization of feature scaling has been completed successfully.")
     
     def _get_allowed_hyperparameters(self, model_name):
@@ -1222,10 +1245,6 @@ class _GenerateCustomJson:
             
         update_methods = {1: 'ADD', 
                           2: 'REPLACE'}
-        # Displaying available update methods for hyperparameter tuning
-        print("\nAvailable hyperparamters update methods with corresponding indices:")
-        for index, method in update_methods.items():
-            print(f"Index {index}: {method}")
 
         # Getting list of models for hyperparameter tuning    
         model_idx_list = self._process_list_input(
@@ -1247,24 +1266,83 @@ class _GenerateCustomJson:
                 input(f"\nEnter the list of hyperparameter indices for model '{model_name}': "),
                 'int', list(allowed_hyperparameters.keys()))
             
-                # Setting parameters for each hyperparameter of model
+            # Setting parameters for each hyperparameter of model
             for hyperparameter in model_hyperparameter_list_idx:
                 hyperparameter_name = allowed_hyperparameters[hyperparameter]
                 self.data['HyperparameterTuningParam'][model_name][hyperparameter_name] = {}
-                method_idx = self._process_single_input(
-                    input(f"\nEnter the index of corresponding update method for hyperparameters "
-                        f"'{hyperparameter_name}' for model '{model_name}': "), 'int', list(update_methods.keys()))
-                # Setting update method for hyperparameter
-                self.data['HyperparameterTuningParam'][model_name][hyperparameter_name]["Method"] = \
-                    update_methods[method_idx]
+
+                self._display_example_hyperparameter(hyperparameter_name)
                 
                 hyperparameter_value = input(f"\nEnter the list of value for hyperparameter "
                                                 f"'{hyperparameter_name}' for model '{model_name}': ")
                 
                 hyperparameter_type = self._get_allowed_hyperparameters_types(hyperparameter_name)
-    
+
                 # Setting hyperparameter value specific to each hyperparameter
                 self.data['HyperparameterTuningParam'][model_name][hyperparameter_name]["Value"] = \
                     self._process_list_input(hyperparameter_value, hyperparameter_type)
+                
+                # Displaying available update methods for hyperparameter tuning
+                print("\nAvailable hyperparamters update methods with corresponding indices:")
+                for index, method in update_methods.items():
+                    print(f"Index {index}: {method}")
+                
+                method_idx = self._process_single_input(
+                    input(f"\nEnter the index of corresponding update method for hyperparameters "
+                        f"'{hyperparameter_name}' for model '{model_name}': "), 'int', list(update_methods.keys()))
+                
+                # Setting update method for hyperparameter
+                self.data['HyperparameterTuningParam'][model_name][hyperparameter_name]["Method"] = \
+                    update_methods[method_idx]
         
         print("\nCustomization of model hyperparameter has been completed successfully.")
+
+    def _display_example_hyperparameter(self, hyperparameter_name):
+        """
+        DESCRIPTION:
+            Function to display example hyperparameter values for different hyperparameters.
+            
+        PARAMETERS:
+            hyperparameter_name:
+                Required Argument.
+                Specifies the hyperparameter for which example values are required.
+                Types: str      
+        """
+        # Setting example hyperparameter values for different hyperparameters
+        example_hyperparameters = {
+            'min_impurity' : ([0.1,0.6], 'float'),
+            'max_depth' : ([1,5,10], 'int'),
+            'min_node_size' : ([1,20,100], 'int'),
+            'num_trees' : ([10,50,100], 'int'),
+            'k' : ([5,25,100], 'int'),
+            'shrinkage_factor': ([0.1,0.5,1.0], 'float'),
+            'alpha' : ([0.1,0.5,1.0], 'float'),
+            'learning_rate' : (['constant','optimal','invtime','adaptive'], 'str'),
+            'initial_eta' : ([0.05,0.1], 'float'),
+            'momentum' : ([0.65,0.95], 'float'),
+            'iter_num_no_change' : ([25,50,100], 'int'),
+            'iter_max' : ([10,100,300], 'int'),
+            'batch_size' : ([10,50,100], 'int'),
+            'tolerance' : ([0.0001,0.01], 'float'),
+            'nesterov' : (['true','false'], 'bool'),
+            'intercept' : (['true','false'], 'bool'),
+            'local_sgd_iterations' : ([10,25,50], 'int'),
+            'iter_num' : ([10,50,100], 'int')
+        }
+
+        print(f"\nExample values for hyperparameter '{hyperparameter_name}' :")
+        if hyperparameter_name in example_hyperparameters:
+            values = example_hyperparameters[hyperparameter_name]
+
+            # Setting example values for hyperparameter
+            if all(isinstance(x, str) for x in values[0]):
+                example_value = ', '.join(f"'{s}'" for s in values[0])
+            else:
+                example_value = ', '.join(map(str, values[0]))
+            
+            # Displaying example values for hyperparameter
+            print(f"* Sample value : {example_value}")
+
+            # Displaying example type for hyperparameter
+            print(f"* Type : {values[1]}")
+