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

teradataml/data/docs/sqle/docs_17_20/NaiveBayes.py

@@ -0,0 +1,162 @@
+def  NaiveBayes(data = None, response_column = None, numeric_inputs = None,
+                categorical_inputs = None, attribute_name_column = None,
+                attribute_value_column = None, attribute_type = None,
+                numeric_attributes = None, categorical_attributes = None,
+                **generic_arguments):
+    """
+    DESCRIPTION:
+        Function generates classification model using NaiveBayes 
+        algorithm.
+        The Naive Bayes classification algorithm uses a training dataset with known discrete outcomes
+        and either discrete or continuous numeric input variables, along with categorical variables, to generate a model.
+        This model can then be used to predict the outcomes of future observations based on their input variable values.
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame .
+            Types: teradataml DataFrame
+        
+        response_column:
+            Required Argument.
+            Specifies the name of the column in "data" containing response values.
+            Types: str
+        
+        numeric_inputs:
+            Optional Argument.
+            Specifies the names of the columns in "data" containing numeric attributes values.
+            Types: str OR list of Strings (str)
+        
+        categorical_inputs:
+            Optional Argument.
+            Specifies the names of the columns in "data" containing categorical attributes values.
+            Types: str OR list of Strings (str)
+        
+        attribute_name_column:
+            Optional Argument.
+            Specifies the names of the columns in "data" containing attributes names.
+            Types: str
+        
+        attribute_value_column:
+            Optional Argument.
+            Specifies the names of the columns in "data" containing attributes values.
+            Types: str
+        
+        attribute_type:
+            Optional Argument, Required if "data" is in sparse format and
+            both "numeric_attributes" and "categorical_attributes" are not provided.
+            Specifies the attribute type. 
+            Permitted Values: 
+                * ALLNUMERIC - if all the attributes are of numeric type.
+                * ALLCATEGORICAL - if all the attributes are of categorical type.
+            Types: str
+        
+        numeric_attributes:
+            Optional Argument.
+            Specifies the numeric attributes names.
+            Types: str OR list of strs
+        
+        categorical_attributes:
+            Optional Argument.
+            Specifies the categorical attributes names.
+            Types: str OR list of strs
+        
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept. Below 
+            are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the 
+                    function in a table or not. When set to True, 
+                    results are persisted in a table; otherwise, 
+                    results are garbage collected at the end of the 
+                    session.
+                    Default Value: False
+                    Types: bool
+                
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the 
+                    function in a volatile table or not. When set to 
+                    True, results are stored in a volatile table, 
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+                    
+            Function allows the user to partition, hash, order or local 
+            order the input data. These generic arguments are available 
+            for each argument that accepts teradataml DataFrame as 
+            input and can be accessed as:    
+                * "<input_data_arg_name>_partition_column" accepts str or 
+                    list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list 
+                    of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list 
+                    of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if 
+                the underlying SQL Engine function supports, else an 
+                exception is raised.
+    
+    RETURNS:
+        Instance of  NaiveBayes.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as  NaiveBayesObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+    
+    
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+    
+    
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage, before importing the 
+        #        function in user space.
+        #     2. User can import the function, if it is available on 
+        #        Vantage user is connected to.
+        #     3. To check the list of analytic functions available on 
+        #        Vantage user connected to, use 
+        #        "display_analytic_functions()".
+        
+        # Load the example data.
+        load_example_data("decisionforestpredict", ["housing_train", "housing_test"])
+        
+        # Create teradataml DataFrame objects.
+        housing_train = DataFrame.from_table("housing_train")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function  NaiveBayes.
+        from teradataml import  NaiveBayes
+        
+        # Example 1: NaiveBayes function to generate classification model using Dense input.
+        NaiveBayes_out = NaiveBayes(data=housing_train, response_column='homestyle', 
+                                    numeric_inputs=['price','lotsize','bedrooms','bathrms','stories','garagepl'], 
+                                    categorical_inputs=['driveway','recroom','fullbase','gashw','airco','prefarea'])
+        
+        # Print the result DataFrame.
+        print( NaiveBayes_out.result)
+
+        # Example 2: NaiveBayes function to generate classification model using Sparse input.
+        
+        # Unpivoting the data for sparse input to naive bayes.
+        upvt_data = Unpivoting(data = housing_train, id_column = 'sn',
+                               target_columns = ['price','lotsize','bedrooms','bathrms','stories','garagepl','driveway',
+                                                 'recroom','fullbase','gashw','airco','prefarea'],
+                               attribute_column = "AttributeName", value_column = "AttributeValue",
+                               accumulate = 'homestyle')
+
+        NaiveBayes_out = NaiveBayes(data=upvt_data.result, 
+                                    response_column='homestyle',
+                                    attribute_name_column='AttributeName', 
+                                    attribute_value_column='AttributeValue',
+                                    numeric_attributes=['price','lotsize','bedrooms','bathrms','stories','garagepl'], 
+                                    categorical_attributes=['driveway','recroom','fullbase','gashw','airco','prefarea'])
+
+        # Print the result DataFrame.
+        print( NaiveBayes_out.result)
+    """

