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

teradataml/README.md

@@ -6,7 +6,7 @@ For community support, please visit the [Teradata Community](https://support.ter
 
 For Teradata customer support, please visit [Teradata Support](https://support.teradata.com/csm).
 
-Copyright 2023, Teradata. All Rights Reserved.
+Copyright 2024, Teradata. All Rights Reserved.
 
 ### Table of Contents
 * [Release Notes](#release-notes)
@@ -16,6 +16,243 @@ Copyright 2023, Teradata. All Rights Reserved.
 * [License](#license)
 
 ## Release Notes:
+#### teradataml 20.00.00.00
+* ##### New Features/Functionality
+    * ###### teradataml OpenML: Run Opensource packages through Teradata Vantage
+      `OpenML` dynamically exposes opensource packages through Teradata Vantage. `OpenML` provides an
+      interface object through which exposed classes and functions of opensource packages can be accessed
+      with the same syntax and arguments. 
+      The following functionality is added in the current release:
+      * `td_sklearn` - Interface object to run scikit-learn functions and classes through Teradata Vantage.
+      Example usage below:
+        ```
+        from teradataml import td_sklearn, DataFrame
+
+        df_train = DataFrame("multi_model_classification")
+
+        feature_columns = ["col1", "col2", "col3", "col4"]
+        label_columns = ["label"]
+        part_columns = ["partition_column_1", "partition_column_2"]
+
+        linear_svc = td_sklearn.LinearSVC()
+        ```
+      * `OpenML` is supported in both Teradata Vantage Enterprise and Teradata Vantage Lake.
+      * Argument Support:
+        * `Use of X and y arguments` - Scikit-learn users are familiar with using `X` and `y` as argument names
+        which take data as pandas DataFrames, numpy arrays or lists etc. However, in OpenML, we pass 
+        teradataml DataFrames for arguments `X` and `y`.
+          ```
+          df_x = df_train.select(feature_columns)
+          df_y = df_train.select(label_columns)
+
+          linear_svc = linear_svc.fit(X=df_x, y=df_y)
+          ```
+        * `Additional support for data, feature_columns, label_columns and group_columns arguments` -
+        Apart from traditional arguments, OpenML supports additional arguments - `data`,
+        `feature_columns`, `label_columns` and `group_columns`. These are used as alternatives to `X`, `y`
+        and `groups`.
+          ```
+          linear_svc = linear_svc.fit(data=df_train, feature_columns=feature_columns, label_colums=label_columns)
+          ```
+      * `Support for classification and regression metrics` - Metrics functions for classification and
+      regression in `sklearn.metrics` module are supported. Other metrics functions' support will be added
+      in future releases.
+      * `Distributed Modeling and partition_columns argument support` - Existing scikit-learn supports 
+      only single model generation. However, OpenML supports both single model use case and distributed
+      (multi) model use case. For this, user has to additionally pass `partition_columns` argument to 
+      existing `fit()`, `predict()` or any other function to be run. This will generate multiple models
+      for multiple partitions, using the data in corresponding partition.
+        ```
+        df_x_1 = df_train.select(feature_columns + part_columns)
+        linear_svc = linear_svc.fit(X=df_x_1, y=df_y, partition_columns=part_columns)      
+        ```
+      * `Support for load and deploy models` - OpenML provides additional support for saving (deploying) the
+      trained models. These models can be loaded later to perform operations like prediction, score etc. The
+      following functions are provided by OpenML:
+        * `<obj>.deploy()` - Used to deploy/save the model created and/or trained by OpenML.
+        * `td_sklearn.deploy()` - Used to deploy/save the model created and/or trained outside teradataml.
+        * `td_sklearn.load()` - Used to load the saved models.
+      
+      <br>Refer Teradata Python Package User Guide for more details of this feature, arguments, usage, examples and supportability in both VantageCloud Enterprise and VantageCloud Lake.
+
+    * ###### teradataml: AutoML - Automated end to end Machine Learning flow.
+      AutoML is an approach to automate the process of building, training, and validating machine learning models. 
+      It involves automation of various aspects of the machine learning workflow, such as feature exploration, 
+      feature engineering, data preparation, model training and evaluation for given dataset.
+      teradataml AutoML feature offers best model identification, model leaderboard generation, parallel execution, 
+      early stopping feature, model evaluation, model prediction, live logging, customization on default process.
+      * `AutoML`
+        AutoML is a generic algorithm that supports all three tasks, i.e. 'Regression',
+        'Binary Classification' and 'Multiclass Classification'. 
+        * Methods of AutoML
+          * `__init__()` - Instantiate an object of AutoML with given parameters.
+          * `fit()` - Perform fit on specified data and target column.
+          * `leaderboard()` - Get the leaderboard for the AutoML. Presents diverse models, feature 
+          selection method, and performance metrics.
+          * `leader()` - Show best performing model and its details such as feature 
+          selection method, and performance metrics.
+          * `predict()` - Perform prediction on the data using the best model or the model of users 
+          choice from the leaderboard.
+          * `generate_custom_config()` - Generate custom config JSON file required for customized 
+          run of AutoML.
+      * `AutoRegressor`
+        AutoRegressor is a special purpose AutoML feature to run regression specific tasks. 
+        * Methods of AutoRegressor
+          * `__init__()` - Instantiate an object of AutoRegressor with given parameters.
+          * `fit()` - Perform fit on specified data and target column.
+          * `leaderboard()` - Get the leaderboard for the AutoRegressor. Presents diverse models, feature 
+          selection method, and performance metrics.
+          * `leader()` - Show best performing model and its details such as feature 
+          selection method, and performance metrics.
+          * `predict()` - Perform prediction on the data using the best model or the model of users 
+          choice from the leaderboard.
+          * `generate_custom_config()` - Generate custom config JSON file required for customized 
+          run of AutoRegressor.
+      * `AutoClassifier`
+        AutoClassifier is a special purpose AutoML feature to run classification specific tasks.
+        * Methods of AutoClassifier
+          * `__init__()` - Instantiate an object of AutoClassifier with given parameters.
+          * `fit()` - Perform fit on specified data and target column.
+          * `leaderboard()` - Get the leaderboard for the AutoClassifier. Presents diverse models, feature 
+          selection method, and performance metrics.
+          * `leader()` - Show best performing model and its details such as feature 
+          selection method, and performance metrics.
+          * `predict()` - Perform prediction on the data using the best model or the model of users 
+          choice from the leaderboard.
+          * `generate_custom_config()` - Generate custom config JSON file required for customized 
+          run of AutoClassifier.
+
+    * ###### teradataml: DataFrame
+      * `fillna` - Replace the null values in a column with the value specified. 
+      * Data Manipulation
+          * `cube()`- Analyzes data by grouping it into multiple dimensions.
+          * `rollup()` - Analyzes a set of data across a single dimension with more than one level of detail.
+          * `replace()` - Replaces the values for columns.
+
+    * ###### teradataml: Script and Apply
+      * `deploy()` - Function deploys the model, generated after `execute_script()`, in database or user
+            environment in lake. The function is available in both Script and Apply.
+
+    * ###### teradataml: DataFrameColumn
+      * `fillna` - Replaces every occurrence of null value in column with the value specified.
+    
+* ###### teradataml DataFrameColumn a.k.a. ColumnExpression
+    * _Date Time Functions_
+      * `DataFrameColumn.week_start()` - Returns the first date or timestamp of the week that begins immediately before the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.week_begin()` - It is an alias for `DataFrameColumn.week_start()` function.
+      * `DataFrameColumn.week_end()` - Returns the last date or timestamp of the week that ends immediately after the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.month_start()` - Returns the first date or timestamp of the month that begins immediately before the specified date or timestamp value in a column or as a literal.
+      * `DataFrameColumn.month_begin()` - It is an alias for `DataFrameColumn.month_start()` function.
+      * `DataFrameColumn.month_end()` - Returns the last date or timestamp of the month that ends immediately after the specified date or timestamp value in a column or as a literal.
+      * `DataFrameColumn.year_start()` - Returns the first date or timestamp of the year that begins immediately before the specified date or timestamp value in a column or as a literal.
+      * `DataFrameColumn.year_begin()` - It is an alias for `DataFrameColumn.year_start()` function.
+      * `DataFrameColumn.year_end()` - Returns the last date or timestamp of the year that ends immediately after the specified date or timestamp value in a column or as a literal.
+      * `DataFrameColumn.quarter_start()` - Returns the first date or timestamp of the quarter that begins immediately before the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.quarter_begin()` - It is an alias for `DataFrameColumn.quarter_start()` function.
+      * `DataFrameColumn.quarter_end()` - Returns the last date or timestamp of the quarter that ends immediately after the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.last_sunday()` - Returns the date or timestamp of Sunday that falls immediately before the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.last_monday()` - Returns the date or timestamp of Monday that falls immediately before the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.last_tuesday()` - Returns the date or timestamp of Tuesday that falls immediately before the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.last_wednesday()` - Returns the date or timestamp of Wednesday that falls immediately before specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.last_thursday()`- Returns the date or timestamp of Thursday that falls immediately before specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.last_friday()` - Returns the date or timestamp of Friday that falls immediately before specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.last_saturday()` - Returns the date or timestamp of Saturday that falls immediately before specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.day_of_week()` - Returns the number of days from the beginning of the week to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.day_of_month()` - Returns the number of days from the beginning of the month to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.day_of_year()` - Returns the number of days from the beginning of the year to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.day_of_calendar()` - Returns the number of days from the beginning of the business calendar to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.week_of_month()` - Returns the number of weeks from the beginning of the month to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.week_of_quarter()` - Returns the number of weeks from the beginning of the quarter to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.week_of_year()` - Returns the number of weeks from the beginning of the year to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.week_of_calendar()` - Returns the number of weeks from the beginning of the calendar to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.month_of_year()` - Returns the number of months from the beginning of the year to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.month_of_calendar()` - Returns the number of months from the beginning of the calendar to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.month_of_quarter()` - Returns the number of months from the beginning of the quarter to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.quarter_of_year()` - Returns the number of quarters from the beginning of the year to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.quarter_of_calendar()` - Returns the number of quarters from the beginning of the calendar to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.year_of_calendar()` - Returns the year of the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.day_occurrence_of_month()` - Returns the nth occurrence of the weekday in the month for the date to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.year()` - Returns the integer value for year in the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.month()` - Returns the integer value for month in the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.hour()` - Returns the integer value for hour in the specified timestamp value in a column as a literal.
+      * `DataFrameColumn.minute()` - Returns the integer value for minute in the specified timestamp value in a column as a literal.
+      * `DataFrameColumn.second()` - Returns the integer value for seconds in the specified timestamp value in a column as a literal.
+      * `DataFrameColumn.week()` - Returns the number of weeks from the beginning of the year to the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.next_day()` - Returns the date of the first weekday specified as 'day_value' that is later than the specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.months_between()` - Returns the number of months between value in specified date or timestamp value in a column as a literal and date or timestamp value in argument.
+      * `DataFrameColumn.add_months()` - Adds an integer number of months to specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.oadd_months()` - Adds an integer number of months, date or timestamp value in specified date or timestamp value in a column as a literal.
+      * `DataFrameColumn.to_date()` - Function converts a string-like representation of a DATE or PERIOD type to Date type.
+    * _String Functions_
+      * `DataFrameColumn.concat()` - Function to concatenate the columns with a separator.
+      * `DataFrameColumn.like()` - Function to match the string pattern. String match is case sensitive. 
+      * `DataFrameColumn.ilike()` - Function to match the string pattern. String match is not case sensitive.
+      * `DataFrameColumn.substr()` - Returns the substring from a string column.       
+      * `DataFrameColumn.startswith()` - Function to check if the column value starts with the specified value or not.       
+      * `DataFrameColumn.endswith()` - Function to check if the column value ends with the specified value or not.
+      * `DataFrameColumn.format()` - Function to format the values in column based on formatter.
+      * `DataFrameColumn.to_char()` - Function converts numeric type or datetype to character type.
+      * `DataFrameColumn.trim()` - Function trims the string values in the column.
+    * _Regular Arithmetic Functions_
+      * `DataFrameColumn.cbrt()` - Computes the cube root of values in the column.
+      * `DataFrameColumn.hex()` - Computes the Hexadecimal from decimal for the values in the column.
+      * `DataframeColumn.hypot()` - Computes the decimal from Hexadecimal for the values in the column.
+      * `DataFrameColumn.unhex()` - computes the hypotenuse for the values between two columns.
+    * _Bit Byte Manipulation Functions_
+      * `DataFrameColumn.from_byte()` - Encodes a sequence of bits into a sequence of characters.
+    * _Comparison Functions_
+      * `DataFrameColumn.greatest()` - Returns the greatest values from columns.
+      * `DataFrameColumn.least()` - Returns the least values from columns.
+    * Behaviour of `DataFrameColumn.replace()` is changed.
+    * Behaviour of `DataFrameColumn.to_byte()` is changed. It now decodes a sequence of characters in a given encoding into a sequence of bits.
+    * Behaviour of `DataFrameColumn.trunc()` is changed. It now accepts Date type columns.  
+
+* ##### Bug Fixes
+  * Argument `url_encode` is no longer used in `create_context()` and is deprecated. 
+    * **Important notes**
+      * Users do not need to encode password even if password contain special characters.
+      * Pass the password to the `create_context()` function argument `password` as it is without changing special characters.
+  * `fillna()` in VAL transformation allows to replace NULL values with empty string.
+
+* ##### Updates
+  * Support for following deprecated functionality is removed:
+    * ML Engine functions
+    * STO and APPLY sandbox feature support for testing the script.   
+      * sandbox_container_utils is removed. Following methods can no longer be used:
+        * `setup_sandbox_env()`
+        * `copy_files_from_container()`
+        * `cleanup_sandbox_env()`
+    * Model Cataloging APIs can no longer be used: 
+        * `describe_model()`
+        * `delete_model()`
+        * `list_models()`
+        * `publish_model()`
+        * `retrieve_model()`
+        * `save_model()`
+  * `DataFrame.join()`
+    * Arguments `lsuffix` and `rsuffix` now add suffixes to new column names for join operation.
+  * `DataFrame.describe()`
+    * New argument `columns` is added to generate statistics on only those columns instead of all applicable columns.
+  * `DataFrame.groupby()`
+    * Supports `CUBE` and `ROLLUP` with additional optional argument `option`.
+  * `DataFrame.column.window()` 
+    * Supports ColumnExpressions for `partition_columns` and `order_columns` arguments.
+  * `DataFrame.column.contains()` allows ColumnExpressions for `pattern` argument.
+  * `DataFrame.window()` 
+    * Supports ColumnExpressions for `partition_columns` and `order_columns` arguments.
+
+#### teradataml 17.20.00.07
+* ##### New Features/Functionality
+  * ###### Open Analytics Framework (OpenAF) APIs:
+      * Manage all user environments.
+        * `create_env()`:
+          * new argument `conda_env` is added to create a conda environment.
+        * `list_user_envs()`:
+          * User can list conda environment(s) by using filter with new argument `conda_env`.
+      *  Conda environment(s) can be managed using APIs for installing , updating, removing files/libraries. 
+* ##### Bug Fixes
+  * `columns` argument for `FillNa` function is made optional.
+
 #### teradataml 17.20.00.06
 * ##### New Features/Functionality
 * ###### teradataml DataFrameColumn a.k.a. ColumnExpression

teradataml/__init__.py

@@ -7,7 +7,6 @@ from teradataml.dbutils.filemgr import *
 from teradataml.dataframe.copy_to import *
 from teradataml.dataframe.fastload import fastload
 from teradataml.data.load_example_data import *
-from teradataml.catalog.model_cataloging import *
 from teradataml.catalog.byom import *
 from teradataml.dataframe.data_transfer import fastexport, read_csv
 
@@ -16,7 +15,6 @@ from teradataml.dataframe.sql_functions import *
 
 # import Analytical Function to User's workspace.
 from teradataml.analytics.byom import *
-from teradataml.analytics.mle import *
 from teradataml.analytics.sqle import *
 from teradataml.analytics.table_operator import *
 from teradataml.analytics.uaf import *
@@ -45,7 +43,6 @@ __version__ = v.version
 # Import Table Operator to User's workspace.
 from teradataml.table_operators.Script import *
 from teradataml.table_operators.Apply import *
-from teradataml.table_operators.sandbox_container_util import *
 
 # Import Geospatial APIs, modules
 from teradataml.geospatial import *
@@ -58,3 +55,16 @@ from teradataml.scriptmgmt import *
 
 # Import utility functions.
 from teradataml.utils.utils import execute_sql, async_run_status
+
+import os
+_TDML_DIRECTORY = os.path.dirname(v.__file__)
+
+from teradataml.opensource import *
+
+# Import AutoML
+from teradataml.automl import AutoML, AutoRegressor, AutoClassifier
+
+
+# Configure app name and app version for querybands
+from teradatasqlalchemy.telemetry.queryband import session_queryband
+session_queryband.configure_queryband_parameters(app_name="TDML", app_version=__version__)

teradataml/_version.py

@@ -8,4 +8,4 @@
 # 
 # ################################################################## 
 
-version = "17.20.00.06"
+version = "20.00.00.00"

teradataml/analytics/Transformations.py

@@ -209,7 +209,7 @@ class FillNa(_Transformations):
                 Types: teradataml DataFrame, bool, int, str, float, datetime.date
 
             columns:
-                Required Argument.
+                Optional Argument.
                 Specifies the names of the columns.
                 Types: str or list of str
 
@@ -484,7 +484,7 @@ class FillNa(_Transformations):
             >>>
         """
         # Call super()
-        super().__init__(columns=columns, out_columns=out_columns, datatype=datatype, columns_optional=False)
+        super().__init__(columns=columns, out_columns=out_columns, datatype=datatype, columns_optional=True)
         # Initialize style and value as data members.
         self.style = style
         self.value = value
@@ -557,8 +557,8 @@ class FillNa(_Transformations):
 
         nullstyle_args = self.style.lower()
         if self.style.upper() in ["LITERAL", "IMPUTED"]:
-            nullstyle_args = "{}, {}".format(self.style.lower(), self.value)
-
+            nullstyle_args = "{}, {}".format(self.style.lower(), '\'\'\'\'' if isinstance(self.value, str) and len(
+                self.value) == 0 else self.value)
         return nullstyle_fmt.format(nullstyle_args)
 
     def _val_sql_syntax(self):

teradataml/analytics/__init__.py

@@ -14,7 +14,6 @@ based on the json data and attach it to teradataml.
 and function _get_executor_class_name, Internal function to get executor class name for function_type provided.
 """
 from .byom import *
-from .mle import *
 from .sqle import *
 from .table_operator import *
 from .uaf import *
@@ -24,7 +23,6 @@ from .Transformations import Binning, Derive, OneHotEncoder, FillNa, LabelEncode
 from teradataml.analytics.json_parser.utils import _get_json_data_from_tdml_repo, _process_paired_functions
 from teradataml.analytics.analytic_function_executor import _SQLEFunctionExecutor, _TableOperatorExecutor,\
     _UAFFunctionExecutor, _BYOMFunctionExecutor
-import sys
 from teradataml.common.constants import TeradataAnalyticFunctionTypes
 
 

teradataml/analytics/analytic_function_executor.py

@@ -29,6 +29,7 @@ from teradataml.common.wrapper_utils import AnalyticsWrapperUtils
 from teradataml.common.utils import UtilFuncs
 from teradataml.context.context import _get_context_temp_databasename
 from teradataml.table_operators.table_operator_query_generator import TableOperatorQueryGenerator
+from teradatasqlalchemy.telemetry.queryband import collect_queryband
 from teradataml.utils.dtypes import _ListOf
 from teradataml.utils.validators import _Validators
 
@@ -150,6 +151,7 @@ class _AnlyticFunctionExecutor:
         # Validate the function arguments.
         _Validators._validate_function_arguments([argument_info])
 
+    @collect_queryband(attr="func_name")
     def _execute_query(self, persist=False, volatile=False):
         """
         DESCRIPTION:
@@ -1906,6 +1908,7 @@ class _UAFFunctionExecutor(_SQLEFunctionExecutor):
                 self.__process_individual_argument(output_fmt_argument,
                                                   **kwargs))
 
+    @collect_queryband(attr="func_name")
     def _execute_query(self, persist=False, volatile=None):
         """
         DESCRIPTION:

teradataml/analytics/json_parser/utils.py

@@ -551,26 +551,27 @@ class _KNNPredict:
 
             res = KNN_out.evaluate(test_data=computers_train1_encoded.result.iloc[10:])
         """
-        # response_column is required when the model_type is classification or regression.
-        # accumulate is optional in case user specifies accumulate then consider the value specified by the user,
-        # else consider the value specified for response_column.
-
         params = {"test_data": kwargs.get("test_data"),
                   "id_column": self.id_column,
-                  "voting_weight": self.voting_weight,
-                  "k": self.k,
-                  "tolerance": self.tolerance,
-                  "output_prob": self.output_prob,
-                  "output_responses": self.output_responses,
-                  "emit_neighbors": self.emit_neighbors,
-                  "emit_distances": self.emit_distances,
                   "train_data": self.train_data,
                   "input_columns": self.input_columns,
-                  "model_type": self.model_type,
                   "response_column": kwargs.get("response_column", self.response_column),
                   "accumulate": kwargs.get("accumulate", kwargs.get("response_column", self.response_column)
                                 if getattr(self.obj, "accumulate") is None else self.accumulate)}
 
+        # KNN works in a different way. predict calls the same function with test data along with
+        # the arguments passed to the actual function. The above parameters are required
+        # arguments so we expect them to be available in output of KNN. However, the below
+        # ones are optional arguments. They can be available or not based on user input. So, before
+        # passing those to KNN again, check whether that argument is passed or not.
+        optional_args = ["model_type", "k", "voting_weight",
+                         "tolerance", "output_prob", "output_responses",
+                         "emit_neighbors", "emit_distances"]
+
+        for optional_arg in optional_args:
+            if hasattr(self, optional_arg):
+                params[optional_arg] = getattr(self, optional_arg)
+
         return getattr(module, "KNN")(**params)
 
 

teradataml/analytics/sqle/DecisionTreePredict.py

@@ -26,7 +26,6 @@ from teradataml.common.messagecodes import MessageCodes
 from teradataml.common.constants import TeradataConstants
 from teradataml.dataframe.dataframe_utils import DataFrameUtils as df_utils
 from teradataml.options.display import display
-from teradataml.analytics.mle.DecisionTree import DecisionTree
 
 class DecisionTreePredict:
     
@@ -52,7 +51,7 @@ class DecisionTreePredict:
             object:
                 Required Argument.
                 Specifies the name of the teradataml DataFrame containing the output 
-                model from DecisionTree or instance of DecisionTree.
+                model from DecisionTree.
          
             object_order_column:
                 Optional Argument.
@@ -132,40 +131,28 @@ class DecisionTreePredict:
          
         EXAMPLES:
             # Load the data to run the example.
-            load_example_data("DecisionTreePredict", ["iris_attribute_train",
-                                                      "iris_response_train",
-                                                      "iris_attribute_test"])
-         
+            load_example_data("DecisionTreePredict", ["iris_response_train",
+                                                      "iris_attribute_test",
+                                                      "iris_attribute_output"])
+
+
             # Create teradataml DataFrame.
             iris_attribute_test = DataFrame.from_table("iris_attribute_test")
-            iris_attribute_train = DataFrame.from_table("iris_attribute_train")
             iris_response_train = DataFrame.from_table("iris_response_train")
-         
+            iris_attribute_output = DataFrame.from_table("iris_attribute_output")
+
             # Example 1 -
-            # First train the data, i.e., create a decision tree Model
-            td_decision_tree_out  = DecisionTree(attribute_name_columns = 'attribute',
-                                                 attribute_value_column = 'attrvalue',
-                                                 id_columns = 'pid',
-                                                 attribute_table = iris_attribute_train,
-                                                 response_table = iris_response_train,
-                                                 response_column = 'response',
-                                                 approx_splits = True,
-                                                 nodesize = 100,
-                                                 max_depth = 5,
-                                                 weighted = False,
-                                                 split_measure = "gini",
-                                                 output_response_probdist = False)
          
-            # Run predict on the output of decision tree
+            # Run predict on the output of decision tree in iris_attribute_output
             decision_tree_predict_out = DecisionTreePredict(newdata=iris_attribute_test,
                                                             newdata_partition_column='pid',
-                                                            object=td_decision_tree_out,
+                                                            object=iris_attribute_output,
                                                             attr_table_groupby_columns='attribute',
                                                             attr_table_pid_columns='pid',
                                                             attr_table_val_column='attrvalue',
-                                                            accumulate='pid',
-                                                            output_response_probdist=False,
-                                                            output_responses=['pid','attribute'])
+                                                            accumulate='attribute',
+                                                            output_response_probdist=True,
+                                                            output_responses=['1', '2', '3'])
          
             # Print output dataframes
             print(decision_tree_predict_out.result)
@@ -227,9 +214,7 @@ class DecisionTreePredict:
         arguments, input argument and table types. Also processes the 
         argument values.
         """
-        if isinstance(self.object, DecisionTree):
-            self.object = self.object._mlresults[0]
-        
+
         # Make sure that a non-NULL value has been supplied for all mandatory arguments
         self.__awu._validate_missing_required_arguments(self.__arg_info_matrix)
         
@@ -238,7 +223,7 @@ class DecisionTreePredict:
         
         # Check to make sure input table types are strings or data frame objects or of valid type.
         self.__awu._validate_input_table_datatype(self.newdata, "newdata", None)
-        self.__awu._validate_input_table_datatype(self.object, "object", DecisionTree)
+        self.__awu._validate_input_table_datatype(self.object, "object", DataFrame)
         
         # Check whether the input columns passed to the argument are not empty.
         # Also check whether the input columns passed to the argument valid or not.

teradataml/analytics/sqle/NaiveBayesPredict.py

@@ -27,7 +27,6 @@ from teradataml.common.constants import TeradataConstants
 from teradataml.dataframe.dataframe_utils import DataFrameUtils as df_utils
 from teradataml.options.display import display
 from teradataml.common.formula import Formula
-from teradataml.analytics.mle.NaiveBayes import NaiveBayes
 
 class NaiveBayesPredict:
     
@@ -104,21 +103,20 @@ class NaiveBayesPredict:
          
         EXAMPLES:
             # Load the data to run the example
-            load_example_data("NaiveBayesPredict",["nb_iris_input_test","nb_iris_input_train"])
-         
+            load_example_data("NaiveBayesPredict",["nb_iris_input_test"])
+            load_example_data("teradataml","nbp_iris_model")
+
             # Create teradataml DataFrame objects.
-            nb_iris_input_train = DataFrame.from_table("nb_iris_input_train")
             nb_iris_input_test = DataFrame.from_table("nb_iris_input_test")
-         
+            nbp_iris_model = DataFrame.from_table("nbp_iris_model")
+
             # Example 1 -
-            # Run the train function
-            naivebayes_train = NaiveBayes(formula="species ~ petal_length + sepal_width + petal_width + sepal_length",
-                                          data=nb_iris_input_train)
-         
-            # Generate prediction using output of train function
+
+            # Generate prediction using output of train stored in nbp_iris_model.
             naivebayes_predict_result = NaiveBayesPredict(newdata=nb_iris_input_test,
-                                                          modeldata = naivebayes_train,
+                                                          modeldata = nbp_iris_model,
                                                           id_col = "id",
+                                                          formula="species ~ .",
                                                           responses = ["virginica","setosa","versicolor"]
                                                           )
          
@@ -174,14 +172,7 @@ class NaiveBayesPredict:
         arguments, input argument and table types. Also processes the
         argument values.
         """
-        if isinstance(self.modeldata, NaiveBayes):
-            self.formula = self.modeldata.formula
-            self.modeldata = self.modeldata._mlresults[0]
-        else:
-            if self.formula is None:
-                raise TeradataMlException(Messages.get_message(MessageCodes.MISSING_ARGS, "formula"),
-                                          MessageCodes.MISSING_ARGS)
-        
+
         # Make sure that a non-NULL value has been supplied for all mandatory arguments
         self.__awu._validate_missing_required_arguments(self.__arg_info_matrix)
         
@@ -190,7 +181,7 @@ class NaiveBayesPredict:
         
         # Check to make sure input table types are strings or data frame objects or of valid type.
         self.__awu._validate_input_table_datatype(self.newdata, "newdata", None)
-        self.__awu._validate_input_table_datatype(self.modeldata, "modeldata", NaiveBayes)
+        self.__awu._validate_input_table_datatype(self.modeldata, "modeldata", None)
         
         # Check whether the input columns passed to the argument are not empty.
         # Also check whether the input columns passed to the argument valid or not.

teradataml/analytics/sqle/__init__.py

@@ -1,18 +1,5 @@
-from teradataml.analytics.sqle.Antiselect import Antiselect
-from teradataml.analytics.sqle.Attribution import Attribution
-from teradataml.analytics.sqle.DecisionForestPredict import DecisionForestPredict
 from teradataml.analytics.sqle.DecisionTreePredict import DecisionTreePredict
-from teradataml.analytics.sqle.GLMPredict import GLMPredict
-from teradataml.analytics.sqle.MovingAverage import MovingAverage
-from teradataml.analytics.sqle.NGramSplitter import NGramSplitter
-from teradataml.analytics.sqle.NPath import NPath
 from teradataml.analytics.sqle.NaiveBayesPredict import NaiveBayesPredict
-from teradataml.analytics.sqle.NaiveBayesTextClassifierPredict import NaiveBayesTextClassifierPredict
-from teradataml.analytics.sqle.Pack import Pack
-from teradataml.analytics.sqle.Sessionize import Sessionize
-from teradataml.analytics.sqle.StringSimilarity import StringSimilarity
-from teradataml.analytics.sqle.SVMSparsePredict import SVMSparsePredict
-from teradataml.analytics.sqle.Unpack import Unpack
 
 from teradataml.analytics.meta_class import _AnalyticFunction
 from teradataml.analytics.meta_class import _common_init

teradataml/analytics/utils.py

@@ -264,6 +264,7 @@ def _display_functions(func_type_category_name_dict, func_types=None, search_key
 
     # Check for type of 'type'. If str, convert it to list.
     func_types = UtilFuncs._as_list(func_types)
+    func_types = list(map(lambda x: x.upper(), func_types))
 
     # Map to store function types and corresponding type to be printed.
     func_type_display_type_map = {"SQLE": "Analytics Database",

teradataml/analytics/valib.py

@@ -12,6 +12,8 @@ Library (VALIB) Function.
 import time
 import uuid
 from math import floor
+
+from teradatasqlalchemy.telemetry.queryband import collect_queryband
 from teradataml.common import messages
 from teradataml.common.constants import TeradataConstants, ValibConstants as VC
 from teradataml.common.exceptions import TeradataMlException
@@ -230,6 +232,7 @@ class _VALIB():
         self.__dyn_cls_data_members[out_var]._index_query_required = False
         self.__dyn_cls_data_members[VC.OUTPUT_DATAFRAME_RESULTS.value].append(out_var)
 
+    @collect_queryband(attr="_VALIB__sql_func_name")
     def __generate_execute_sp_query(self):
         """
         DESCRIPTION: