teradataml 20.0.0.4__py3-none-any.whl → 20.0.0.5__py3-none-any.whl

teradataml/automl/__init__.py

@@ -188,6 +188,9 @@ class AutoML:
                         results are persisted in a table; otherwise,
                         results are garbage collected at the end of the
                         session.
+                        Note:
+                            * User is responsible for cleanup of the persisted tables. List of persisted tables
+                              in current session can be viewed using get_persisted_tables() method.
                         Default Value: False
                         Types: bool
                     
@@ -476,8 +479,13 @@ class AutoML:
         self._is_fit_called = False 
         self._is_load_model_called = False
         self.kwargs = kwargs
-        self.table_name_mapping={}
-        
+        self.table_name_mapping = {}    
+        # Stores the table name of all intermediate datas
+        self._intermediate_table_names={}
+        self._auto_dataprep = False
+        self._phases = None
+        self._progressbar_prefix = "AutoML Running:"
+
     @collect_queryband(queryband="AutoML_fit")    
     def fit(self,
             data,
@@ -602,15 +610,25 @@ class AutoML:
         clf = task_cls(self.data, self.target_column, self.custom_data)
         
         self.model_info, self.leader_board, self.target_count, self.target_label, \
-            self.data_transformation_params, self.table_name_mapping = getattr(clf, cls_method)(
-                                                                       model_list = self.model_list,
-                                                                       auto = self.auto,
-                                                                       verbose = self.verbose,
-                                                                       max_runtime_secs = self.max_runtime_secs, 
-                                                                       stopping_metric = self.stopping_metric, 
-                                                                       stopping_tolerance = self.stopping_tolerance,
-                                                                       max_models = self.max_models,
-                                                                       **self.kwargs)
+            self.data_transformation_params, self._intermediate_table_names = getattr(clf, cls_method)(
+                                                                              model_list = self.model_list,
+                                                                              auto = self.auto,
+                                                                              verbose = self.verbose,
+                                                                              max_runtime_secs = self.max_runtime_secs, 
+                                                                              stopping_metric = self.stopping_metric, 
+                                                                              stopping_tolerance = self.stopping_tolerance,
+                                                                              max_models = self.max_models,
+                                                                              auto_dataprep = self._auto_dataprep,
+                                                                              automl_phases = self._phases,
+                                                                              progress_prefix = self._progressbar_prefix,
+                                                                              **self.kwargs)
+        
+        
+        # table_name_mapping stores the table name of all intermediate datas (lasso, rfe, pca)
+        # used for training models
+        keys_to_extract = ['lasso_train', 'rfe_train', 'pca_train']
+        self.table_name_mapping = {key: self._intermediate_table_names[key] for key in keys_to_extract
+                                   if key in self._intermediate_table_names}
 
         # Model Evaluation Phase
         self.m_evaluator = _ModelEvaluator(self.model_info, 
@@ -680,13 +698,9 @@ class AutoML:
             >>> prediction = automl_obj.predict(admissions_test, rank=3, use_loaded_models=True)
             >>> prediction
         """
-        # Checking if fit or load model is called before predict, If not raise error
-        if not self._is_fit_called and not self._is_load_model_called:
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'predict' method", \
-                                       "'fit' or 'load' method must be called before" \
-                                       " running predict.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        # Raise error if fit is not called before predict
+        _Validators._validate_dependent_method("predict", ["fit", "load"],
+                                                [self._is_fit_called, self._is_load_model_called])
 
         # Appending predict arguments to list for validation.
         arg_info_pred_matrix = []
@@ -862,13 +876,10 @@ class AutoML:
             >>> evaluation = automl_obj.evaluate(admissions_test, rank=3, use_loaded_models=True)
             >>> evaluation
         """
-        if not self._is_fit_called and not self._is_load_model_called:
-            # raise ValueError("fit() method must be called before evaluating.")
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'evaluate' method", \
-                                       "'fit' or 'load' method must be called before" \
-                                       " running evaluate.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        # Raising exception if fit or load model is not called before evaluate
+        _Validators._validate_dependent_method("evaluate", ["fit", "load"],
+                                               [self._is_fit_called, self._is_load_model_called])
+
         # Appending evaluate arguments to list for validation.
         arg_info_pred_matrix = []
         arg_info_pred_matrix.append(["data", data, False, (DataFrame), True])
@@ -1017,13 +1028,9 @@ class AutoML:
             # Generate leaderboard using leaderboard() method on "automl_obj".
             >>> automl_obj.leaderboard()
         """
-        if not self._is_fit_called:
-            # raise ValueError("fit() method must be called before generating leaderboard.")
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'leaderboard' method", \
-                                       "'fit' method must be called before" \
-                                       " generating leaderboard.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        # Raise error if fit is not called before leaderboard
+        _Validators._validate_dependent_method("leaderboard", "fit", self._is_fit_called)
+
         return self.leader_board
         
     @collect_queryband(queryband="AutoML_leader")    
@@ -1046,13 +1053,9 @@ class AutoML:
             # Display best performing model using leader() method on "automl_obj".
             >>> automl_obj.leader()   
         """
-        if not self._is_fit_called:
-            # raise ValueError("fit() method must be called before generating leader.")
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'leader' method", \
-                                       "'fit' method must be called before" \
-                                       " generating leader.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        # Raise error if fit is not called before leader
+        _Validators._validate_dependent_method("leader", "fit", self._is_fit_called)
+
         record = self.leader_board
         if not _is_terminal():
             display(record[record['RANK'] == 1])
@@ -1125,13 +1128,9 @@ class AutoML:
             >>> automl_obj.model_hyperparameters(rank=1)
         """
 
-        if not self._is_fit_called and not self._is_load_model_called:
-            # raise ValueError("fit() or load() method must be called before getting hyperparameters.")
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'model_hyperparameters' method",
-                                       "No models available to get hyperparameters. " \
-                                       "Run 'fit()' or 'load()' methods to get models.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        # Raise error if fit or load model is not called before model_hyperparameters
+        _Validators._validate_dependent_method("model_hyperparameters", ["fit", "load"],
+                                               [self._is_fit_called, self._is_load_model_called])
         
         arg_info_matrix = []
         arg_info_matrix.append(["rank", rank, True, (int), True])
@@ -1270,28 +1269,18 @@ class AutoML:
         start_rank, end_rank = ranks.start, ranks.stop
 
         # Check if both parts are non-negative integers
-        if not (start_rank > 0 and end_rank > 0):
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'deploy' method", \
-                                       "Provided start and end rank in 'ranks' "\
-                                       "must be positive non-zero integers.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        _Validators._validate_positive_int(start_rank, "ranks(start)")
+        _Validators._validate_positive_int(end_rank, "ranks(end)")
 
         # Check if start_rank is less than or equal to end_rank
         if start_rank > end_rank:
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'deploy' method", \
-                                       "Provided start rank in 'ranks' must be less than"\
-                                       " or equal to end rank in 'ranks'.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+            err = "Provided start rank in 'ranks' must be less than or equal to end rank in 'ranks'."
+            self._raise_error("deploy", err)
         
         # check end rank is less than or equal to total models
         if end_rank > self.leader_board.RANK.max():
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                       "'deploy' method", \
-                                       "Provided end rank in 'ranks' must be less than"\
-                                       " or equal to total models available.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+            err = "Provided end rank in 'ranks' must be less than or equal to total models available."
+            self._raise_error("deploy", err)
         
         return start_rank, end_rank
     
@@ -1356,12 +1345,7 @@ class AutoML:
             >>> obj.deploy("model_table", ranks=range(2,6))
         """ 
         # raise Error if fit is not called
-        if not self._is_fit_called:
-            err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
-                                    "'deploy' method", \
-                                    "'fit' method must be called before" \
-                                    " 'deploy'.")
-            raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+        _Validators._validate_dependent_method("deploy", "fit", self._is_fit_called)
 
         # Appending arguments to list for validation
         arg_info_matrix = []
@@ -1808,6 +1792,185 @@ class AutoML:
 
         db_drop_table(table_name)
     
+    @collect_queryband(queryband="AutoML_get_persisted_tables")
+    def get_persisted_tables(self):
+        """
+        DESCRIPTION:
+            Get the list of the tables that are persisted in the database.
+            Note:
+                * User is responsible for keeping track of the persistent tables 
+                  and cleanup of the same if required.
+
+        PARAMETERS:
+            None
+
+        RETURNS:
+            Dictionary, containing the list of table names that mapped to the stage
+            at which it was generated.
+
+        RAISES:
+            TeradataMlException.
+
+        EXAMPLES:
+            # Create an instance of the AutoML called "obj" 
+            # by referring "AutoML() or AutoRegressor() or AutoClassifier()" method.
+            # 'persist' argument must be set to True in the AutoML object.
+            >>> obj = AutoML(verbose=2, max_models=10, persist=True)
+
+            # Load and fit the data.
+            >>> load_example_data("teradataml", "titanic")
+            >>> titanic_data = DataFrame("titanic")
+            >>> obj.fit(data = titanic_data, target_column = titanic.survived)
+
+            # Get the list of tables that are persisted in the database.
+            >>> obj.get_persisted_tables()
+        """
+        # Check if fit is called
+        _Validators._validate_dependent_method("get_persisted_tables", "fit", self._is_fit_called)
+        
+        # check if persist is passed as argument and is set to True
+        persist_val = True if self.kwargs.get('persist', False) else None
+
+        _Validators._validate_dependent_argument("get_persisted_tables", True,
+                                                 "persist", persist_val,
+                                                 msg_arg_value='True')
+
+        # result table names
+        return self._intermediate_table_names
+
+    def _raise_error(self, method_name, error_msg):
+        """
+        DESCRIPTION:
+            Internal Function raises an error message when a method
+            fails to execute.
+
+        PARAMETERS:
+            method_name:
+                Required Argument.
+                Specifies the method name that failed to execute.
+                Types: str
+
+            error_msg:
+                Required Argument.
+                Specifies the error message to be displayed.
+                Types: str
+
+        RAISES:
+            TeradataMlException.
+
+        EXAMPLES:
+            >>> self._raise_error("fit", "fit() method must be called before 'deploy'.")
+        """
+        err = Messages.get_message(MessageCodes.FUNC_EXECUTION_FAILED,
+                                   f'{method_name} method',
+                                   error_msg)
+        raise TeradataMlException(err, MessageCodes.EXECUTION_FAILED)
+    
+    @staticmethod
+    def visualize(**kwargs):
+        """
+        DESCRIPTION:
+            Function visualizes the data using various plots such as heatmap, 
+            pair plot, histogram, univariate plot, count plot, box plot, and target distribution.
+
+        PARAMETERS:
+            data:
+                Required Argument.
+                Specifies the input teradataml DataFrame for plotting.
+                Types: teradataml Dataframe
+
+            target_column:
+                Required Argument.
+                Specifies the name of the target column in "data".
+                Note:
+                    * "target_column" must be of numeric type.
+                Types: str
+
+            plot_type:
+                Optional Argument.
+                Specifies the type of plot to be displayed.
+                Default Value: "target"
+                Permitted Values: 
+                    * "heatmap": Displays a heatmap of feature correlations.
+                    * "pair": Displays a pair plot of features.
+                    * "density": Displays a density plot of features.
+                    * "count": Displays a count plot of categorical features.
+                    * "box": Displays a box plot of numerical features.
+                    * "target": Displays the distribution of the target variable.
+                    * "all": Displays all the plots.
+                Types: str, list of str
+
+            length:
+                Optional Argument.
+                Specifies the length of the plot.
+                Default Value: 10
+                Types: int
+
+            breadth:
+                Optional Argument.
+                Specifies the breadth of the plot.
+                Default Value: 8
+                Types: int
+
+            columns:
+                Optional Argument.
+                Specifies the column names to be used for plotting.
+                Types: str or list of string
+
+            max_features:
+                Optional Argument.
+                Specifies the maximum number of features to be used for plotting.
+                Default Value: 10
+                Note:
+                    * It applies separately to categorical and numerical features.
+                Types: int
+
+            problem_type:
+                Optional Argument.
+                Specifies the type of problem.
+                Permitted Values:
+                    * 'regression'
+                    * 'classification'
+                Types: str
+            
+        RETURNS:
+            None
+
+        RAISES:
+            TeradataMlException.
+
+        EXAMPLES:
+            # Import either of AutoML or AutoClassifier or AutoRegressor or Autodataprep
+            # from teradataml.
+            >>> from teradataml import AutoML
+            >>> from teradataml import DataFrame
+            >>> load_example_data("teradataml", "titanic")
+            >>> titanic_data = DataFrame("titanic")
+            # Example 1: Visualize the data using AutoML class.
+            >>> AutoML.visualize(data = titanic_data,
+            ...                  target_column = 'survived',
+            ...                  plot_type = ['heatmap', 'pair', 'histogram', 'target'],
+            ...                  length = 10,
+            ...                  breadth = 8,
+            ...                  max_features = 10,
+            ...                  problem_type = 'classification')
+
+            # Example 2: Visualize the data using AutoDataPrep class.
+            >>> from teradataml import AutoDataPrep
+            >>> obj = AutoDataPrep(task_type="classification")
+            >>> obj.fit(data = titanic_data, target_column = 'survived')
+
+            # Retrieve the data from AutoDataPrep object.
+            >>> datas = obj.get_data()
+
+            >>> AutoDataPrep.visualize(data = datas['lasso_train'],
+            ...                        target_column = 'survived',
+            ...                        plot_type = 'all'
+            ...                        length = 20,
+            ...                        breadth = 15)
+        """  
+        _FeatureExplore._visualize(**kwargs)          
+
     @staticmethod
     def generate_custom_config(file_name = "custom"):
         """
@@ -1892,7 +2055,7 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
         
         
     def _regression(self,
-                    model_list = None, 
+                    model_list=None,
                     auto = False,
                     verbose = 0,
                     max_runtime_secs = None,
@@ -1969,13 +2132,14 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
         RETURNS:
             a tuple containing, model information and leaderboard.   
         """
+
         # Feature Exploration Phase
         _FeatureExplore.__init__(self, 
                                  data = self.data, 
                                  target_column = self.target_column,
                                  verbose=verbose)
         if verbose > 0:
-            self._exploration()
+            self._exploration(**kwargs)
         # Feature Engineering Phase
         _FeatureEngineering.__init__(self, 
                                      data = self.data, 
@@ -1986,7 +2150,8 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                                      **kwargs)
         # Start time
         start_time = time.time()
-        data, excluded_columns, target_label, data_transformation_params = self.feature_engineering(auto)
+        data, excluded_columns, target_label,\
+        data_transformation_params, data_mapping = self.feature_engineering(auto)
         
         # Data preparation Phase
         _DataPreparation.__init__(self, 
@@ -1996,8 +2161,18 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                                   excluded_columns = excluded_columns,
                                   custom_data = self.custom_data,
                                   data_transform_dict = data_transformation_params,
+                                  data_mapping = data_mapping,
                                   **kwargs)
-        features, data_transformation_params = self.data_preparation(auto)
+        features, data_transformation_params,\
+            data_mapping = self.data_preparation(auto)
+
+        if kwargs.get('auto_dataprep', False):
+            models_info = None
+            leaderboard = None
+            target_count = None
+            return (models_info, leaderboard, 
+                    target_count, target_label,
+                    data_transformation_params, data_mapping)
 
         # Calculating max_runtime_secs for model training by,
         # subtracting the time taken for feature engineering and data preparation
@@ -2019,12 +2194,14 @@ class _Regression(_FeatureExplore, _FeatureEngineering, _DataPreparation, _Model
                                 custom_data = self.custom_data,
                                 **kwargs)
         models_info, leaderboard, target_count = self.model_training(auto = auto,
-                                                        max_runtime_secs = max_runtime_secs, 
-                                                        stopping_metric = stopping_metric, 
-                                                        stopping_tolerance = stopping_tolerance,
-                                                        max_models = max_models)
+                                                                     max_runtime_secs = max_runtime_secs, 
+                                                                     stopping_metric = stopping_metric, 
+                                                                     stopping_tolerance = stopping_tolerance,
+                                                                     max_models = max_models)
 
