teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,186 @@
+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
+        a data set with two or more groups. ANOVA is a statistical test that
+        analyzes the difference between the means of more than two groups.
+
+        The null hypothesis (H0) of ANOVA is that there is no difference among
+        group means. However, if any one of the group means is significantly
+        different from the overall mean, then the null hypothesis is rejected.
+        You can use one-way Anova when you have data on an independent variable
+        with at least three levels and a dependent variable.
+
+        For example, assume that your independent variable is insect spray type,
+        and you have data on spray type A, B, C, D, E, and F. You can use one-way
+        ANOVA to determine whether there is any difference in the dependent variable,
+        insect count based on the spray type used.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        group_columns:
+            Optional Argument.
+            Specifies the names of the columns in "data" to use in the computation.
+            Note:
+                Users must specify at least two columns in "group_columns" list.
+            Types: list of Strings (str)
+
+        alpha:
+            Optional Argument.
+            Specifies the probability of rejecting the null hypothesis when the null
+            hypothesis is true.
+            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:
+                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 ANOVA.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ANOVAObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # 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()
+
+        # Example 1 : Perform one-way anova analysis on a data set with
+        #             two or more groups.
+        ANOVA_out_1 = ANOVA(data = insect_sprays,
+                            alpha = 0.05
+                            )
+
+        # Print the result DataFrame.
+        print(ANOVA_out_1.result)
+
+        # Example 2 : Perform one-way anova analysis on a data set with more
+        #             than two groups and group_columns argument specified.
+        ANOVA_out_2 = ANOVA(data = insect_sprays,
+                            group_columns=insect_sprays.columns[2:5],
+                            alpha = 0.05
+                            )
+
+        # 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/Antiselect.py

