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

teradataml/data/dataframe_example.json

@@ -143,5 +143,15 @@
     "smoker" : "varchar(4)",
     "region" : "varchar(12)",
     "charges" : "real"
+   },
+   "grocery_transaction":{
+    "tranid" : "integer",
+    "period" : "varchar(20)",
+    "storeid" : "integer",
+    "region" : "varchar(20)",
+    "item" : "varchar(20)",
+    "sku" : "integer",
+    "category" : "varchar(20)"
+
    }
 }

teradataml/data/docs/sqle/docs_17_10/OneHotEncodingFit.py

@@ -7,7 +7,9 @@ def OneHotEncodingFit(data=None, is_input_dense=None, target_column=None, catego
         Such as, target attributes and their categorical values to be encoded and other parameters.
         Output of OneHotEncodingFit() function is used by OneHotEncodingTransform() function for encoding
         the input data. It supports inputs in both sparse and dense format.
-
+        Note:
+            * For input to be considered as sparse input, column names must be provided for
+             'data_partition_column' argument.
 
     PARAMETERS:
         data:

teradataml/data/docs/sqle/docs_17_10/OneHotEncodingTransform.py

@@ -3,6 +3,12 @@ def OneHotEncodingTransform(data=None, object=None, is_input_dense=None, **gener
     DESCRIPTION:
         Function encodes specified attributes and categorical values as one-hot numeric vectors,
         using OneHotEncodingFit() function output.
+        Notes:
+            * In case of sparse input, neither 'data_partition_column' nor
+              'object_partition_column' can be used independently.
+            * In case of dense input, if 'data_partition_column' is having value
+              PartitionKind.ANY, then 'object_partition_column' should have value
+              PartitionKind.DIMENSION.
 
 
     PARAMETERS:

teradataml/data/docs/sqle/docs_17_10/OutlierFilterTransform.py

@@ -5,7 +5,11 @@ def OutlierFilterTransform(data=None, object=None, **generic_arguments):
         OutlierFilterTransform() uses the result DataFrame from OutlierFilterFit() function to get
         statistics like median, count of rows, lower percentile and upper percentile for every column
         specified in target columns argument and filters the outliers in the input data.
-
+        Notes:
+            * Partitioning of input data and model is allowed using 'data_partition_column' and
+              'object_partition_column' only if 'group_columns' are passed while creating model
+              using OutlierFilterFit() function.
+            * Neither 'data_partition_column' nor 'object_partition_column' can be used independently.
 
     PARAMETERS:
         data:

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

@@ -1,4 +1,6 @@
-def ANOVA(data=None, group_columns=None, alpha=0.05, **generic_arguments):
+def ANOVA(data=None, group_columns=None, alpha=0.05, group_name_column=None,
+          group_value_column=None, group_names=None, num_groups=None,
+          **generic_arguments):
     """
     DESCRIPTION:
         The ANOVA() function performs one-way ANOVA (Analysis of Variance) on
@@ -37,6 +39,42 @@ def ANOVA(data=None, group_columns=None, alpha=0.05, **generic_arguments):
             Default Value: 0.05
             Types: float
 
+        group_name_column:
+            Optional Argument.
+            Specifies the column name in "data" containing the names of the groups  
+            included in the computation.
+            Note:
+                * This argument is used when data contains group names in a column
+                    and group values in another column.
+                * This argument must be used in conjunction with "group_value_column".
+            Types: str
+        
+        group_value_column:
+            Optional Argument.
+             Specifies the column name in "data" containing the values for each group member.
+            Note:
+                * This argument is used when data contains group values in a column
+                    and group names in another column.
+                * This argument must be used in conjunction with "group_name_column".
+            Types: str
+        
+        group_names:
+            Optional Argument.
+            Specifies the names of the groups included in the computation.
+            Note:
+                * This argument is used when data contains group values in a column
+                  and group names in another column.
+            Types: list of Strings (str)
+
+        num_groups:
+            Optional Argument.
+             Specifies the number of different groups in the "data" included 
+            in the computation.
+            Note:
+                * This argument is used when data contains group values in a column
+                  and group names in another column.
+            Types: int
+
         **generic_arguments:
             Specifies the generic keyword arguments SQLE functions accept. Below
             are the generic keyword arguments:
@@ -97,9 +135,11 @@ def ANOVA(data=None, group_columns=None, alpha=0.05, **generic_arguments):
 
         # Load the example data.
         load_example_data("teradataml", ["insect_sprays"])
+        load_example_data("ztest", 'insect2Cols')
 
         # Create teradataml DataFrame objects.
         insect_sprays = DataFrame.from_table("insect_sprays")
+        insect_gp = DataFrame.from_table("insect2Cols")
 
         # Check the list of available analytic functions.
         display_analytic_functions()
@@ -123,4 +163,24 @@ def ANOVA(data=None, group_columns=None, alpha=0.05, **generic_arguments):
         # Print the result DataFrame.
         print(ANOVA_out_2.result)
 
+        # Example 3 : Perform one-way anova analysis on a data set with more
+        #             than two groups and group_name_column, group_value_column,
+        #             group_names.
+        ANOVA_out_3 = ANOVA(data = insect_gp,
+                            group_name_column='groupName',
+                            group_value_column='groupValue',
+                            group_names=['groupA', 'groupB', 'groupC'])
+        
+        # Print the result DataFrame.
+        print(ANOVA_out_3.result)
+
+        # Example 4 : Perform one-way anova analysis on a data set with more
+        #             than two groups and num_groups.
+        ANOVA_out_4 = ANOVA(data = insect_gp,
+                            group_name_column='groupName',
+                            group_value_column='groupValue',
+                            num_groups=6)
+        
+        # Print the result DataFrame.
+        print(ANOVA_out_4.result)
     """

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

@@ -0,0 +1,132 @@
+def CFilter(data = None, target_column = None, transaction_id_columns = None,
+            partition_columns = None, max_distinct_items = 100,
+            **generic_arguments):
+    
+    """
+    DESCRIPTION:
+        Function calculates several statistical measures of how likely 
+        each pair of items is to be purchased together.
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+        
+        target_column:
+            Required Argument.
+            Specifies name of the column from the "data" containing data for filtration.
+            Types: str
+        
+        transaction_id_columns:
+            Required Argument.
+            Specifies the name of the columns in "data" containing transaction id that defines the groups of items listed
+            in the input columns that are purchased together.
+            Types: str OR list of Strings (str)
+        
+        partition_columns:
+            Optional Argument.
+            Specifies the name of the column in "data" to partition the data on.
+            Types: str OR list of Strings (str)
+        
+        max_distinct_items:
+            Optional Argument.
+            Specifies the maximum size of the item set. 
+            Default Value: 100
+            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 CFilter.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as CFilterObj.<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("dataframe", ["grocery_transaction"])
+        
+        # Create teradataml DataFrame objects.
+        df = DataFrame.from_table("grocery_transaction")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function CFilter.
+        from teradataml import CFilter
+        
+        # Example 1: CFilter function to calculate the statistical measures
+        #            of how likely each pair of items is to be purchased together, without
+        #            specifying the partition_columns.
+        CFilter_out = CFilter(data=df, 
+                              target_column='item',
+                              transaction_id_columns = 'tranid',
+                              max_distinct_items=100)
+        
+        # Print the result DataFrame.
+        print(CFilter_out.result)
+
+        # Example 2: CFilter function to calculate the statistical measures
+        #            of how likely each pair of items is to be purchased together,
+        #            specifying the partition_columns.
+        CFilter_out2 = CFilter(data=df, 
+                               target_column='item', 
+                               transaction_id_columns = 'tranid',
+                               partiton_columns='storeid',
+                               max_distinct_items=100)
+
+        # Print the result DataFrame.
+        print(CFilter_out2.result)
+    """

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

@@ -22,6 +22,8 @@ def ColumnTransformer(input_data = None, bincode_fit_data = None, function_fit_d
         User must create the FIT dataframe before using the function and must be provided in the same order
         as in the training data sequence to transform the dataset. The FIT dataframe can have maximum of
         128 columns.
+        Note:
+            * ColumnTransformer() function works only with python 3.6 and above.
 
 
     PARAMETERS:

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

@@ -1,12 +1,8 @@
-def FTest(data = None, alpha = None,
-          first_sample_variance=None,
-          first_sample_column=None,
-          df1=None,
-          second_sample_variance=None,
-          second_sample_column=None,
-          df2=2,
-          alternate_hypothesis='two-tailed',
-          **generic_arguments):
+def FTest(data = None, alpha = 0.05, first_sample_variance=None,
+          first_sample_column=None, df1=None, second_sample_variance=None,
+          second_sample_column=None, df2=2, alternate_hypothesis='two-tailed',
+          sample_name_column=None, sample_value_column=None, first_sample_name=None,
+          second_sample_name=None, **generic_arguments):
     """
     DESCRIPTION:
         The FTest() function performs an F-test, for which the test statistic follows an
@@ -27,47 +23,72 @@ def FTest(data = None, alpha = None,
 
         alpha:
             Optional Argument.
-            Specifies the probability of rejecting the null hypothesis when it is true
-            (value below which null hypothesis is rejected).
-            "alpha" must be a numeric value in the range [0, 1].
+            Specifies the probability of rejecting the null 
+            hypothesis when the null hypothesis is true.
+            Note:
+                * "alpha" must be a numeric value in the range [0, 1].
             Default Value: 0.05
             Types: float
 
         first_sample_column:
-            Required if "first_sample_variance" is omitted, disallowed otherwise.
-            Specifies the name of the input column that contains the data for the
-            first sample population.
+            Optional Argument.
+            Specifies the first sample column in F-Test.
+            Note:
+                * This argument must be specified with "first_sample_variance" and "df1"
+                  or allowed combination is "first_sample_column" with 
+                  "second_sample_variance" and "df2".
+                * This argument cannot be used in conjunction with "sample_name_column"
+                  and "sample_value_column".
             Types: str
 
         first_sample_variance:
-            Required if "first_sample_column" is omitted, disallowed otherwise.
-            Specifies the variance of the first sample population.
+            Optional Argument.
+            Specifies the first sample variance.
+            Note:
+                * This argument must be specified with "first_sample_column" and "df1"
+                  or other allowed combination is "second_sample_column" with 
+                  "first_sample_variance" and "df1".
             Types: float
 
         df1:
-            Required if "first_sample_column" is omitted, disallowed otherwise.
+            Optional Argument.
             Specifies the degrees of freedom of the first sample.
+            Note:
+                * This argument must be specified with "first_sample_column" and 
+                  "first_sample_variance".
             Types: integer
 
         second_sample_column:
-            Required if "second_sample_variance" is omitted, disallowed otherwise.
-            Specifies the name of the input column that contains the data for the
-            second sample population.
+            Optional Argument.
+            Specifies the second sample column in F-Test.
+            Note:
+                * This argument must be specified with "second_sample_variance" and "df2"
+                  or allowed combination is "second_sample_column" with "first_sample_variance" 
+                  and "df1".
+                * This argument cannot be used in conjunction with "sample_name_column"
+                  and "sample_value_column".
             Types: str
 
         second_sample_variance:
-            Required if "second_sample_column" is omitted, disallowed otherwise.
-            Specifies the variance of the second sample population.
+            Optional Argument.
+            Specifies the second sample variance.
+            Note:
+                * This argument must be specified with "second_sample_column" and "df2"
+                  or allowed combination is "first_sample_column" with 
+                  "second_sample_variance" and df2.
             Types: float
 
         df2:
-            Required if "second_sample_column" is omitted, disallowed otherwise.
-            Specifies the degrees of freedom of the second sample.
+            Optional Argument.
+            Specifies the degree of freedom of the second sample.
+            Note:
+                * This argument must be specified with "second_sample_column" and 
+                  "second_sample_variance".
             Types: integer
 
         alternate_hypothesis:
             Optional Argument.
-            Specifies the alternative hypothesis.
+            Specifies the alternate hypothesis.
             Permitted Values:
                 * lower-tailed - Alternate hypothesis (H 1): μ < μ0.
                 * upper-tailed - Alternate hypothesis (H 1): μ > μ0.
@@ -79,6 +100,27 @@ def FTest(data = None, alpha = None,
             Default Value: two-tailed
             Types: str
 
+        sample_name_column:
+            Optional Argument.
+            Specifies the column name in "data" containing the names of the samples
+            included in the F-Test.
+            Types: str
+        
+        sample_value_column:
+            Optional Argument.
+            Specifies the column name in "data" containing the values for each sample member.
+            Types: str
+
+        first_sample_name:
+            Optional Argument.
+            Specifies the name of the first sample included in the F-Test.
+            Types: str
+
+        second_sample_name:
+            Optional Argument.
+            Specifies the name of the second sample included in the F-Test.
+            Types: str
+
         **generic_arguments:
             Specifies the generic keyword arguments SQLE functions accept.
             Below are the generic keyword arguments:
@@ -129,9 +171,11 @@ def FTest(data = None, alpha = None,
 
         # Load the example data.
         load_example_data("teradataml", "titanic")
+        load_example_data("ztest", 'insect2Cols')
 
         # Create teradataml DataFrame object.
         titanic_data = DataFrame.from_table("titanic")
+        insect_gp = DataFrame.from_table("insect2Cols")
 
         # Check the list of available analytic functions.
         display_analytic_functions()
@@ -158,4 +202,39 @@ def FTest(data = None, alpha = None,
 
         # Print the result DataFrame.
         print(obj.result)
+
+        # Example 3: Run FTest() with sample_name_column, sample_value_column,
+        #            first_sample_name and second_sample_name.
+        obj = FTest(data=insect_gp,
+                    sample_value_column='groupValue',
+                    sample_name_column='groupName',
+                    first_sample_name='groupE',
+                    second_sample_name='groupC')
+        
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 4: Run FTest() with sample_name_column, sample_value_column,
+        #            first_sample_name and second_sample_name.
+        obj = FTest(data=insect_gp,
+                    sample_value_column='groupValue',
+                    sample_name_column='groupName',
+                    first_sample_name='groupE',
+                    second_sample_variance=100.0,
+                    df2=25)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 5: Run FTest() with sample_name_column, sample_value_column,
+        #            second_sample_name and first_sample_variance.
+        obj = FTest(data=insect_gp,
+                    sample_value_column='groupValue',
+                    sample_name_column='groupName',
+                    second_sample_name='groupC',
+                    first_sample_variance=85.0,
+                    df1=19)
+        
+        # Print the result DataFrame.
+        print(obj.result)
     """

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

@@ -2,7 +2,9 @@ def GLM(formula=None, data=None, input_columns=None, response_column=None, famil
         iter_max=300, batch_size=10, lambda1=0.02, alpha=0.15,
         iter_num_no_change=50, tolerance=0.001, intercept=True, class_weights="0:1.0, 1:1.0",
         learning_rate=None, initial_eta=0.05, decay_rate=0.25, decay_steps=5, momentum=0.0,
-        nesterov=True, local_sgd_iterations=0, **generic_arguments):
+        nesterov=True, local_sgd_iterations=0, stepwise_direction=None, max_steps_num=5,
+        initial_stepwise_columns=None, attribute_data=None, parameter_data=None, iteration_mode="BATCH",
+        partition_column=None, **generic_arguments):
     """
     DESCRIPTION:
         The generalized linear model (GLM) function performs regression and classification
@@ -252,6 +254,55 @@ def GLM(formula=None, data=None, input_columns=None, response_column=None, famil
             Default Value: 0
             Types: int
 
+        stepwise_direction:
+            Optional Argument.
+            Specify the type of stepwise algorithm to be used.
+            Permitted Values: 'FORWARD', 'BACKWARD', 'BOTH', 'BIDIRECTIONAL'
+            Types: str
+
+        max_steps_num:
+            Optional Argument.
+            Specifies the maximum number of steps to be used for the Stepwise Algorithm.
+            Note:
+                *  The "max_steps_num" must be in the range [1, 2147483647].
+            Default Value: 5
+            Types: int
+        
+        attribute_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame containing the attribute data.
+            Note:
+                * This is valid when "data_partition_column" argument is used.
+            Types: teradataml DataFrame
+        
+        parameter_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame containing the parameter data.
+            Note:
+                * This is valid when "data_partition_column" argument is used.
+            Types: teradataml DataFrame
+        
+        iteration_mode:
+            Optional Argument.
+            Specifies the iteration mode.
+            Note:
+                * This is valid when "data_partition_column" argument is used.
+            Permitted Values: 'BATCH', 'EPOCH'
+            Default Value: 'BATCH'
+            Types: str
+
+        partition_column:
+            Optional Argument.
+            Specifies the column names of "data" on which to partition the input.
+            The name should be consistent with the "data_partition_column".
+            Note:
+                * If the "data_partition_column" is unicode with foreign language characters, 
+                  it is necessary to specify "partition_column" argument. 
+                * Column range is not supported for "partition_column" argument. 
+                * This is valid when "data_partition_column" argument is used.
+            Types: str
+        
+
         **generic_arguments:
             Specifies the generic keyword arguments SQLE functions accept. Below
             are the generic keyword arguments:
@@ -377,4 +428,114 @@ def GLM(formula=None, data=None, input_columns=None, response_column=None, famil
         # Print the result DataFrame.
         print(GLM_out_2.result)
         print(GLM_out_2.output_data)
+
+        # Example 3 : Generate generalized linear model(GLM) using stepwise regression algorithm.
+        #             This example uses the boston dataset and scales the data.
+        #             Scaled data is used as input data to generate the GLM model.
+        # loading the example data
+        load_example_data("decisionforest", ["boston"])
+        load_example_data('glm', ['housing_train_segment', 'housing_train_parameter', 'housing_train_attribute'])
+
+        # Create teradataml DataFrame objects.
+        boston_df = DataFrame('boston')
+        housing_seg = DataFrame('housing_train_segment')
+        housing_parameter = DataFrame('housing_train_parameter')
+        housing_attribute = DataFrame('housing_train_attribute')
+
+        # Scaling the data
+        # Scale "target_columns" with respect to 'STD' value of the column.
+        fit_obj = ScaleFit(data=boston_df,
+                        target_columns=['crim','zn','indus','chas','nox','rm','age','dis','rad','tax','ptratio','black','lstat',],
+                        scale_method="STD")
+
+        # Scale values specified in the input data using the fit data generated by the ScaleFit() function above.
+        obj = ScaleTransform(object=fit_obj.output,
+                            data=boston_df,
+                            accumulate=["id","medv"])
+
+        boston = obj.result
+
+        # Generate generalized linear model(GLM) using stepwise regression algorithm.
+        glm_1 = GLM(data=boston,
+                    input_columns=['indus','chas','nox','rm'],
+                    response_column='medv',
+                    family='GAUSSIAN',
+                    lambda1=0.02,
+                    alpha=0.33,
+                    batch_size=10,
+                    learning_rate='optimal',
+                    iter_max=36,
+                    iter_num_no_change=100,
+                    tolerance=0.0001,
+                    initial_eta=0.02,
+                    stepwise_direction='backward',
+                    max_steps_num=10)
+        
+        # Print the result DataFrame.
+        print(glm_1.result)
+
+        # Example 4 : Generate generalized linear model(GLM) using
+        #             stepwise regression algorithm with initial_stepwise_columns.
+        glm_2 = GLM(data=boston,
+                    input_columns=['crim','zn','indus','chas','nox','rm','age','dis','rad','tax','ptratio','black','lstat'],
+                    response_column='medv',
+                    family='GAUSSIAN',
+                    lambda1=0.02,
+                    alpha=0.33,
+                    batch_size=10,
+                    learning_rate='optimal',
+                    iter_max=36,
+                    iter_num_no_change=100,
+                    tolerance=0.0001,
+                    initial_eta=0.02,
+                    stepwise_direction='bidirectional',
+                    max_steps_num=10,
+                    initial_stepwise_columns=['rad','tax']
+            )
+
+        # Print the result DataFrame.
+        print(glm_2.result)
+
+        # Example 5 : Generate generalized linear model(GLM) using partition by key.
+        glm_3 = GLM(data=housing_seg,
+                    input_columns=['bedrooms', 'bathrms', 'stories', 'driveway', 'recroom', 'fullbase', 'gashw', 'airco'],
+                    response_column='price',
+                    family='GAUSSIAN',
+                    batch_size=10,
+                    iter_max=1000,
+                    data_partition_column='partition_id'
+                    )
+
+        # Print the result DataFrame.
+        print(glm_3.result)
+
+        # Example 6 : Generate generalized linear model(GLM) using partition by key with attribute data.
+        glm_4 = GLM(data=housing_seg,
+                    input_columns=['bedrooms', 'bathrms', 'stories', 'driveway', 'recroom', 'fullbase', 'gashw', 'airco'],
+                    response_column='price',
+                    family='GAUSSIAN',
+                    batch_size=10,
+                    iter_max=1000,
+                    data_partition_column='partition_id',
+                    attribute_data = housing_attribute,
+                    attribute_data_partition_column = 'partition_id'
+                    )
+
+        # Print the result DataFrame.
+        print(glm_4.result)
+
+        # Example 7 : Generate generalized linear model(GLM) using partition by key with parameter data
+        glm_5 = GLM(data=housing_seg,
+                    input_columns=['bedrooms', 'bathrms', 'stories', 'driveway', 'recroom', 'fullbase', 'gashw', 'airco'],
+                    response_column='homestyle',
+                    family='binomial',
+                    iter_max=1000,
+                    data_partition_column='partition_id',
+                    parameter_data = housing_parameter,
+                    parameter_data_partition_column = 'partition_id'
+                    )
+
+        # Print the result DataFrame.
+        print(glm_5.result)
+
     """