teradataml/data/docs/sqle/docs_17_20/OutlierFilterFit.py

@@ -16,6 +16,8 @@ def OutlierFilterFit(data=None, target_columns=None, group_columns=None, lower_p
             * For information about PTCs, see Teradata Vantage™ - Analytics
               Database International Character Set Support.
             * This function does not support KanjiSJIS or Graphic data types.
+            * This function does not support "data_partition_column" and "data_order_column" 
+              if the corresponding Vantage version is greater than or equal to 17.20.03.20.
 
 
     PARAMETERS:

teradataml/data/docs/sqle/docs_17_20/Pivoting.py

@@ -0,0 +1,279 @@
+def Pivoting(data = None, partition_columns = None, target_columns = None,
+             accumulate = None, rows_per_partition = None, pivot_column = None,
+             pivot_keys = None, pivot_keys_alias = None, default_pivot_values = None,
+             aggregation = None, delimiters = None, combined_column_sizes = None,
+             truncate_columns = None, output_column_names = None,
+             **generic_arguments):
+        
+    
+    """
+    DESCRIPTION:
+        Function pivots the data, that is, changes the data from 
+        sparse format to dense format.
+        Notes:
+            * 'data_partition_column' is required argument for partitioning the input data.
+            * Provide either the 'rows_per_partition', 'pivot_column', or 'aggregation' arguments 
+              along with required arguments.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame to be pivoted.
+            Types: teradataml DataFrame
+        
+        partition_columns:
+            Required Argument.
+            Specifies the name of the column(s) in "data" on which to partition the 
+            input.
+            Types: str OR list of Strings (str)
+        
+        target_columns:
+            Required Argument.
+            Specifies the name of the column(s) in "data" which contains the data for 
+            pivoting.
+            Types: str OR list of Strings (str)
+        
+        accumulate:
+            Optional Argument.
+            Specifies the name of the column(s) in "data" to copy to the output. 
+            By default, the function copies no input table columns to the output.
+            Types: str OR list of Strings (str)
+        
+        rows_per_partition:
+            Optional Argument.
+            Specifies the maximum number of rows in the partition.
+            Types: int
+        
+        pivot_column:
+            Optional Argument.
+            Specifies the name of the column in "data" that contains the pivot keys.
+            Note:
+                * This argument is not needed when 'rows_per_partition' is provided.
+            Types: str
+        
+        pivot_keys:
+            Optional Argument.
+            Specifies the names of the pivot keys, if "pivot_column" is specified. 
+            Notes:
+                * This argument is not needed when 'rows_per_partition' is provided.
+                * 'pivot_keys' are required when 'pivot_column' is specified.
+            Types: str OR list of Strings (str)
+        
+        pivot_keys_alias:
+            Optional Argument.
+            Specifies the alias names of the pivot keys, if 'pivot_column' is specified.
+            Note:
+                * This argument is not needed when 'rows_per_partition' is provided.
+            Types: str OR list of Strings (str)
+        
+        default_pivot_values:
+            Optional Argument.
+            Specifies one default value for each pivot_key. The nth 
+            default_pivot_value applies to the nth pivot_key.
+            Note:
+                * This argument is not needed when 'rows_per_partition' is provided.
+            Types: str OR list of Strings (str)
+        
+        aggregation:
+            Optional Argument.
+            Specifies the aggregation for the target columns. 
+            Provide a single value {CONCAT | UNIQUE_CONCAT | SUM | 
+            MIN | MAX | AVG}  which will be applicable to all target columns or 
+            specify multiple values for multiple target columns in 
+            following format: ['ColumnName:{CONCAT|UNIQUE_CONCAT|SUM|MIN|MAX|AVG}',...].
+            Types: str OR list of Strings (str)
+        
+        delimiters:
+            Optional Argument.
+            Specifies the delimiter to be used for concatenating the values of a target column. 
+            Provide a single delimiter value applicable to all target columns or 
+            specify multiple delimiter values for multiple target columns 
+            in the following format: ['ColumnName:single_char',...].
+            Note:
+                * This argument is not needed when 'aggregation' is not specified.
+            Types: str OR list of Strings (str)
+        
+        combined_column_sizes:
+            Optional Argument.
+            Specifies the maximum size of the concatenated string.
+            Provide a single integer value that applies to all target columns or 
+            specify multiple size values for multiple target columns 
+            in the following format ['ColumnName:size_value',...].
+            Note:
+                * This argument is not needed when 'aggregation' is not specified.
+            Types: int OR  str OR list of Strings (str)
+        
+        truncate_columns:
+            Optional Argument.
+            Specifies columns from the target columns for which 
+            to truncate the concatenated string if it exceeds the specified size.
+            Note:
+                * This argument is not needed when 'aggregation' is not specified.
+            Types: str OR list of Strings (str)
+        
+        output_column_names:
+            Optional Argument.
+            Specifies the column name to be used for the output column. The nth 
+            column name value applies to the nth output column.
+            Types: str OR list of Strings (str)
+        
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept. Below 
+            are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the 
+                    function in a table or not. When set to True, 
+                    results are persisted in a table; otherwise, 
+                    results are garbage collected at the end of the 
+                    session.
+                    Default Value: False
+                    Types: bool
+                
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the 
+                    function in a volatile table or not. When set to 
+                    True, results are stored in a volatile table, 
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+                    
+            Function allows the user to partition, hash, order or local 
+            order the input data. These generic arguments are available 
+            for each argument that accepts teradataml DataFrame as 
+            input and can be accessed as:    
+                * "<input_data_arg_name>_partition_column" accepts str or 
+                    list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list 
+                    of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list 
+                    of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if 
+                the underlying SQL Engine function supports, else an 
+                exception is raised.
+    
+    RETURNS:
+        Instance of  Pivoting.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as  PivotingObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+    
+    
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+    
+    
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage, before importing the 
+        #        function in user space.
+        #     2. User can import the function, if it is available on 
+        #        Vantage user is connected to.
+        #     3. To check the list of analytic functions available on 
+        #        Vantage user connected to, use 
+        #        "display_analytic_functions()".
+        
+        # Load the example data.
+        load_example_data('unpivot', 'titanic_dataset_unpivoted')
+        load_example_data('unpivot', 'star_pivot')
+        
+        # Create teradataml DataFrame objects.
+        titanic_unpvt = DataFrame.from_table('titanic_dataset_unpivoted')
+        star = DataFrame.from_table('star_pivot')
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function  Pivoting.
+        from teradataml import  Pivoting
+        
+        # Example 1 : Pivot the input data using 'rows_per_partition'.
+        pvt1 = Pivoting(data = titanic_unpvt, 
+                        partition_columns = 'passenger', 
+                        target_columns = 'AttributeValue',
+                        accumulate = 'survived', 
+                        rows_per_partition = 2,
+                        data_partition_column='passenger',
+                        data_order_column='AttributeName')
+        
+        # Print the result DataFrame.
+        print( pvt1.result)
+
+        # Example 2 : Pivot the input data using 'pivot_column' and 'pivot_keys'.
+        pvt2 = Pivoting(data = titanic_unpvt, 
+                        partition_columns = 'passenger', 
+                        target_columns = 'AttributeValue',
+                        accumulate = 'survived', 
+                        pivot_column = 'AttributeName',
+                        pivot_keys = ['pclass','gender'],
+                        data_partition_column = 'passenger')
+
+        # Print the result DataFrame.
+        print( pvt2.result)
+
+        # Example 3 : Pivot the input data with multiple target columns and
+        #             multiple aggregation functions.
+        pvt3 = Pivoting(data = star, 
+                        partition_columns = ['country', 'state'],
+                        target_columns = ['sales', 'cogs', 'rating'],
+                        accumulate = 'yr',
+                        pivot_column = 'qtr',
+                        pivot_keys = ['Q1','Q2','Q3'],
+                        aggregation = ['sales:SUM','cogs:AVG','rating:CONCAT'],
+                        delimiters = '|', 
+                        combined_column_sizes = 64001,
+                        data_partition_column = ['country', 'state'],
+                        data_order_column = ['qtr'])
+
+        # Print the result DataFrame.
+        print( pvt3.result)
+
+        # Example 4 : Pivot the input data with multiple target columns and
+        #             multiple aggregation functions.
+        pvt4 = Pivoting(data = star, 
+                        partition_columns = 'country', 
+                        target_columns = ['sales', 'cogs', 'state','rating'],
+                        accumulate = 'yr', 
+                        aggregation = ['sales:SUM','cogs:AVG','state:UNIQUE_CONCAT','rating:CONCAT'], 
+                        delimiters = '|', 
+                        combined_column_sizes = ['state:5', 'rating:10'],
+                        data_partition_column='country',
+                        data_order_column='state')
+
+        # Print the result DataFrame.
+        print( pvt4.result)
+
+        # Example 5 : Pivot the input data with truncate columns.
+        pvt5 = Pivoting(data = star, 
+                        partition_columns = ['state'],
+                        target_columns = ['country', 'rating'],
+                        accumulate = 'yr',
+                        pivot_column = 'qtr',
+                        pivot_keys = ['Q1','Q2','Q3'],
+                        aggregation = 'CONCAT',
+                        combined_column_sizes = 10,
+                        truncate_columns = 'country',
+                        data_partition_column = 'qtr',
+                        data_order_column='state')
+
+        # Print the result DataFrame.
+        print( pvt5.result)
+
+        # Example 6 : Pivot the input data with output column names.
+        pvt6 = Pivoting(data = star, 
+                        partition_columns = ['country','state'],
+                        target_columns = ['sales', 'cogs', 'rating'],
+                        accumulate = 'yr',
+                        rows_per_partition = 3,
+                        output_column_names=['sales_q1','sales_q2','sales_q3','cogs_q1','cogs_q2',
+                                             'cogs_q3','rating_q1','rating_q2','rating_q3'],
+                        data_partition_column = 'qtr',
+                        data_order_column=['country','state'])
+
+        # Print the result DataFrame.
+        print( pvt6.result)
+    """

teradataml/data/docs/sqle/docs_17_20/Shap.py

@@ -0,0 +1,197 @@
+def Shap(data = None, object = None, training_function = "TD_GLM",
+         model_type = "Regression", input_columns = None, detailed = False,
+         accumulate = None, num_parallel_trees = 1000, num_boost_rounds = 10,
+         **generic_arguments):
+
+    """
+    DESCRIPTION:
+        Function to get explanation for individual predictions 
+        (feature contributions) in a machine learning model based on the 
+        co-operative game theory optimal Shapley values.
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the teradataml DataFrame.
+            Types: teradataml DataFrame
+        
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the model data.
+            Types: teradataml DataFrame
+        
+        training_function:
+            Required Argument.
+            Specifies the model type name.
+            Default Value: "TD_GLM"
+            Permitted Values: TD_GLM, TD_DECISIONFOREST, TD_XGBOOST
+            Types: str
+        
+        model_type:
+            Required Argument.
+            Specifies the operation to be performed on input data.
+            Default Value: "Regression"
+            Permitted Values: Regression, Classification
+            Types: str
+        
+        input_columns:
+            Required Argument.
+            Specifies the names of the columns in "data" used for 
+            training the model (predictors, features or independent variables).
+            Types: str OR list of Strings (str)
+        
+        detailed:
+            Optional Argument.
+            Specifies whether to output detailed shap information about the 
+            forest trees.
+            Default Value: False
+            Types: bool
+        
+        accumulate:
+            Optional Argument.
+            Specifies the names of the input columns to copy to the output teradataml DataFrame.
+            Types: str OR list of Strings (str)
+        
+        num_parallel_trees:
+            Optional Argument.
+            Specify the number of parallel boosted trees. Each boosted tree 
+            operates on a sample of data that fits in an AMPs memory.
+            Note:
+                * By default, "num_parallel_trees" is chosen equal to the number of AMPs with 
+                  data.
+            Default Value: 1000
+            Types: int
+        
+        num_boost_rounds:
+            Optional Argument.
+            Specifies the number of iterations to boost the weak classifiers. The 
+            iterations must be an int in the range [1, 100000].
+            Default Value: 10
+            Types: int
+        
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept. Below 
+            are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the 
+                    function in a table or not. When set to True, 
+                    results are persisted in a table; otherwise, 
+                    results are garbage collected at the end of the 
+                    session.
+                    Default Value: False
+                    Types: bool
+                
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the 
+                    function in a volatile table or not. When set to 
+                    True, results are stored in a volatile table, 
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+                    
+            Function allows the user to partition, hash, order or local 
+            order the input data. These generic arguments are available 
+            for each argument that accepts teradataml DataFrame as 
+            input and can be accessed as:    
+                * "<input_data_arg_name>_partition_column" accepts str or 
+                    list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list 
+                    of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list 
+                    of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if 
+                the underlying SQL Engine function supports, else an 
+                exception is raised.
+    
+    RETURNS:
+        Instance of Shap.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as ShapObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. output
+    
+    
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+    
+    
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage, before importing the 
+        #        function in user space.
+        #     2. User can import the function, if it is available on 
+        #        Vantage user is connected to.
+        #     3. To check the list of analytic functions available on 
+        #        Vantage user connected to, use 
+        #        "display_analytic_functions()".
+        
+        # Load the example data.
+        load_example_data("byom", "iris_input")
+        load_example_data("teradataml", ["cal_housing_ex_raw"])
+        
+        # Create teradataml DataFrame objects.
+        iris_input = DataFrame("iris_input")
+        data_input = DataFrame.from_table("cal_housing_ex_raw")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function Shap.
+        from teradataml import Shap, XGBoost, DecisionForest, SVM
+        
+        # Example 1: Shap for classification model.
+        XGBoost_out = XGBoost(data=iris_input,
+                      input_columns=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],
+                      response_column = 'species',
+                      model_type='Classification',
+                      iter_num=25)
+        
+        Shap_out = Shap(data=iris_input, 
+                        object=XGBoost_out.result, 
+                        id_column='id',
+                        training_function="TD_XGBOOST", 
+                        model_type="Classification",
+                        input_columns=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'], 
+                        detailed=True)
+        # Print the result DataFrame.
+        print(Shap_out.output_data)
+
+        # Example 2: Shap for regression model.
+
+        from teradataml import ScaleFit, ScaleTransform
+
+        # Scale "target_columns" with respect to 'STD' value of the column.
+        fit_obj = ScaleFit(data=data_input,
+                           target_columns=['MedInc', 'HouseAge', 'AveRooms',
+                                            'AveBedrms', 'Population', 'AveOccup',
+                                            'Latitude', 'Longitude'],
+                           scale_method="STD")
+
+        # Transform the data.
+        transform_obj = ScaleTransform(data=data_input,
+                                       object=fit_obj.output,
+                                       accumulate=["id", "MedHouseVal"])
+        
+        decision_forest_out = DecisionForest(data=transform_obj.result,
+                                             input_columns=['MedInc', 'HouseAge', 'AveRooms',
+                                                            'AveBedrms', 'Population', 'AveOccup',
+                                                            'Latitude', 'Longitude'],
+                                             response_column="MedHouseVal",
+                                             model_type="Regression",
+                                             max_depth = 10
+                                             )
+        Shap_out2 = Shap(data=transform_obj.result, 
+                         object=decision_forest_out.result,
+                         id_column='id',
+                         training_function="TD_DECISIONFOREST",
+                         model_type="Regression",
+                         input_columns=['MedInc', 'HouseAge', 'AveRooms','AveBedrms', 'Population', 'AveOccup','Latitude', 'Longitude'],
+                         detailed=True)
+
+        # Print the result DataFrame.
+        print(Shap_out2.output_data)
+    """