-        return (models_info, leaderboard, target_count, target_label, data_transformation_params, self.table_name_mapping)
+        return (models_info, leaderboard,
+                target_count, target_label,
+                data_transformation_params, data_mapping)
             
 class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _ModelTraining):
 
@@ -2057,7 +2234,7 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
         self.custom_data = custom_data
 
     def _classification(self,
-                        model_list = None,
+                        model_list=None,
                         auto = False,
                         verbose = 0,
                         max_runtime_secs = None,
@@ -2134,14 +2311,16 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
         RETURNS:
             a tuple containing, model information and leaderboard.
         """
+        
 
         # Feature Exploration Phase
         _FeatureExplore.__init__(self, 
-                                     data = self.data, 
-                                     target_column = self.target_column,
-                                     verbose=verbose)
+                                 data = self.data, 
+                                 target_column = self.target_column,
+                                 verbose=verbose,
+                                 task_type = "classification")
         if verbose > 0:
-            self._exploration()
+            self._exploration(**kwargs)
         # Feature Engineeting Phase
         _FeatureEngineering.__init__(self, 
                                      data = self.data, 
@@ -2153,7 +2332,9 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                                      **kwargs)
         # Start time
         start_time = time.time()
-        data, excluded_columns, target_label, data_transformation_params = self.feature_engineering(auto)
+        data, excluded_columns, target_label,\
+        data_transformation_params, data_mapping = self.feature_engineering(auto)
+
         # Data Preparation Phase
         _DataPreparation.__init__(self, 
                                   data = self.data, 
@@ -2163,8 +2344,19 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                                   custom_data = self.custom_data,
                                   data_transform_dict = data_transformation_params,
                                   task_type = "Classification",
+                                  data_mapping = data_mapping,
                                   **kwargs)
-        features, data_transformation_params = self.data_preparation(auto)
+        
+        features, data_transformation_params, \
+            data_mapping = self.data_preparation(auto)
+
+        if kwargs.get('auto_dataprep', False):
+            models_info = None
+            leaderboard = None
+            target_count = None
+            return (models_info, leaderboard, 
+                    target_count, target_label,
+                    data_transformation_params, data_mapping)
 
         # Calculating max_runtime_secs for model training by,
         # subtracting the time taken for feature engineering and data preparation
@@ -2186,28 +2378,14 @@ class _Classification(_FeatureExplore, _FeatureEngineering, _DataPreparation, _M
                                 custom_data = self.custom_data,
                                 **kwargs)
         models_info, leaderboard, target_count = self.model_training(auto = auto,
-                                                        max_runtime_secs = max_runtime_secs, 
-                                                        stopping_metric = stopping_metric, 
-                                                        stopping_tolerance = stopping_tolerance,
-                                                        max_models = max_models)
+                                                                     max_runtime_secs = max_runtime_secs, 
+                                                                     stopping_metric = stopping_metric, 
+                                                                     stopping_tolerance = stopping_tolerance,
+                                                                     max_models = max_models)
 
-        return (models_info, leaderboard, target_count, target_label, data_transformation_params, self.table_name_mapping)
-  
-    def _target_column_details(self): 
-        """
-        DESCRIPTION:
-            Internal function displays the target column distribution of Target column/ Response column.
-        """       
-        # If data visualization libraries are available
-        if self._check_visualization_libraries() and not _is_terminal():
-            import matplotlib.pyplot as plt
-            import seaborn as sns
-            self._display_msg(msg='\nTarget Column Distribution:',
-                              show_data=True)
-            plt.figure(figsize=(6, 6))
-            # Ploting a histogram for target column
-            sns.countplot(data=self.data.select([self.target_column]).to_pandas(), x=self.target_column)
-            plt.show()
+        return (models_info, leaderboard, 
+                target_count, target_label,
+                data_transformation_params, data_mapping)
 
     def _check_data_imbalance(self, 
                               data=None):
@@ -2435,6 +2613,9 @@ class AutoRegressor(AutoML):
                         results are persisted in a table; otherwise,
                         results are garbage collected at the end of the
                         session.
+                        Note:
+                            * User is responsible for cleanup of the persisted tables. List of persisted tables
+                              in current session can be viewed using get_persisted_tables() method.
                         Default Value: False
                         Types: bool
                     
@@ -2675,6 +2856,9 @@ class AutoClassifier(AutoML):
                         results are persisted in a table; otherwise,
                         results are garbage collected at the end of the
                         session.
+                        Note:
+                            * User is responsible for cleanup of the persisted tables. List of persisted tables
+                              in current session can be viewed using get_persisted_tables() method.
                         Default Value: False
                         Types: bool
                     
@@ -2904,4 +3088,4 @@ class AutoClassifier(AutoML):
                                              stopping_tolerance=self.stopping_tolerance,
                                              max_models=self.max_models,
                                              custom_config_file=self.custom_config_file,
-                                             **kwargs)
+                                             **kwargs)