@@ -0,0 +1,83 @@
+def Antiselect(data=None, exclude=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        Antiselect() function returns all columns except those specified in the Exclude syntax element.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        exclude:
+            Required Argument.
+            Specifies the names of the columns not to return.
+            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: boolean
+
+                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: boolean
+
+            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 Antiselect.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as AntiselectObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Load the example data.
+        load_example_data("antiselect", ["antiselect_input"])
+
+        # Create teradataml DataFrame object.
+        antiselect_input = DataFrame.from_table("antiselect_input")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Returns all columns except those specified in the exclude argument.
+        obj = Antiselect(data=antiselect_input,
+                         exclude=['rowids', 'orderdate', 'discount', 'province', 'custsegment'])
+
+        # Print the result.
+        print(obj.result)
+
+    """

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

@@ -0,0 +1,138 @@
+def Apriori(data=None, target_column=None, id_column=None, partition_columns=None,
+            max_len=2, delimiter=",", is_dense_input=False, patterns_or_rules=None,
+            support=0.01, **generic_arguments):
+    """
+    DESCRIPTION:
+        The Apriori() function finds patterns and calculates different statistical metrics to
+        understand the influence of the occurrence of a set of items on others.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_column:
+            Required Argument.
+            Specifies the input teradataml DataFrame column which contains the data to filter.
+            Types: str
+
+        id_column:
+            Optional Argument.
+            Specifies the name of the column that uniquely groups the items that are purchased together. 
+            Applicable only when `is_dense_input` is False.
+            Types: str
+
+        partition_columns:
+            Optional Argument.
+            Specifies the column name(s) in the "data" to partition the input.
+            Types: str or list of str
+
+        max_len:
+            Optional Argument.
+            Specifies the maximum number of items in the item set. 
+            "max_len" must be greater than or equal to 1 and less than or equal to 20.
+            Default Value: 2
+            Types: int
+
+        delimiter:
+            Optional Argument, Required when "is_dense_input" is set to True.
+            Specifies a character or string that separates words in the input text.
+            Default Value: ","
+            Types: str
+
+
+        is_dense_input:
+            Optional Argument.
+            Specifies whether input data is in dense format or not. 
+            When set to True, function considers the  data is in dense format. 
+            Otherwise function considers  data is not in dense format.
+            Default Value: False
+            Types: bool
+
+        patterns_or_rules:
+            Optional Argument.
+            Specifies whether to emit PATTERNS or RULES as output.
+            Permitted Values: "PATTERNS", "RULES"
+            Types: str
+
+        support:
+            Optional Argument.
+            Specifies the support value (minimum occurrence threshold) of the itemset.
+            Default Value: 0.01
+            Types: float
+
+        **generic_arguments:
+            Optional Argument.
+            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 SQLE Engine
+                function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of Apriori.
+        Output teradataml DataFrames can be accessed using attribute references, such as AprioriObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in the example from teradataml.
+        #     3. Function will raise an error if not supported on the Vantage user is connected to.
+
+        # Load the example data.
+        load_example_data("apriori", ["trans_dense","trans_sparse"])
+
+        # Create teradataml DataFrame objects.
+        dense_table = DataFrame.from_table("trans_dense")
+        sparse_table = DataFrame.from_table("trans_sparse")
+
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function Apriori.
+        from teradataml import Apriori
+
+        # Example 1: Find patterns in the input data with DENSE DATA, PARTITION,RULES .
+        Apriori_out = Apriori(data=dense_table, target_column="item",
+                              partition_columns=["location"], max_len=2,
+                              patterns_or_rules="rules", support=0.01)
+
+        # Print the result DataFrame.
+        print(Apriori_out.result)
+
+        # Example 2: Find patterns in the input data with SPARSE DATA, NO PARTITIONS, PATTERNS.
+        Apriori_out = Apriori(data=sparse_table, target_column="item",
+                              id_column="tranid", max_len=3)
+                                    
+        # Print the result DataFrame.
+        print(Apriori_out.result)
+    """

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

@@ -0,0 +1,201 @@
+def Attribution(data=None, data_optional=None, data_optional2=None, data_optional3=None, data_optional4=None,
+                conversion_data=None, excluding_data=None, optional_data=None, model1_type=None, model2_type=None,
+                event_column=None, timestamp_column=None, window_size=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The Attribution() function is used in web page analysis, where it lets
+        companies assign weights to pages before certain events, such as
+        buying a product.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        data_optional:
+            Optional Argument.
+            Specifies the click stream data, which the function uses to compute
+            attributions.
+            Types: teradataml DataFrame
+
+        data_optional2:
+            Optional Argument.
+            Specifies the click stream data, which the function uses to compute
+            attributions.
+            Types: teradataml DataFrame
+
+        data_optional3:
+            Optional Argument.
+            Specifies the click stream data, which the function uses to compute
+            attributions.
+            Types: teradataml DataFrame
+
+        data_optional4:
+            Optional Argument.
+            Specifies the click stream data, which the function uses to compute
+            attributions.
+            Types: teradataml DataFrame
+
+        conversion_data:
+            Required Argument.
+            Specifies one varchar column (conversion_events) containing conversion
+            event values.
+            Types: teradataml DataFrame
+
+        excluding_data:
+            Optional Argument.
+            Specifies one varchar column (excluding_events) containing excluding
+            cause event values.
+            Types: teradataml DataFrame
+
+        optional_data:
+            Optional Argument.
+            Specifies one varchar column (optional_events) containing optional
+            cause event values.
+            Types: teradataml DataFrame
+
+        model1_type:
+            Required Argument.
+            Specifies the type and specification of the first model.
+            For example:
+                +----+----------------------+
+                | id |        model         |
+                +----+----------------------+
+                | 0  |   SEGMENT_SECONDS    |
+                |    |                      |
+                | 1  |   6:0.5:UNIFORM:NA   |
+                |    |                      |
+                | 2  | 8:0.3:LAST_CLICK:NA  |
+                |    |                      |
+                | 3  | 6:0.2:FIRST_CLICK:NA |
+                +----+----------------------+
+            Types: teradataml DataFrame
+
+        model2_type:
+            Optional Argument.
+            Specifies the type and distributions of the second model.
+            For example:
+                +----+--------------------------------+
+                | id |             model              |
+                +----+--------------------------------+
+                | 0  |          SEGMENT_ROWS          |
+                |    |                                |
+                | 1  |  3:0.5:EXPONENTIAL:0.5,SECOND  |
+                |    |                                |
+                | 2  | 4:0.3:WEIGHTED:0.4,0.3,0.2,0.1 |
+                |    |                                |
+                | 3  |      3:0.2:FIRST_CLICK:NA      |
+                +----+--------------------------------+
+            Types: teradataml DataFrame
+
+        event_column:
+            Required Argument.
+            Specifies the name of the input column that contains the clickstream
+            events.
+            Types: str
+
+        timestamp_column:
+            Required Argument.
+            Specifies the name of the input column that contains the timestamps
+            of the clickstream events.
+            Types: str
+
+        window_size:
+            Required Argument.
+            Specifies how to determine the maximum window size for the
+            attribution calculation: rows:K: Consider the maximum number of
+            events to be attributed, excluding events of types specified in
+            excluding_event_table, which means assigning attributions to at most
+            K effective events before the current impact event.seconds:K:
+            Consider the maximum time difference between the current impact event
+            and the earliest effective event to be attributed. rows:K&seconds:K2:
+            Consider both constraints and comply with the stricter one.
+            Types: 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: boolean
+
+                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: boolean
+
+            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
+                SQLE function supports it, else an exception is raised.
+
+    RETURNS:
+        Instance of Attribution.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as AttributionObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Load the data to run the example
+        load_example_data("attribution", ["attribution_sample_table1",
+        "attribution_sample_table2" , "conversion_event_table",
+        "optional_event_table", "model1_table", "model2_table"])
+
+        # Create teradataml DataFrame objects
+        attribution_sample_table1 = DataFrame.from_table("attribution_sample_table1")
+        attribution_sample_table2 = DataFrame.from_table("attribution_sample_table2")
+        conversion_event_table = DataFrame.from_table("conversion_event_table")
+        optional_event_table = DataFrame.from_table("optional_event_table")
+        model1_table = DataFrame.from_table("model1_table")
+        model2_table = DataFrame.from_table("model2_table")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Assign attribution weights to events and channels.
+        attribution_out = Attribution(data=attribution_sample_table1,
+                                      data_partition_column="user_id",
+                                      data_order_column="time_stamp",
+                                      data_optional=attribution_sample_table2,
+                                      data_optional_partition_column='user_id',
+                                      data_optional_order_column='time_stamp',
+                                      event_column="event",
+                                      conversion_data=conversion_event_table,
+                                      optional_data=optional_event_table,
+                                      timestamp_column = "time_stamp",
+                                      window_size = "rows:10&seconds:20",
+                                      model1_type=model1_table,
+                                      model2_type=model2_table)
+
+        # Print the results DataFrame.
+        print(attribution_out.result)
+
+    """